Skip to content
Related Articles

Related Articles

Print all the duplicates in the input string
  • Difficulty Level : Basic
  • Last Updated : 14 Apr, 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
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. 
My Personal Notes
arrow_drop_up
Next

Remove characters from the first string which are present in the second string
Recommended Articles
Page :
Print distinct sorted permutations with duplicates allowed in input
11, Feb 18
Print a closest string that does not contain adjacent duplicates
28, Dec 17
Check if string is palindrome after removing all consecutive duplicates
20, Jun 20
Remove all consecutive duplicates from the string
23, Oct 17
Remove all duplicates from a given string in Python
30, Oct 17
Remove duplicates from a given string
22, Mar 09
Distinct permutations of a string containing duplicates using HashSet in Java
19, Sep 19
Remove duplicates from string keeping the order according to last occurrences
28, Apr 20
Remove duplicates from a string in O(1) extra space
26, Sep 18
Character replacement after removing duplicates from a string
19, Jul 18
Remove three consecutive duplicates from string
30, Aug 17
Lexicographically smallest string formed by removing duplicates
03, Nov 20
Python groupby method to remove all consecutive duplicates
27, Dec 17
Recursively remove all adjacent duplicates
10, Oct 13
Check duplicates in a stream of strings
04, Oct 19
Removing row or column wise duplicates from matrix of characters
22, Jan 18
Print all possible combinations of the string by replacing '$' with any other digit from the string
03, May 20
Print string after removing all (“10” or “01”) from the binary string
14, Apr 20
Print shortest path to print a string on screen
24, Jun 16
Generate two output strings depending upon occurrence of character in input string in Python
27, Dec 17
Return maximum occurring character in an input string
20, Mar 09
How to input a comma separated string in C++?
31, Oct 19
Generate two output strings depending upon occurrence of character in input string.
07, Oct 17
Program to check if input is an integer or a string
12, Jul 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Basic





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox