how to count duplicate number in c++

Question

I am trying to count the number of duplicates when the user enters a number.

For example, the user enter this sequence:

i/p  : 1,3,3,4,4,4,5,5,5 

The output should be:

o/p :  3 

Here's what I have:

#include <bits/stdc++.h>
#include <iostream>

using namespace std;

int countduplicate(vector<int> number)
{
    
   std::set<int> setuniquenumber(number.begin(),number.end());
   std::vector<int>(setuniquenumber.begin(),setuniquenumber.end());
   
}

int main()
{
  
   
}

Live program link: https://onlinegdb.com/Byetbj_MWD

I'm using this link as reference.

Thank you for your help.

Answer 1

If you are allowed to go the std::map route, you could do something like this (this may be a tad overkill, and by the looks of your example code, you want to use set instead):

#include <iostream>
#include <vector>
#include <set>
#include <map>

int countduplicate(const std::vector<int>& number) {
    std::map<int, int> m;
    int countDupes = 0;
    
    for (std::vector<int>::const_iterator it = number.begin(); it != number.end(); ++it){
        const int currentNumber = *it;
        if(m.find(currentNumber) != m.end()){
            if(m[currentNumber] == 1){
                ++countDupes;
                ++m[currentNumber];
            }
        }else{
            m[currentNumber] = 1;
        }
    }
    
    return countDupes;
}

int main() {
    const std::vector<int> vect { 1,3,3,4,4,4,5,5,5 };
    const int dupeCount = countduplicate(vect);
    std::cout << dupeCount;

    return 0;
}

Try it out: https://onlinegdb.com/BypCzxQWD

Answer 2

It is not fully clear, if your values in the std::vector are sorted or allowed to be sorted. This makes a difference.

Anyway, I will show you 2 solutions.

First. We will sort the values in the vector. Then we will iterate over all values. We will increase the duplicate counter, if the current value is equal to the previous value and if we did not increase the counter for this value already.

This we will determine with a simple boolean comparison of the previous and current value.

Very simple and straightforward.

---

The second solution, and this is my prefereed solution, uses the standard approach for such questions. I will count all occurences of different integers. For that you can use a std::map or std::unordered_map. The important part here is the functionality of the index operator.

This

Returns a reference to the value that is mapped to a key equivalent to key, performing an insertion if such key does not already exist.

With counter[i]++;, either the value i exists already and its counter will be incremented, or, if the value i was not existing before, an entry will be created, and the coounter incremented.

At the ned, we will just count all counters with a value > 1, because thats the meaning of or dupe in this context.

Please see:

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>

int countduplicate1(std::vector<int> number) {

    // Sort a vector, so that all duplicates are adjacent
    std::sort(number.begin(), number.end());

    // The result. Counter for duplicates
    int counter{};
    bool newNumber{ true };

    // Go through all digits and check, if duplicate
    for (size_t i{}; i < number.size(); ++i) {

        // If duplicate, but was not already counted before
        if ((i > 0) && newNumber && (number[i] == number[i - 1]))
            ++counter;
        newNumber = ((i > 0) && (number[i] != number[i - 1]));
    }
    return counter;
}

int countduplicate2(std::vector<int> number) {
    // Counter for occurence of an integer
    std::map<int, size_t> counter{};

    // Count all different integer
    for (int i : number) counter[i]++;

    // Duplicate means that an integer is avaliable more than once
    return std::count_if(counter.begin(), counter.end(), [](const std::pair<int, size_t>& c) {return c.second > 1; });
}

int main() {

    std::vector<int> vect{ 1,3,3,4,4,4,7,9,9,9,8 };

    std::cout << countduplicate1(vect) << '\n';
    std::cout << countduplicate2(vect) << '\n';

    return 0;
}

Answer 3

As already suggested in the comments, you can use a std::map<int, int> where the key is some int-value and the mapped value is the number of occurences of the key.

Algorithm / Pseudo code:

1. for each value i in number:
   1. if the map contains key i, then increase the mapped value by one
   2. else add the key-value-pair with key i and value 1
2. start the counter n of duplicate numbers at 0
3. for each key-value-pair [key, value]:
   1. if value is > 1, then key had some duplicates, increse the counter n by one
   2. else key was unique in number and we can ignore it

Implementation specific hints:

• for a std::map<int, int> m steps 1.1 and 1.2 can be combined to m[i]++, this will automatically add the key if it doesn't exist already

• you can literally iterate over key-value-pairs like this:

  for(auto [key, value] : m) {...}
  

• steps 2 and 3 can be combined by using std::count_if

Actual implementation is left to the reader as exercise.