Related Articles

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 ``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 ``# include ``# 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

 ` 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

 ``

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 ``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 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

 ``

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