Elegante Art zum zählen der Häufigkeit von Wörtern in einer Datei

Zunächst definiere ich letter_only std::locale so zu ignorieren Satzzeichen kommen aus dem stream, und Lesen nur gültig, "Englisch" Briefe aus dem input-stream. So, der stream wird die Behandlung der Wörter "ways", "ways." und "ways!" als nur das gleiche Wort "ways", weil der stream wird ignoriert die Interpunktion wie "." und "!".

struct letter_only: std::ctype<char> 
{
    letter_only(): std::ctype<char>(get_table()) {}

    static std::ctype_base::mask const* get_table()
    {
        static std::vector<std::ctype_base::mask> 
            rc(std::ctype<char>::table_size,std::ctype_base::space);

        std::fill(&rc['A'], &rc['z'+1], std::ctype_base::alpha);
        return &rc[0];
    }
};

Lösung 1

int main()
{
     std::map<std::string, int> wordCount;
     ifstream input;
     input.imbue(std::locale(std::locale(), new letter_only())); //enable reading only letters!
     input.open("filename.txt");
     std::string word;
     while(input >> word)
     {
         ++wordCount[word];
     }
     for (std::map<std::string, int>::iterator it = wordCount.begin(); it != wordCount.end(); ++it)
     {
           cout << it->first <<" : "<< it->second << endl;
     }
}

Lösung 2

struct Counter
{
    std::map<std::string, int> wordCount;
    void operator()(const std::string & item) { ++wordCount[item]; }
    operator std::map<std::string, int>() { return wordCount; }
};

int main()
{
     ifstream input;
     input.imbue(std::locale(std::locale(), new letter_only())); //enable reading only letters!
     input.open("filename.txt");
     istream_iterator<string> start(input);
     istream_iterator<string> end;
     std::map<std::string, int> wordCount = std::for_each(start, end, Counter());
     for (std::map<std::string, int>::iterator it = wordCount.begin(); it != wordCount.end(); ++it)
     {
          cout << it->first <<" : "<< it->second << endl;
     }
 }

InformationsquelleAutor Nawaz

Meine Lösung ist die folgende. Erstens, alle Symbole werden in Leerzeichen umgewandelt. Dann, im Grunde die gleiche Lösung, die hier bereitgestellt werden, bevor Sie verwendet werden, um zu extrahieren Worten:

const std::string Symbols = ",;.:-()\t!¡¿?\"[]{}&<>+-*/=#'";
typedef std::map<std::string, unsigned int> WCCollection;
void countWords(const std::string fileName, WCCollection &wcc)
    {
        std::ifstream input( fileName.c_str() );

        if ( input.is_open() ) {
            std::string line;
            std::string word;

            while( std::getline( input, line ) ) {
                //Substitute punctuation symbols with spaces
                for(std::string::const_iterator it = line.begin(); it != line.end(); ++it) {
                    if ( Symbols.find( *it ) != std::string::npos ) {
                        *it = ' ';
                    }

                }

                //Let std::operator>> separate by spaces
                std::istringstream filter( line );
                while( filter >> word ) {
                    ++( wcc[word] );
                }
            }
        }

    }

InformationsquelleAutor Baltasarq

Perl ist wohl nicht so elegant, aber sehr effektiv.

Ich habe eine Lösung hier: Verarbeitung von großen text-Dateien

In einer nussschale,

1), Wenn nötig, strip Satzzeichen und Großbuchstaben in Kleinbuchstaben umwandeln:

perl -pe "s/[^a-zA-Z \t\n']//g; tr/A-Z/a-z/" file_raw > file

2) Anzahl des Auftretens jedes Wortes. Drucken Sie die Ergebnisse geordnet nach Häufigkeit und dann alphabetisch:

perl -lane '$h{$_}++ for @F; END{for $w (sort {$h{$b}<=>$h{$a} || $a cmp $b} keys %h) {print "$h{$w}\t$w"}}' file > freq

Lief ich diesen code auf eine 3,3 GB-text-Datei mit 580,000,000 Wörter.

Perl 5.22 abgeschlossen in unter 3 Minuten.

InformationsquelleAutor Chris Koknat

1. Entscheiden, was genau meinen Sie mit "ein Wort". Sollte die definition Abdeckung Dinge wie, ob "wehrfähigen" ist ein Wort oder zwei, wie man mit Apostrophen ("Don 'T trust' em!"), ob die groß /Kleinschreibung ist signifikant, etc.

2. Erstellen Sie eine Reihe von Testfällen, so dass Sie können sicher sein, Sie bekommen alle Entscheidungen in Schritt 1 korrekt.

3. Erstellen Sie einen tokenizer, der liest das nächste Wort (wie definiert in Schritt 1) aus der Eingabe und gibt es in einer standard-form. Je nachdem, wie Ihre definition, könnte dies einen einfachen Zustandsautomaten, einen regulären Ausdruck oder nur unter Berufung auf <istream>'s Gewinnung von Operatoren (z.B. std::cin >> word;). Testen Sie Ihre tokenizer mit allen Testfällen aus Schritt 2.

4. Wählen Sie eine Datenstruktur, die für die Beibehaltung der Wörter und Anzahl. In modernem C++, würden Sie wahrscheinlich am Ende mit etwas wie std::map<std::string, unsigned> oder std::unordered_map<std::string, int>.

5. Schreiben Sie eine Schleife, die bekommt das nächste Wort aus der Segmentierer und erhöht seine Zählung in dem Histogramm, bis es nicht mehr Wörter in der Eingabe.

InformationsquelleAutor Adrian McCarthy