计算每个单词在文件中出现的次数

Question

您好我正在编写一个程序来计算每个单词在文件中出现的次数。 然后它打印一个单词列表，其中单词的计数在 800 到 1000 之间，并按计数顺序排序。 在出现新词之前，我一直坚持使用计数器来查看第一个词是否与下一个词匹配。 主要是我试图打开文件，逐字读取每个单词并在 while 循环中调用 sort 来对向量进行排序。 然后，在 for 循环 go 中遍历所有单词，如果第一个单词等于第二个 count++。 我不认为那是你保持柜台的方式。

这是代码：

#include <string>
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <set>

using namespace std;

vector<string> lines;
vector<int> second;
set<string> words;
multiset<string> multiwords;

void readLines(const char *filename)
{
    string line;
    ifstream infile;
    infile.open(filename);
    if (!infile)
    {       
        cerr << filename << " cannot open" << endl; 
          return; 
    }       
    getline(infile, line);
    while (!infile.eof())
    {
        lines.push_back(line);
        getline(infile, line);
    }  
    infile.close();
}

int binary_search(vector<string> &v, int size, int value)
{
    int from = 0;
    int to = size - 1;
    while (from <= to)
    {  
        int mid = (from + to) / 2;
        int mid_count = multiwords.count(v[mid]);
        if (value == mid_count) 
            return mid;
        if (value < mid_count) to = mid - 1;
        else from = mid + 1;
    }
   return from;
}

int main() 
{
    vector<string> words;
    string x;
    ifstream inFile;
    int count = 0;

    inFile.open("bible.txt");
    if (!inFile) 
    {
        cout << "Unable to open file";
        exit(1);
    }
    while (inFile >> x){
        sort(words.begin(), words.end());
    }

    for(int i = 0;i < second.size();i++)
    {
        if(x == x+1)
        {
            count++;
        }
        else
            return;
    }
    inFile.close();
}

Answer 1

他。 我知道直截了当地展示解决方案并不能真正帮助您。 然而。

我浏览了您的代码，看到了许多未使用和混淆的部分。 这是我要做的：

#include <algorithm>
#include <fstream>
#include <functional>
#include <iostream>
#include <iterator>
#include <map>
#include <string>
#include <vector>

using namespace std;

// types
typedef std::pair<string, size_t> frequency_t;
typedef std::vector<frequency_t> words_t;

// predicates
static bool byDescendingFrequency(const frequency_t& a, const frequency_t& b)
{ return a.second > b.second; }

const struct isGTE // greater than or equal
{ 
    size_t inclusive_threshold;
    bool operator()(const frequency_t& record) const 
        { return record.second >= inclusive_threshold; }
} over1000 = { 1001 }, over800  = { 800 };

int main() 
{
    words_t words;
    {
        map<string, size_t> tally;

        ifstream inFile("bible.txt");
        string s;
        while (inFile >> s)
            tally[s]++;

        remove_copy_if(tally.begin(), tally.end(), 
                       back_inserter(words), over1000);
    }

    words_t::iterator begin = words.begin(),
                      end = partition(begin, words.end(), over800);
    std::sort(begin, end, &byDescendingFrequency);

    for (words_t::const_iterator it=begin; it!=end; it++)
        cout << it->second << "\t" << it->first << endl;
}

授权版本：

993 because
981 men
967 day
954 over
953 God,
910 she
895 among
894 these
886 did
873 put
868 thine
864 hand
853 great
847 sons
846 brought
845 down
819 you,
811 so

普通话：

995 tuum
993 filius
993 nec
966 suum
949 meum
930 sum
919 suis
907 contra
902 dicens
879 tui
872 quid
865 Domine
863 Hierusalem
859 suam
839 suo
835 ipse
825 omnis
811 erant
802 se

两个文件的性能大约为 1.12 秒，但在将map<>替换为boost::unordered_map<>后只有 0.355 秒

Answer 2

更有效的方法可以使用单个map< string, int >出现，逐个读取单词，并在m[ word ]中增加计数器。 在考虑了所有单词之后，遍历 map，对于给定范围内的单词，将它们添加到multimap<int, string> 。 最后转储多图的内容，将按出现次数和字母顺序排序...

Answer 3

一种解决方案可能是：定义letter_only语言环境以忽略来自 stream 的标点符号，并仅读取来自输入 stream 的有效“英文”字母。 这样，stream 将处理“方式”、“方式”等词。 和“方式！” 就像“方式”一样，因为 stream 将忽略像“。”这样的标点符号。 和 ”。”。

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];
    }
};

然后将其用作：

int main()
{
     std::map<std::string, int> wordCount;
     ifstream input;

     //enable reading only english letters only!
     input.imbue(std::locale(std::locale(), new letter_only())); 

     input.open("filename.txt");
     std::string word;
     std::string uppercase_word;
     while(input >> word)
     {
         std::transform(word.begin(), 
                        word.end(), 
                        std::back_inserter(uppercase_word),
                        (int(&)(int))std::toupper); //the cast is needed!
         ++wordCount[uppercase_word];
     }
     for (std::map<std::string, int>::iterator it = wordCount.begin(); 
                                               it != wordCount.end(); 
                                               ++it)
     {
           std::cout << "word = "<< it->first 
                     <<" : count = "<< it->second << std::endl;
     }
}

Answer 4

只是为了好玩，我使用Boost MultiIndex做了一个 c++0x 风格的解决方案。

如果没有auto关键字（类型推断），这种风格会非常笨拙。

通过始终按单词和频率维护索引，无需删除、分区或排序单词表：一切都会在那里。

编译和运行：

g++ --std=c++0x -O3 test.cpp -o test
curl ftp://ftp.funet.fi/pub/doc/bible/texts/english/av.tar.gz |
    tar xzO | sed 's/^[ 0-9:]\+//' > bible.txt
time ./test

.

#include <boost/foreach.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/member.hpp>
#include <fstream>
#include <iostream>
#include <string>

using namespace std;

struct entry 
{
    string word;
    size_t freq;
    void increment() { freq++; }
};

struct byword {}; // TAG
struct byfreq {}; // TAG

int main() 
{
    using ::boost::lambda::_1;
    using namespace ::boost::multi_index;
    multi_index_container<entry, indexed_by< // sequenced<>,
            ordered_unique    <tag<byword>, member<entry,string,&entry::word> >, // alphabetically
            ordered_non_unique<tag<byfreq>, member<entry,size_t,&entry::freq> > // by frequency
                > > tally;

    ifstream inFile("bible.txt");
    string s;
    while (inFile>>s)
    {
        auto& lookup = tally.get<byword>();
        auto it = lookup.find(s);

        if (lookup.end() != it)
            lookup.modify(it, boost::bind(&entry::increment, _1));
        else
            lookup.insert({s, 1});
    }

    BOOST_FOREACH(auto e, tally.get<byfreq>().range(800 <= _1, _1 <= 1000))
        cout << e.freq << "\t" << e.word << endl;

}

注意如何

• 定义自定义entry类型而不是使用std::pair变得稍微方便一些

• （出于显而易见的原因），这比我之前的代码慢：这在插入阶段按频率维护索引。 这是不必要的，但它可以更有效地提取 [800,1000] 范围：

  tally.get<byfreq>().range(800 <= _1, _1 <= 1000)

多组频率已经排序。 因此，实际的速度/内存交易可能会倾向于这个版本，特别是当文档很大并且包含很少重复的单词时（唉，这是一个已知的属性不适用于圣经的语料库文本，以免有人把它翻译成新白）。

Answer 5

随着 C++ 20 中可用的更多现代功能，我们现在可以给出改进的答案。 通过使用新可用的 STL 容器，我们只需几条语句就可以完成整个任务。

“计数”几乎有一个通用的解决方法。 我们可以使用std::unordered_map 。 此处的 C++ 参考中对此进行了描述。

std::unordered_map非常方便的索引运算符[]使计数变得非常简单。 此运算符返回对映射到键的值的引用。 因此，它搜索键然后返回值。 如果该键不存在，它会插入一个新的键/值对并返回对该值的引用。

因此，无论如何，都会返回对该值的引用。 这可以增加。 例子：

使用“std::unordered_map<char, int> mymap{};” 和文本“aba”，可以使用索引运算符完成以下操作：

• mymap['a'] 将在 map 中搜索一个 'a'。它没有找到，因此为 'a' 创建一个对应值为 0 的新条目：返回对值的引用。 而且，如果我们现在增加它，我们将增加计数器值。 因此， mymap['a']++将插入一个新的 gey/value 对 'a'/0，然后递增它，得到 'a'/1
• 对于“b”，将发生与上述相同的情况。
• 对于下一个 'a'，将在 map 中找到一个条目，因此返回对值 (1) 的引用。 这是递增的，然后将是 2

等等等等。

当然，我们将在示例中使用std::string作为键。

排序类似简单。 我们只需将所有内容插入std::multimap ，交换键和值。然后根据频率对所有内容进行排序。

借助std::multimap非常方便的lower_bound和upper_bound function，我们可以轻松找到并显示请求的值。

所有这些都将产生一个紧凑的代码示例：

#include <iostream>
#include <fstream>
#include <string>
#include <unordered_map>
#include <map>
#include <iterator>
#include <ranges>
#include <iomanip>

namespace rng = std::ranges;                // Abbreviation for the ranges namespace

int main() {

    // Open bible text file and check, if it could be opened
    if (std::ifstream ifs{ "r:\\bible.txt" }; ifs) {
        
        // Read all words from file and count them
        std::unordered_map<std::string, std::size_t> counter{};
        for (const auto& word : rng::istream_view<std::string>(ifs)) counter[word]++;

        // Sort the words according to their frequency
        std::multimap<std::size_t, std::string> sorter{};
        for (const auto& [word, count] : counter) sorter.insert({ count, word });

        // Show words with frequency given in a certain range
        for (const auto& [count, word] : rng::subrange{ sorter.lower_bound(800), sorter.upper_bound(1000) })
            std::cout << std::setw(25) << word << " --> " << count << '\n';
    }
    else std::cerr << "\n*** Error: Could not open source text file\n";
}