Skip to content
Related Articles

Related Articles

Improve Article

Print all the duplicates in the input string

  • Difficulty Level : Easy
  • Last Updated : 01 Jun, 2021

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.
count[‘e’] = 4 
count[‘g’] = 2 
count[‘k’] = 2 
……
2: Print all the indexes from the constructed array which have values greater than 1.
Solution 

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 pront 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.

Solution:



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 logN time for an element insertion in a map.

Space Complexity: O(K), where K = size of the map (0<=K<=input_string_length).

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :