Same duplicate

[bambambam]

HELLOO!
Who can tell me, how to find same duplicate characters from text file and print them in another text file?

I am talking about these "AB", "BB", etc. If they are the same the program would print whole line in the another text file. How it is possible to make it?

Text file look like this:
J1 B1 1998 AB
asas J33 1997 BB
ff fff 1996 BC
PE L5 1995 AB
ff55 ff 1994 AB.

[salem c]

So which of those lines would be printed to another file?

[coder777]

What does "If they are the same" mean? The same regarding what?

[Enoizat]

If you know there are exactly 4 std::strings in each row, you could loop through the file reading 4 std::strings at each iteration and trying to insert the forth in a std::set.
Each time std::set::insert() fails, just save those 4 std::strings in your output file.

(If this is NOT an assignment, we can give you a working example)

[dhayden]

Like others, I'm having trouble understanding the problem. What should the output be for the input text file you've given?

[bambambam]

Information in the document file.
(name, surname, date of birth, group)
For example document file look like this:

J1 B1 1998 AB
asas J33 1997 BB
ff fff 1996 BC
PE L5 1995 AB
ff55 ff 1994 AB

first, i need to find out the group which dominate the most, in this case it's group "AB"
second, the program would print all the line if it is in the group "AB".

The result file would look like this:
J1 B1 1998 AB
PE L5 1995 AB
ff55 ff 1994 AB


Thanks for the help!

[Enoizat]

Again: is this an assignment?

[dhayden]

You'll need a function that takes a line of text as input and returns the group:

// Return the group (4'th field) from a line of space-separated fields
string getGroup(const string &line)
{
    ...
}

There are three parts to this problem, first you have to count how many times each group appears. Second you must select the largest count, and third you must print the lines whose count is largest. The thing that trips people up with a problem like this is that you' looking up groups by value in the first part, then by frequency in the second part.

To do the first part, just use a map.

std::map<std::string, unsigned> freqMap;  // maps string to frequency
for each line {
    string group = getGroup(line);
    freqMap[group]++;
}

Second, find the group with the highest frequency. Note that this code is untested. I always seem to have trouble iterating through an std::map:

unsigned theMax {0};  // max frequency
string bestGroup;    // group corresponding to the Max
for (const auto & keyVal : freqMap) {
    if (keyVal.second > theMax) {
        theMax = keyVal.second;
        bestGroup = keyVal.first;
    }
}

Third, go back through the lines, printing ones that match the best group:

for (each line) {
    group = getGroup(line);
    if (group == bestGroup) {
        cout << line << '\n';
    }
}

I haven't specified how to go through each line. If the file isn't too big, you can read it into memory and do all the processing there. If the data is expected to be large, you might be better off making two passes through the file.

[bambambam]

Again: is this an assignment?
I am just trying to learn individually.

[Enoizat]

I think the solution changes according to what you want to do with those data once you have read them.
Do you want make further operations or not?
If so, perhaps you want them stored inside some sort of container; and (again, if so) perhaps the best solution is a std::multimap, where you can use equal_range() to divide them.

Anyway, you could also try something weirder like this:

bambambam.dat:

J1    B1 1998 AB
asas J33 1997 BB
ff   fff 1996 BC
PE    L5 1995 AB
ff55  ff 1994 AB

#include <fstream>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>


// Information in the document file:
// (name, surname, date of birth, group)
struct FourData {
public:
    std::string name;
    std::string surname;
    int birthdate {};
    std::string group;

    FourData() = default;
    explicit FourData(std::string s);

    bool operator< (const FourData& rhs) const;

//friend:
    friend std::ostream& operator << (std::ostream& os, const FourData& rhs);
    friend std::istream& operator >> (std::istream& is, FourData& rhs);
};


FourData::FourData(std::string s)
{
    std::istringstream iss { s };
    iss >> *this;
}


bool FourData::operator< (const FourData& rhs) const
{
    return group < rhs.group;
}


std::istream& operator >> (std::istream& is, FourData& rhs)
{
    is >> rhs.name >> rhs.surname >> rhs.birthdate >> rhs.group;
    return is;
}


std::ostream& operator << (std::ostream& os, const FourData& rhs)
{
    os << rhs.name << ' ' << rhs.surname << ' ' << rhs.birthdate << ' ' << rhs.group;
    return os;
}


using weirdmap = std::map<FourData, std::vector<FourData>>;


weirdmap& extractAll(weirdmap& mymap);
weirdmap& extractDuplicates(weirdmap& mymap);
void printWeirdmap(const weirdmap& mymap);
int printWeirdmapToFile(const weirdmap& mymap, std::ofstream & fout);
std::string findMostFrequent(const weirdmap& mymap);


int main ()
{
    int choice {};
    while (!choice) {
        std::cout << "Would you like to extract all the occurencies of\n"
                     "duplicated lines (first occurency and the duplicates)\n"
                     "or only the duplicates (not the first occurency)?\n"
                     "1) all\n2) duplicates only\n >>> ";
        std::cin >> choice;
        if(choice < 1 || 2 < choice) { choice = 0; }
    }
    weirdmap mymap;
    switch(choice) {
    case 1:
        extractAll(mymap);
        break;
    case 2:
        extractDuplicates(mymap);
        break;
    default:
        std::cout << "A misterius error occurred.\n";
        return 0;
    }

    printWeirdmap(mymap);
    std::cout << "The most frequent group is " << findMostFrequent(mymap) << '\n';
}


weirdmap& extractDuplicates(weirdmap& mymap)
{
    std::string finname { "bambambam.dat" };
    std::ifstream inf(finname);
    if(!inf) {
        std::cout << "Cannnot open " << finname << '\n';
        return mymap;
    }

    std::string foutname { "bambambam_duplicates.dat" };
    std::ofstream outf(foutname);
    if(!outf) {
        std::cout << "Cannnot open " << foutname << '\n';
        return mymap;
    }

    int mycount {};
    for(std::string line; std::getline(inf, line); /**/) {
        FourData fd(line);

        auto myit = mymap.find(fd);
        
        // No duplicates:
        if ( myit == mymap.end()) {
            std::vector<FourData> v { fd };
            mymap.insert ( std::make_pair(fd,v) );
            continue;
        }

        // Duplicate found:
        myit->second.push_back ( fd );
        outf << line << '\n';
        ++mycount;
    }
    std::cout << finname << " has been read and " << mycount
              << " duplicates have been copied into " << foutname << '\n';
    return mymap;
}


weirdmap& extractAll(weirdmap& mymap)
{
    std::string finname { "bambambam.dat" };
    std::ifstream inf(finname);
    if(!inf) {
        std::cout << "Cannnot open " << finname << '\n';
        return mymap;
    }

    for(std::string line; std::getline(inf, line); /**/) {
        FourData fd(line);

        auto myit = mymap.find(fd);
        
        if ( myit == mymap.end()) {
            // No duplicates:
            std::vector<FourData> v { fd };
            mymap.insert ( std::make_pair(fd, v) );
        } else {
            // Duplicate found:
            myit->second.push_back ( fd );
        }
    }

    std::string foutname { "bambambam_duplicates.dat" };
    std::ofstream outf(foutname);
    if(!outf) {
        std::cout << "Cannnot open " << foutname << '\n';
        return mymap;
    }
    int mycount { printWeirdmapToFile(mymap, outf) };
    std::cout << finname << " has been read and " << mycount
              << " duplicates have been found.\nPlease check "
              << foutname << '\n';
    return mymap;
}


int printWeirdmapToFile(const weirdmap& mymap, std::ofstream & fout)
{
    int mycount {};
    for(const auto& a : mymap) {
        if(a.second.size() > 1) {
            fout << "Elements in the group " << a.first.group << ":\n";
            for(const auto& b : a.second) {
                fout << b << '\n';
                ++mycount;
            }
            fout << '\n';
        }
    }
    return mycount;
}


void printWeirdmap(const weirdmap& mymap)
{
    for(const auto& a : mymap) {
        std::cout << "Elements in the group " << a.first.group << ":\n";
        for(const auto& b : a.second) {
            std::cout << b << '\n';
        }
        std::cout << '\n';
    }
}


std::string findMostFrequent(const weirdmap& mymap)
{
    std::map<unsigned, std::string> tmpmap;
    for(const auto& e : mymap) {
        tmpmap.insert(std::make_pair(e.second.size(), e.first.group));
    }
    return tmpmap.crbegin()->second;
}

[bambambam]

Thank you! :)