Open In App
Related Articles

Count words that appear exactly two times in an array of words

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given an array of n words. Some words are repeated twice, we need to count such words. 

Examples: 

Input : s[] = {"hate", "love", "peace", "love", 
               "peace", "hate", "love", "peace", 
               "love", "peace"};
Output : 1
There is only one word "hate" that appears twice

Input : s[] = {"Om", "Om", "Shankar", "Tripathi", 
                "Tom", "Jerry", "Jerry"};
Output : 2
There are two words "Om" and "Jerry" that appear
twice.

Source: Amazon Interview

Recommended Practice

Below is the implementation: 

C++

// C++ program to count all words with count
// exactly 2.
#include <bits/stdc++.h>
using namespace std;
 
// Returns count of words with frequency
// exactly 2.
int countWords(string str[], int n)
{
    unordered_map<string, int> m;
    for (int i = 0; i < n; i++)
        m[str[i]] += 1;
 
    int res = 0;
    for (auto it = m.begin(); it != m.end(); it++)
        if ((it->second == 2))
            res++;
 
    return res;
}
 
// Driver code
int main()
{
    string s[] = { "hate", "love", "peace", "love",
                   "peace", "hate", "love", "peace",
                   "love", "peace" };
    int n = sizeof(s) / sizeof(s[0]);
    cout << countWords(s, n);
    return 0;
}

                    

Java

// Java program to count all words with count
// exactly 2.
import java.util.HashMap;
import java.util.Map;
public class GFG {
      
    // Returns count of words with frequency
    // exactly 2.
    static int countWords(String str[], int n)
    {
        // map to store count of each word
        HashMap<String, Integer> m = new HashMap<>();
         
        for (int i = 0; i < n; i++){
            if(m.containsKey(str[i])){
                int get = m.get(str[i]);
                m.put(str[i], get + 1);
            }
            else{
                m.put(str[i], 1);
            }
        }
             
        int res = 0;
        for (Map.Entry<String, Integer> it: m.entrySet()){
            if(it.getValue() == 2)
                res++;
        }
                 
        return res;
    }
      
    // Driver code
    public static void main(String args[])
    {
        String s[] = { "hate", "love", "peace", "love",
                       "peace", "hate", "love", "peace",
                       "love", "peace" };
        int n = s.length;
        System.out.println( countWords(s, n));
    }
}
// This code is contributed by Sumit Ghosh

                    

Python3

# Python program to count all
# words with count
# exactly 2.
  
# Returns count of words with frequency
# exactly 2.
def countWords(stri, n):
    m = dict()
    for i in range(n):
        m[stri[i]] = m.get(stri[i],0) + 1
  
    res = 0
    for i in m.values():
        if i == 2:
            res += 1
  
    return res
  
# Driver code
s = [ "hate", "love", "peace", "love",
      "peace", "hate", "love", "peace",
                "love", "peace" ]
n = len(s)
print(countWords(s, n))
 
# This code is contributed
# by Shubham Rana

                    

C#

// C# program to count all words with count
// exactly 2.
using System;
using System.Collections.Generic;
 
class GFG
{
     
    // Returns count of words with frequency
    // exactly 2.
    static int countWords(String []str, int n)
    {
        // map to store count of each word
        Dictionary<String,int> m = new Dictionary<String,int>();
         
        for (int i = 0; i < n; i++)
        {
            if(m.ContainsKey(str[i]))
            {
                int get = m[str[i]];
                m.Remove(str[i]);
                m.Add(str[i], get + 1);
            }
            else
            {
                m.Add(str[i], 1);
            }
        }
             
        int res = 0;
        foreach(KeyValuePair<String, int> it in m)
        {
            if(it.Value == 2)
                res++;
        }
                 
        return res;
    }
     
    // Driver code
    public static void Main(String []args)
    {
        String []a = { "hate", "love", "peace", "love",
                    "peace", "hate", "love", "peace",
                    "love", "peace" };
        int n = a.Length;
        Console.WriteLine( countWords(a, n));
    }
}
 
// This code is contributed by Rajput-Ji

                    

Javascript

<script>
 
// Javascript program to count all words with count
// exactly 2.
 
// Returns count of words with frequency
// exactly 2.
function countWords(str, n)
{
    var m = new Map();
    for (var i = 0; i < n; i++)
    {
        if(m.has(str[i]))
            m.set(str[i], m.get(str[i])+1)
        else
            m.set(str[i], 1)
    }
 
    var res = 0;
 
    m.forEach((value, key) => {
         
        if ((value == 2))
            res++;
    });
    return res;
}
 
// Driver code
var s = ["hate", "love", "peace", "love",
               "peace", "hate", "love", "peace",
               "love", "peace" ];
var n = s.length;
document.write( countWords(s, n));
 
</script>

                    

Output
1

Time Complexity : O(N)
Auxiliary Space: O(N)

Method 2: Using Built-in Python functions:

  • Count the frequencies of every word using the Counter function
  • Traverse in frequency dictionary
  • Check which word has frequency 2. If so, increase the count
  • Print Count

Below is the implementation:

C++

// C++ program for the above approach
 
#include <iostream>
#include <unordered_map>
#include <vector>
using namespace std;
 
int countWords(vector<string> s, int n)
{
    // Calculating frequency using unordered_map
    unordered_map<string, int> freq;
    for (int i = 0; i < n; i++) {
        freq[s[i]]++;
    }
    int count = 0;
    // Traversing in freq dictionary
    for (auto& it : freq) {
        if (it.second == 2) {
            count++;
        }
    }
    return count;
}
 
// Driver code
int main()
{
    vector<string> s
        = { "hate", "love", "peace", "love", "peace",
            "hate", "love", "peace", "love", "peace" };
    int n = s.size();
    cout << countWords(s, n) << endl;
    return 0;
}
 
// This code is contributed by prince

                    

Java

import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;
 
public class Main {
    public static int countWords(List<String> s, int n) {
        // Calculating frequency using HashMap
        Map<String, Integer> freq = new HashMap<String, Integer>();
        for (int i = 0; i < n; i++) {
            String key = s.get(i);
            if (freq.containsKey(key)) {
                freq.put(key, freq.get(key) + 1);
            } else {
                freq.put(key, 1);
            }
        }
        int count = 0;
        // Traversing in freq dictionary
        for (Map.Entry<String, Integer> entry : freq.entrySet()) {
            if (entry.getValue() == 2) {
                count++;
            }
        }
        return count;
    }
 
    // Driver code
    public static void main(String[] args) {
        List<String> s = new ArrayList<String>();
        s.add("hate");
        s.add("love");
        s.add("peace");
        s.add("love");
        s.add("peace");
        s.add("hate");
        s.add("love");
        s.add("peace");
        s.add("love");
        s.add("peace");
        int n = s.size();
        System.out.println(countWords(s, n));
    }
}

                    

Python

# importing Counter from collections
from collections import Counter
 
# Python program to count all words with count exactly 2.
# Returns count of words with frequency exactly 2.
def countWords(stri, n):
   
    # Calculating frequency using Counter
    m = Counter(stri)
 
    count = 0
    # Traversing in freq dictionary
    for i in m:
        if m[i] == 2:
            count += 1
 
    return count
 
# Driver code
s = ["hate", "love", "peace", "love",
     "peace", "hate", "love", "peace",
     "love", "peace"]
n = len(s)
print(countWords(s, n))
 
# This code is contributed by vikkycirus

                    

C#

using System;
using System.Collections.Generic;
using System.Linq;
 
class Program {
    static int CountWords(List<string> s, int n)
    {
        // Calculating frequency using Dictionary
        Dictionary<string, int> freq
            = new Dictionary<string, int>();
        foreach(string word in s)
        {
            if (freq.ContainsKey(word))
                freq[word]++;
            else
                freq.Add(word, 1);
        }
        int count = 0;
        // Traversing in freq dictionary
        foreach(KeyValuePair<string, int> pair in freq)
        {
            if (pair.Value == 2)
                count++;
        }
        return count;
    }
 
    static void Main(string[] args)
    {
        List<string> s = new List<string>{
            "hate", "love", "peace", "love", "peace",
            "hate", "love", "peace", "love", "peace"
        };
        int n = s.Count();
        Console.WriteLine(CountWords(s, n));
    }
}

                    

Javascript

// Returns count of words with frequency exactly 2.
function countWords(strList) {
  // Calculating frequency using Counter
  const m = {};
  for (let i = 0; i < strList.length; i++) {
    const word = strList[i];
    m[word] = m[word] ? m[word] + 1 : 1;
  }
 
  let count = 0;
  // Traversing in freq dictionary
  for (const i in m) {
    if (m[i] === 2) {
      count += 1;
    }
  }
 
  return count;
}
 
// Driver code
const s = ["hate", "love", "peace", "love", "peace", "hate", "love", "peace", "love", "peace"];
console.log(countWords(s));
 
// This code is contributed by adityashatmfh

                    

Output
1

Time Complexity : O(n)
Auxiliary Space: O(n)



Last Updated : 23 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads