Zählen von vorkommen in einem Vektor

Dieses Programm liest zahlen aus einer txt-Datei, wandelt Sie in ganzen zahlen, speichert Sie in einem Vektor, und dann versucht die Ausgabe in einer organisierten Art und Weise wie so....

Wenn txt-Datei sagt:

7 5 5 7 3 117 5

Programm-Ausgänge:

also, wenn die Zahl mehr als einmal vorkommt ausgibt, wie oft das passiert. Hier ist der code, so weit.

#include "std_lib_facilities.h"

int str_to_int(string& s)
{
    stringstream ss(s);
    int num;
    ss >> num;
    return num;
}

int main()
{
    cout << "Enter file name.\n";
    string file;
    cin >> file;
    ifstream f(file.c_str(), ios::in);

    string num;
    vector<int> numbers;
    while(f>>num)
    {
        int number = str_to_int(num);
        numbers.push_back(number);
    }

    sort(numbers.begin(), numbers.end());

    for(int i = 0; i < numbers.size(); ++i)
    {
     if(i = 0 && numbers[i]!= numbers[i+1]) cout << numbers[i] << endl;
     if(i!=0 && numbers[i]!= numbers[i-1])
     {
          cout << numbers[i] << '\t' << counter << endl;
          counter = 0;
     }
     else ++counter;
    }
 }

Edit: Programm stecken. Suchen Sie eine unendliche Schleife jetzt.

Nein, es ist nicht Hausaufgaben. Lesen Profil.
Dein Fehler ist, wenn(i = 0). Sie wollen mit ==. Einzelnes Gleichheitszeichen ist die Zuweisung.
Gah, ich mache immer, wenn ich zu tun != wie gut.
Warum wurde das nicht geschlossen? Er hatte noch nicht einmal eine Frage stellen.
Die änderung der Frage in dieser Art und Weise führen zum erlöschen der ursprünglichen Antworten. Es ist wahrscheinlich am besten, zu akzeptieren, eine Antwort auf die ursprüngliche und starten Sie eine neue Frage für ein neues problem.

InformationsquelleAutor trikker | 2009-07-30

c++

6

Wie wäre es mit einer Karte, wo der Schlüssel ist die Nummer, die Sie sind tracking und der Wert ist die Anzahl der vorkommen?

Wenn Sie müssen, verwenden Sie einen Vektor, Sie habe bereits sortiert. So verfolgen Sie die Nummer, die Sie zuvor sah. Wenn es das gleiche ist wie die aktuelle Anzahl, Inkrementieren Sie den Zähler. Jedes mal, wenn die Anzahl der änderungen: drucken Sie die aktuelle Nummer und die Anzahl, zurücksetzen der Zähler, legen Sie die last_seen-Nummer auf die neue Nummer.

Lesen rückwärts Lesen, anstatt vor, natürlich. Ich poste, was ich umgesetzt habe, für einige Grund, warum das Programm hängen bleibt. Es muss eine Endlosschleife in dort irgendwo.
Ist ein std::vector sortiert an? @
Nein, es ist nicht sortiert. OP-code hat sort(numbers.begin(), numbers.end());

InformationsquelleAutor bstpierre
8

Könnten Sie eine Karte von zahlen zu Zählern:
```
typedef map<int,unsigned int> CounterMap;
CounterMap counts;
for (int i = 0; i < numbers.size(); ++i)
{
   CounterMap::iterator it(counts.find(numbers[i]));
   if (it != counts.end()){
      it->second++;
   } else {
      counts[numbers[i]] = 1;
   }
}
```
... dann Durchlaufen die Karte, das drucken der Ergebnisse.

BEARBEITEN:
Wie vorgeschlagen, durch lazypython: wenn Sie die TR1-Erweiterungen [wikipedia.org] zur Verfügung, unordered_map sollte besser die Leistung...
```
typedef std::tr1::unordered_map<int,unsigned int> CounterMap;
CounterMap counts;
for (int i = 0; i < numbers.size(); ++i)
{
   CounterMap::iterator it(counts.find(numbers[i]));
   if (it != counts.end()){
      it->second++;
   } else {
      counts[numbers[i]] = 1;
   }
}
```
Ich würde die Verwendung einer hashmap (oder eine ungeordnete map, oder was auch immer Sie Sie nennen in der tr1). Sie haben O(nlgn) - Leistung in Anzahl der Einträge, während eine hashmap wird O(nlgn) performance in der Anzahl der keys der Karte, die für irgendeine große Anwendung, die die Anzahl der Einträge wird Zwerg der Anzahl der Tasten.
btw, dies bedeutet nicht, dass der Vektor sortiert werden ersten.
guter Punkt. Ich dachte nur über die Basis der stl-Version. Ich glaube nicht, dass ein toy-Programm wie dieses beschäftigt sich mit der Geschwindigkeit, aber ich nehme an, es ist am besten zu lernen, die richtigen Techniken in der ersten Zeit.

InformationsquelleAutor Adam Holmberg
3

Mit Hilfe einer Karte ist die praktische Lösung. Was Sie tun sollten, um dieses problem zu lösen 🙂

Dies wird als Frequenz-Zähler. Also, Sie haben einen sortierten Vektor-und alles, was Sie tun müssen, ist die Anzahl der aufeinanderfolgenden gleichen zahlen. In anderen Worten, Sie haben zu prüfen, jede Zahl mit Ihrem Nachfolger.
```
for(size_t i = 0; i < numbers.size(); i++)
{
    size_t count = 1;

    size_t limit = numbers.size() - 1;
    while(i < limit  && numbers[i] == numbers[i+1])
    {
        count++;
        i++;
    }

    std::cout << numbers[i] << "\t" << count << std::endl;
}   
```
InformationsquelleAutor AraK
1

Dieses Programm liest zahlen
aus einer txt-Datei, wandelt Sie um
Ganzzahlen, speichert Sie in einem Vektor -, und
dann versucht die Ausgabe in eine
organisiert Mode-wie so....(Hervorhebung Hinzugefügt)

Was ist der Sinn dieser Speicher Schritt? Wenn Sie beim Lesen der zahlen aus einer Datei, dann werden Sie Sie schon haben, um, bereit, verarbeitet werden (gezählt) werden nacheinander, wie Sie Ihnen begegnen können.

Jedoch bräuchte ich eine Möglichkeit für Sie zu wissen, wenn es sieht eine neue Nummer.

Empfehle ich Ihnen einen Blick auf std::set oder std::map. Ich erwarte, dass entweder dieser Behälter tun würde, was Sie suchen.

InformationsquelleAutor SingleNegationElimination

Std::count() passt die Rechnung gut.

std::vector<int>::const_iterator cur = numbers.begin();
std::vector<int>::const_iterator last = numbers.end();
while (cur != last) {
    unsigned cnt = std::count(cur, last, *cur);
    std::cout << *cur;
    if (cnt != 1) {
        std::cout << " " << c;
    }
    std::cout << std::endl;
    int saved = *cur;
    while (*cur == saved) {
        ++cur;
    }
}

Natürlich gibt es eine Reihe von anderen algorithmen gibt, die denselben job erledigen. Spielen mit Dingen wie std::equal_range() in Verbindung mit std::distance() wird den job zu erledigen gerade so schön.

InformationsquelleAutor D.Shawley

Das war ein Spaß:

#include <map>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <iterator>

struct IncrementMap
{
    IncrementMap(std::map<int,int>& m): m_map(m)    {}
        void operator()(int val) const
    {
        ++m_map[val];
    }
    std::map<int,int>& m_map;
};
struct SpecialPrint
{
    SpecialPrint(std::ostream& s):  m_str(s)    {}
    void operator()(std::map<int,int>::value_type const& value) const
    {
        m_str << value.first;
        if (value.second != 1)
        {
            m_str << "\t" << value.second;
        }
        m_str << "\n";
    }
    std::ostream&   m_str;
};
int main()
{
    std::fstream        x("Plop");
    std::map<int,int>   data;

    std::for_each(  std::istream_iterator<int>(x),
                     std::istream_iterator<int>(),
                     IncrementMap(data)
                );
    std::for_each(  data.begin(),
                    data.end(),
                    SpecialPrint(std::cout)
                );
}

InformationsquelleAutor Martin York

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.