Print all the duplicates in the input string

Write an efficient program to print all the duplicates and their counts in the input string 

Method 1: Using hashing

Algorithm: Let input string be “geeksforgeeks” 

1. Construct character count array from the input string.
   1. count[‘e’] = 4 
   2. count[‘g’] = 2
   3. count[‘k’] = 2 
   4. ……
2. Print all the indexes from the constructed array which have values greater than 1.

Implementation:

C++14

// C++ program to count all duplicates
// from string using hashing
#include <iostream>
using namespace std;
# define NO_OF_CHARS 256

class gfg
{
    public :

    /* Fills count array with
    frequency of characters */
    void fillCharCounts(char *str, int *count)
    {
        int i;
        for (i = 0; *(str + i); i++)
        count[*(str + i)]++;
    }

    /* Print duplicates present
    in the passed string */
    void printDups(char *str)
    {

        // Create an array of size 256 and fill
        // count of every character in it
        int *count = (int *)calloc(NO_OF_CHARS,
                                      sizeof(int));
        fillCharCounts(str, count);

        // Print characters having count more than 0
        int i;
        for (i = 0; i < NO_OF_CHARS; i++)
        if(count[i] > 1)
            printf("%c, count = %d \n", i, count[i]);

        free(count);
    }
};

/* Driver code*/
int main()
{
    gfg g ;
    char str[] = "test string";
    g.printDups(str);
    //getchar();
    return 0;
}

// This code is contributed by SoM15242

C

// C program to count all duplicates
// from string using hashing
# include <stdio.h>
# include <stdlib.h>
# define NO_OF_CHARS 256

/* Fills count array with
   frequency of characters */
void fillCharCounts(char *str, int *count)
{
   int i;
   for (i = 0; *(str+i);  i++)
      count[*(str+i)]++;
}

/* Print duplicates present
   in the passed string */
void printDups(char *str)
{

  // Create an array of size 256 and
  // fill count of every character in it
  int *count = (int *)calloc(NO_OF_CHARS,
                             sizeof(int));
  fillCharCounts(str, count);

  // Print characters having count more than 0
  int i;
  for (i = 0; i < NO_OF_CHARS; i++)
    if(count[i] > 1)
        printf("%c,  count = %d \n", i,  count[i]);

  free(count);
}

/* Driver program to test to print printDups*/
int main()
{
    char str[] = "test string";
    printDups(str);
    getchar();
    return 0;
}

Java

// Java program to count all
// duplicates from string using
// hashing

public class GFG {
    static final int NO_OF_CHARS = 256;

    /* Fills count array with
       frequency of characters */
    static void fillCharCounts(String str,
                                   int[] count)
    {
        for (int i = 0; i < str.length(); i++)
            count[str.charAt(i)]++;
    }

    /* Print duplicates present
      in the passed string */
    static void printDups(String str)
    {
        // Create an array of size
        // 256 and fill count of
        // every character in it
        int count[] = new int[NO_OF_CHARS];
        fillCharCounts(str, count);

        for (int i = 0; i < NO_OF_CHARS; i++)
            if (count[i] > 1)
                System.out.println((char)(i) +
                          ", count = " + count[i]);
    }

    // Driver Method
    public static void main(String[] args)
    {
        String str = "test string";
        printDups(str);
    }
}

Python

# Python program to count all
# duplicates from string using hashing
NO_OF_CHARS = 256

# Fills count array with
# frequency of characters
def fillCharCounts(string, count):
    for i in string:
        count[ord(i)] += 1
    return count

# Print duplicates present
# in the passed string
def printDups(string):

    # Create an array of size 256
    # and fill count of every character in it
    count = [0] * NO_OF_CHARS
    count = fillCharCounts(string,count)

    # Utility Variable
    k = 0

    # Print characters having
    # count more than 0
    for i in count:
        if int(i) > 1:
            print chr(k) + ", count = " + str(i)
        k += 1

# Driver program to test the above function
string = "test string"
print printDups(string)

# This code is contributed by Bhavya Jain

C#

// C# program to count all duplicates
// from string using hashing
using System;

class GFG
{

    static int NO_OF_CHARS = 256;

    /* Fills count array with
       frequency of characters */
    static void fillCharCounts(String str,
                                 int[] count)
    {
        for (int i = 0; i < str.Length; i++)
            count[str[i]]++;
    }

    /* Print duplicates present in
    the passed string */
    static void printDups(String str)
    {

        // Create an array of size 256 and
        // fill count of every character in it
        int []count = new int[NO_OF_CHARS];
        fillCharCounts(str, count);

        for (int i = 0; i < NO_OF_CHARS; i++)
            if(count[i] > 1)
                Console.WriteLine((char)i + ", " +
                              "count = " + count[i]);
    }

    // Driver Method
    public static void Main()
    {
        String str = "test string";
        printDups(str);
    }
}

// This code is contributed by Sam007

PHP

<?php
// PHP program to count
// all duplicates from
// string using hashing
function fillCharCounts($str, $count)
{
    for ($i = 0; $i < strlen($str); $i++)
        $count[ord($str[$i])]++;

    for ($i = 0; $i < 256; $i++)
        if($count[$i] > 1)
            echo chr($i) . ", " ."count = " .
                         ($count[$i]) . "\n";
}

// Print duplicates present
// in the passed string
function printDups($str)
{
    // Create an array of size
    // 256 and fill count of
    // every character in it
    $count = array();
    for ($i = 0; $i < 256; $i++)
    $count[$i] = 0;
    fillCharCounts($str, $count);


}

// Driver Code
$str = "test string";
printDups($str);

// This code is contributed by Sam007
?>

Javascript

<script>
    // Javascript program to count all duplicates
    // from string using hashing

    let NO_OF_CHARS = 256;

    /* Print duplicates present in
    the passed string */
    function printDups(str)
    {

        // Create an array of size 256 and
        // fill count of every character in it
        let count = new Array(NO_OF_CHARS);
        count.fill(0);

        for (let i = 0; i < str.length; i++)
            count[str[i].charCodeAt()]++;

        for (let i = 0; i < NO_OF_CHARS; i++)
        {
            if(count[i] > 1)
            {
                document.write(String.fromCharCode(i) + ", " +
                "count = " + count[i] + "</br>");
            }
        }
    }

    let str = "test string";
      printDups(str);

</script>

Output

s, count = 2 
t, count = 3 

Time Complexity: O(n), where n = length of the string passed
Space Complexity: O(NO_OF_CHARS)

Note: Hashing involves the use of an array of fixed size each time no matter whatever the string is. 

For example, str = “aaaaaaaaaa”. 

An array of size 256 is used for str, only 1 block out of total size (256) will be utilized to store the number of occurrences of ‘a’ in str (i.e count[‘a’] = 10). 

Rest 256 – 1 = 255 blocks remain unused. 

Thus, Space Complexity is potentially high for such cases. So, to avoid any discrepancies and to improve Space Complexity, maps are generally preferred over long-sized arrays. 

Method 2: Using Maps

Approach: The approach is the same as discussed in Method 1, but, using a map to store the count.

Implementation:

C++

// C++ program to count all duplicates
// from string using maps
#include <bits/stdc++.h>
using namespace std;
void printDups(string str)
{
    map<char, int> count;
    for (int i = 0; i < str.length(); i++) {
        count[str[i]]++;
    }

    for (auto it : count) {
        if (it.second > 1)
            cout << it.first << ", count = " << it.second
                 << "\n";
    }
}
/* Driver code*/
int main()
{
    string str = "test string";
    printDups(str);
    return 0;
}
// This code is contributed by yashbeersingh42

Java

// Java program to count all duplicates
// from string using maps
import java.util.*;

class GFG {

    static void printDups(String str)
    {
        HashMap<Character, Integer> count = new HashMap<>();
        /*Store duplicates present
        in the passed string */
        for (int i = 0; i < str.length(); i++) {
            if (!count.containsKey(str.charAt(i)))
                count.put(str.charAt(i), 1);
            else
                count.put(str.charAt(i),
                          count.get(str.charAt(i)) + 1);
        }

        /*Print duplicates in sorted order*/
        for (Map.Entry mapElement : count.entrySet()) {
            char key = (char)mapElement.getKey();
            int value = ((int)mapElement.getValue());

            if (value > 1)
                System.out.println(key
                                   + ", count = " + value);
        }
    }
    // Driver code
    public static void main(String[] args)
    {
        String str = "test string";
        printDups(str);
    }
}
// This code is contributed by yashbeersingh42

Python3

# Python 3 program to count all duplicates
# from string using maps
from collections import defaultdict

def printDups(st):

    count = defaultdict(int)
    for i in range(len(st)):
        count[st[i]] += 1

    for it in count:
        if (count[it] > 1):
            print(it, ", count = ", count[it])

# Driver code
if __name__ == "__main__":

    st = "test string"
    printDups(st)

    # This code is contributed by ukasp.

C#

// C# program to count all duplicates
// from string using maps
using System;
using System.Collections.Generic;
using System.Linq;

class GFG{

static void printDups(String str)
{
    Dictionary<char,
               int> count = new Dictionary<char,
                                           int>();

    for(int i = 0; i < str.Length; i++)
    {
        if (count.ContainsKey(str[i]))
            count[str[i]]++;
        else
            count[str[i]] = 1;
    }

    foreach(var it in count.OrderBy(key => key.Value))
    {
        if (it.Value > 1)
            Console.WriteLine(it.Key + ", count = " +
                              it.Value);
    }
}

// Driver code
static public void Main()
{
    String str = "test string";
    printDups(str);
}
}

// This code is contributed by shubhamsingh10

Javascript

<script>
//Javascript Implementation
//  to count all duplicates
// from string using maps

function printDups(str)
{
    var count = {};
    for (var i = 0; i < str.length; i++) {
        count[str[i]] = 0;
    }

    for (var i = 0; i < str.length; i++) {
        count[str[i]]++;
    }

    for (var it in count) {
        if (count[it] > 1)
            document.write(it + ", count = " + count[it] + "<br>");
    }
}
/* Driver code*/
var str = "test string";
printDups(str);

// This code is contributed by shubhamsingh10
</script>

Output

s, count = 2
t, count = 3

Time Complexity: O(N*log(N)), where N = length of the string passed and it generally takes O(log(N)) time for an element insertion in a map. 
Space Complexity: O(K), where K = size of the map (0<=K<=input_string_length).

Implementation:

C++

// C++ program to count all duplicates
// from string using maps
#include <bits/stdc++.h>
using namespace std;
void printDups(string str)
{
    unordered_map<char, int> count;
    for (int i = 0; i < str.length(); i++) {
        count[str[i]]++;  //increase the count of characters by 1
    }

    for (auto it : count) {   //iterating through the unordered map
        if (it.second > 1)   //if the count of characters is greater then 1 then duplicate found
            cout << it.first << ", count = " << it.second
                 << "\n";
    }
}
/* Driver code*/
int main()
{
    string str = "test string";
    printDups(str);
    return 0;
}

Java

/*package whatever //do not write package name here */
import java.io.*;
import java.util.*;

class GFG
{

  // Java program to count all duplicates
  // from string using maps
  static void printDups(String str)
  {
    Map<Character, Integer> count = new HashMap<>();
    for (int i = 0; i < str.length(); i++) {
      if(count.containsKey(str.charAt(i)))
        count.put(str.charAt(i) , count.get(str.charAt(i))+1);
      else count.put(str.charAt(i),1);
      //increase the count of characters by 1
    }

    for (Map.Entry<Character,Integer> mapElement : count.entrySet()) {   //iterating through the unordered map
      if (mapElement.getValue() > 1)   //if the count of characters is greater then 1 then duplicate found
        System.out.println(mapElement.getKey() + ", count = " + mapElement.getValue());
    }
  }

  /* Driver program to test above function*/
  public static void main(String args[])
  {
    String str = "test string";
    printDups(str);
  }
}

// This code is contributed by shinjanpatra

Python3

# Python3 program to count all duplicates
# from string using maps
def printDups(Str):

    count = {}
    for i in range(len(Str)):
        if(Str[i] in count):
            count[Str[i]] += 1
        else:
            count[Str[i]] = 1
        #increase the count of characters by 1

    for it,it2 in count.items():  #iterating through the unordered map
        if (it2 > 1):   #if the count of characters is greater then 1 then duplicate found
            print(str(it) + ", count = "+str(it2))

# Driver code
Str = "test string"
printDups(Str)

# This code is contributed by shinjanpatra

Javascript

<script>

// JavaScript program to count all duplicates
// from string using maps
function printDups(str)
{
    let count = new Map();
    for (let i = 0; i < str.length; i++) {
        if(count.has(str[i])){
            count.set(str[i],count.get(str[i])+1);
        }
        else{
            count.set(str[i],1);
        }
        //increase the count of characters by 1
    }

    for (let [it,it2] of count) {   //iterating through the unordered map
        if (it2 > 1)   //if the count of characters is greater then 1 then duplicate found
            document.write(it,", count = ",it2,"</br>");
    }
}
/* Driver code*/

let str = "test string";
printDups(str);

// This code is contributed by shinjanpatra

</script>

Output

s, count = 2
t, count = 3

Time Complexity: O(N), where N = length of the string passed and it takes O(1) time to insert and access any element in an unordered map
Auxiliary Space: O(K), where K = size of the map (0<=K<=input_string_length).