如何编写一种算法来找出特定单词出现在哪些行中（我正在使用std :: map）

Question

I am writing code which calculate how many times each word appears in text ( I DID THIS TASK), but I can't find a way to calculate in which lines these words appeared.

I don't know where to start.

#include "header.h"
int main()
{
     //read the input, keeping track of each word and how often we see it
     std::ifstream in("tekstas.txt"); // input file

    std::string input;
    std::map<std::string, int> counters; // store each word and an associated counter
    std::vector<char>CharVect; // vector that stores symbols i want to replace
    formuojuChar(CharVect); // pushbacking that vector with symbols
     for (unsigned int i = 0; !in.eof(); i++)
    {
        std::getline(in, input);
        std::transform(input.begin(), input.end(), input.begin(), ::tolower); // lowering letters so for example "Mom"= "mom"
        Replace(input,CharVect, ' '); // replace symbols with space
        std::stringstream read(input);
        std::string word;
        while (read >> word)
        {
            ++counters[word];
        }
     }
     std::ofstream out("isvestis.txt");
    std::cout<<"Words that appear more than once in the text: "<<std::endl;
    std::cout<<std::endl;
     for (std::map<std::string, int>::const_iterator it = counters.begin();it != counters.end(); ++it)
        {
            if((it->second)>1)
            {

                std::cout<<"'" <<it->first<<"' " <<"appears "<<it->second <<" times in lines: " ;
                /*
                 ANY IDEAS ?
                 */
                std::cout<<std::endl;

            }
        }
        return 0;

}

I expect output to show me in which .txt file lines that word appears. TY

Answer 1

This looks like a learning exercise that you want to do on your own, and I have a policy of not writing code for those.

However, one thing you could do is count the number of newlines you've encountered (which tells you the line you're on) and, whenever you see the text you're searching for, insert the current line number into a std::set<unsigned> or std::vector<unsigned> .

You would want to do this in a single loop, perhaps reading in a line at a time. Whever you encounter the search term, update both the word counter and the set of line numbers.

Answer 2

The major issue with your approach is that you're using a second loop to gather the information on the words, and in doing so, you've lost all the information about which line(s) the words are on.

Instead of trying to figure out what line you're on in the second loop, you have all the information necessary on the current line in the first loop. All you need is a variable that keeps track of each line. You are using (incorrectly I may add), std::getline -- each time you call that function, you are going to the next line, thus you know implicitly what line you're on in the first loop.

---

First, you need to fix your read loop so that it reads lines correctly from a file:

std::string line;
while (std::getline(in, line))
{
//...
}

---

Second, inside the while loop, you can determine all the information you need for the word, word count, and line(s) where the word is found. You don't need two loops to do this.

Instead of a std::map<std::string, int> , which only knows about the word count, you could create a map that holds all the information -- the word count and the line(s) the word is found on. Here is a map type that can hold this information:

std::map<std::string, std::pair<int, std::set<int>>>

The "second" of the map holds the information on the count, and a std::set that will hold all of the line numbers where the word is found. The reason for the std::set is to guarantee that duplicate line numbers will not be stored.

Putting this all together, here is a sample program using this type:

#include <map>
#include <set>
#include <string>
#include <sstream>
#include <iostream>

// pair and map type
using WordInfo = std::pair<int, std::set<int>>;
using WordMap = std::map<std::string, WordInfo>;

int main()
{
    // our map
    WordMap wm;
    std::string line;

    // the line count
    int line_number = 1;
    while (std::getline(std::cin, line))
    {
        // line parser
        std::istringstream strm(line);
        std::string word;
        while ( strm >> word)
        {
            // we call map::insert, not `[ ]` to insert into a map
            auto pr = wm.insert({word, {0,std::set<int>()}});

            // the return value of map::insert gives us a pair, where the first is 
            // an iterator to the item in the map
            auto& mapIter = pr.first;

            // increment the word count   
            ++(mapIter->second.first);

            // insert the line number into the set
            mapIter->second.second.insert(line_number);
        }

        // increment the line counter
        ++line_number;
    }

    // output results
    for (auto& m : wm )
    {
        std::cout << "The word  \"" << m.first << "\" appears " << m.second.first << " times on the following lines:\n";
        for ( auto& m2 : m.second.second)
            std::cout << m2 << " ";
        std::cout << "\n\n";
    }
}

So what was done here?

1) The line where each word is on is known in the read loop. All that is done is to increment the line count for each line that is read in.

2) We use std::map::insert to insert an entry into the map, and not std::map::operator[ ] . The reason is that map::insert will not insert an entry if the entry already exists, it will insert a brand new entry if the entry doesn't exist, and regardless of which is done, std::map::insert returns an iterator to the item in the map.

We need the iterator returned to us for later processing. In the subsequent lines, we just increment the count and update the std::set .

Here is a live example .

---

Note: I have no idea what all of the replacement you're doing in your original program, so I skipped over all of that and concentrated solely on the task of determining the words and the line(s) the words are situated.