GeeksforGeeks App
Open App
Browser
Continue

# Count of repeating digits in a given Number

Given a number N, the task is to count the total number of repeating digits in the given number.

Examples:

Input: N = 99677
Output: 2
Explanation:
In the given number only 9 and 7 are repeating, hence the answer is 2.

Input: N = 12
Output: 0
Explanation:
In the given number no digits are repeating, hence the answer is 0.

Naive Approach: The idea is to use two nested loops. In the first loop, traverse from the first digit of the number to the last, one by one. Then for each digit in the first loop, run a second loop and search if this digit is present anywhere else as well in the number. If yes, then increase the required count by 1. In the end, print the calculated count.

Algorithm

```Define a function called count_repeating_digits(num)
Convert the input number to a string using the to_string() function
Store it in a variable called str_num
Initialize a variable called count to 0

Use a nested loop to compare each digit in the string with every other digit
a. For each digit i in str_num, start another loop to compare it with all the digits j following it
b. If a repeating digit is found, increment the count by 1 and exit the inner loop
c. Continue comparing the rest of the digits
Return the count of repeating digits
Call the count_repeating_digits(num) function and store the result in a variable called repeating_digits
Display the number of repeating digits on the console
```

## C++

 `#include ``#include ` `using` `namespace` `std;` `int` `count_repeating_digits(``int` `num) {``    ``int` `count = 0;``    ``string str_num = to_string(num);  ``// Convert the number to a string``    ` `    ``for` `(``int` `i = 0; i < str_num.length(); i++) {``        ``for` `(``int` `j = i+1; j < str_num.length(); j++) {``            ``if` `(str_num[i] == str_num[j]) {``                ``count++;``                ``break``;  ``// Exit the inner loop once a repeating digit is found``            ``}``        ``}``    ``}``    ` `    ``return` `count;``}` `int` `main() {``    ``int` `num=99677;``     ` `    ` `    ``int` `repeating_digits = count_repeating_digits(num);``    ``cout << ``"Number of repeating digits: "` `<< repeating_digits << endl;``    ` `    ``return` `0;``}`

## Python3

 `def` `count_repeating_digits(num):``    ``count ``=` `0``    ``str_num ``=` `str``(num)  ``# Convert the number to a string` `    ``for` `i ``in` `range``(``len``(str_num)):``        ``for` `j ``in` `range``(i``+``1``, ``len``(str_num)):``            ``if` `str_num[i] ``=``=` `str_num[j]:``                ``count ``+``=` `1``                ``break`  `# Exit the inner loop once a repeating digit is found` `    ``return` `count`  `num ``=` `99677` `repeating_digits ``=` `count_repeating_digits(num)``print``(``"Number of repeating digits:"``, repeating_digits)`

Output

`Number of repeating digits: 2`

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: The idea is to use Hashing to store the frequency of the digits and then count the digits with a frequency equal to more than 1. Follow the steps below to solve the problem:

• Create an array of size 10 to store the count of digits 0 – 9. Initially store each index as 0.
• Now for each digit of number N, increment the count of that index in the array.
• Traverse the array and count the indices that have value more than 1.
• In the end, print this count.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function that returns the count of``// repeating digits of the given number``int` `countRepeatingDigits(``int` `N)``{``    ``// Initialize a variable to store``    ``// count of Repeating digits``    ``int` `res = 0;` `    ``// Initialize cnt array to``    ``// store digit count` `    ``int` `cnt[10] = { 0 };` `    ``// Iterate through the digits of N``    ``while` `(N > 0) {` `        ``// Retrieve the last digit of N``        ``int` `rem = N % 10;` `        ``// Increase the count of digit``        ``cnt[rem]++;` `        ``// Remove the last digit of N``        ``N = N / 10;``    ``}` `    ``// Iterate through the cnt array``    ``for` `(``int` `i = 0; i < 10; i++) {` `        ``// If frequency of digit``        ``// is greater than 1``        ``if` `(cnt[i] > 1) {` `            ``// Increment the count``            ``// of Repeating digits``            ``res++;``        ``}``    ``}` `    ``// Return count of repeating digit``    ``return` `res;``}` `// Driver Code``int` `main()``{``    ``// Given array arr[]``    ``int` `N = 12;` `    ``// Function Call``    ``cout << countRepeatingDigits(N);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``class` `GFG{``  ` `// Function that returns the count of``// repeating digits of the given number``static` `int` `countRepeatingDigits(``int` `N)``{``    ``// Initialize a variable to store``    ``// count of Repeating digits``    ``int` `res = ``0``;`` ` `    ``// Initialize cnt array to``    ``// store digit count`` ` `    ``int` `cnt[] = ``new` `int``[``10``];`` ` `    ``// Iterate through the digits of N``    ``while` `(N > ``0``)``    ``{`` ` `        ``// Retrieve the last digit of N``        ``int` `rem = N % ``10``;`` ` `        ``// Increase the count of digit``        ``cnt[rem]++;`` ` `        ``// Remove the last digit of N``        ``N = N / ``10``;``    ``}`` ` `    ``// Iterate through the cnt array``    ``for` `(``int` `i = ``0``; i < ``10``; i++)``    ``{`` ` `        ``// If frequency of digit``        ``// is greater than 1``        ``if` `(cnt[i] > ``1``)``        ``{`` ` `            ``// Increment the count``            ``// of Repeating digits``            ``res++;``        ``}``    ``}`` ` `    ``// Return count of repeating digit``    ``return` `res;``}`` ` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``// Given array arr[]``    ``int` `N = ``12``;`` ` `    ``// Function Call``    ``System.out.println(countRepeatingDigits(N));``}``}` `// This code is contributed by Ritik Bansal`

## Python3

 `# Python3 program for the above approach` `# Function that returns the count of``# repeating digits of the given number``def` `countRepeatingDigits(N):``    ` `    ``# Initialize a variable to store``    ``# count of Repeating digits``    ``res ``=` `0` `    ``# Initialize cnt array to``    ``# store digit count``    ``cnt ``=` `[``0``] ``*` `10` `    ``# Iterate through the digits of N``    ``while` `(N > ``0``):` `        ``# Retrieve the last digit of N``        ``rem ``=` `N ``%` `10` `        ``# Increase the count of digit``        ``cnt[rem] ``+``=` `1` `        ``# Remove the last digit of N``        ``N ``=` `N ``/``/` `10``    ` `    ``# Iterate through the cnt array``    ``for` `i ``in` `range``(``10``):` `        ``# If frequency of digit``        ``# is greater than 1``        ``if` `(cnt[i] > ``1``):` `            ``# Increment the count``            ``# of Repeating digits``            ``res ``+``=` `1``        ` `    ``# Return count of repeating digit``    ``return` `res` `# Driver Code` `# Given array arr[]``N ``=` `12` `# Function call``print``(countRepeatingDigits(N))` `# This code is contributed by sanjoy_62`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG{` `// Function that returns the count of``// repeating digits of the given number``static` `int` `countRepeatingDigits(``int` `N)``{``    ``// Initialize a variable to store``    ``// count of Repeating digits``    ``int` `res = 0;` `    ``// Initialize cnt array to``    ``// store digit count``    ``int` `[]cnt = ``new` `int``[10];` `    ``// Iterate through the digits of N``    ``while` `(N > 0)``    ``{` `        ``// Retrieve the last digit of N``        ``int` `rem = N % 10;` `        ``// Increase the count of digit``        ``cnt[rem]++;` `        ``// Remove the last digit of N``        ``N = N / 10;``    ``}` `    ``// Iterate through the cnt array``    ``for` `(``int` `i = 0; i < 10; i++)``    ``{` `        ``// If frequency of digit``        ``// is greater than 1``        ``if` `(cnt[i] > 1)``        ``{` `            ``// Increment the count``            ``// of Repeating digits``            ``res++;``        ``}``    ``}` `    ``// Return count of repeating digit``    ``return` `res;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``// Given array []arr``    ``int` `N = 12;` `    ``// Function Call``    ``Console.WriteLine(countRepeatingDigits(N));``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

`0`

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

#### Method #2:Using built in python functions:

• Convert integer to string.
• Use the Counter function to count the frequency of characters.
• If the frequency is greater than 1 increment the count

Below is the implementation:

## C++

 `#include ``#include ``#include ` `using` `namespace` `std;` `// Function that returns the count of``// repeating digits of the given number``int` `countRepeatingDigits(``int` `N)``{` `  ``// Converting int to string``  ``string number = to_string(N);` `  ``// Initializing count``  ``int` `count = 0;``  ``unordered_map<``char``, ``int``> frequency;` `  ``// Finding frequency of each character``  ``for` `(``char` `c : number) {``    ``frequency++;``  ``}``  ``for` `(``auto``& it : frequency) {``    ``if` `(it.second > 1) {``      ``count++;``    ``}``  ``}``  ``// return the count``  ``return` `count;``}` `int` `main()``{``  ``int` `N = 1232145;` `  ``// Function call``  ``cout << countRepeatingDigits(N) << endl;``  ``return` `0;``}`

## Java

 `import` `java.util.HashMap;` `public` `class` `Main {``    ``//Function that returns the count of``    ``//repeating digits of the given number``    ``static` `int` `countRepeatingDigits(``int` `N)``    ``{``        ``// Converting int to string``        ``String number = Integer.toString(N);``          ``// Initializing count``        ``int` `count = ``0``;``        ``HashMap frequency``            ``= ``new` `HashMap<>();``        ``// Finding frequency of each character``        ``for` `(``char` `c : number.toCharArray()) {``            ``frequency.put(c,``                          ``frequency.getOrDefault(c, ``0``) + ``1``);``        ``}``        ``for` `(``char` `key : frequency.keySet()) {``            ``if` `(frequency.get(key) > ``1``) {``                ``count++;``            ``}``        ``}``        ``// return the count``        ``return` `count;``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``1232145``;``          ``// Function call``        ``System.out.println(countRepeatingDigits(N));``    ``}``}`

## Python3

 `# Python3 program for the above approach``from` `collections ``import` `Counter` `# Function that returns the count of``# repeating digits of the given number``def` `countRepeatingDigits(N):``  ` `    ``# converting integer to string``    ``number ``=` `str``(N)``    ` `    ``# initializing count = 0``    ``count ``=` `0``    ``frequency ``=` `Counter(number)``    ` `    ``# Traversing frequency``    ``for` `i ``in` `frequency:``        ``if``(frequency[i] > ``1``):``          ` `            ``# increase the count``            ``count ``=` `count``+``1``    ``return` `count` `# Driver Code`  `# Given array arr[]``N ``=` `1232145` `# Function call``print``(countRepeatingDigits(N))` `# This code is contributed by vikkycirus`

## Javascript

 `// js equivalent` `// Function that returns the count of``// repeating digits of the given number``function` `countRepeatingDigits(N)``{` `    ``// Converting int to string``    ``let number = N.toString();``    ` `    ``// Initializing count``    ``let count = 0;``    ``let frequency = {};``    ` `    ``// Finding frequency of each character``    ``for` `(let c of number) {``        ``frequency = (frequency || 0) + 1;``    ``}``    ``for` `(let key ``in` `frequency) {``        ``if` `(frequency[key] > 1) {``            ``count++;``        ``}``    ``}``    ` `    ``// return the count``    ``return` `count;``}` `// Function call``let N = 1232145;``console.log(countRepeatingDigits(N));`

## C#

 `using` `System;``using` `System.Collections.Generic;` `public` `class` `Program``{``    ``// Function that returns the count of``    ``// repeating digits of the given number``    ``public` `static` `int` `countRepeatingDigits(``int` `N)``    ``{``        ``// Converting int to string``        ``string` `number = N.ToString();` `        ``// Initializing count``        ``int` `count = 0;``        ``Dictionary<``char``, ``int``> frequency = ``new` `Dictionary<``char``, ``int``>();` `        ``// Finding frequency of each character``        ``foreach` `(``char` `c ``in` `number)``        ``{``            ``if` `(!frequency.ContainsKey(c))``            ``{``                ``frequency = 0;``            ``}``            ``frequency++;``        ``}` `        ``foreach` `(KeyValuePair<``char``, ``int``> item ``in` `frequency)``        ``{``            ``if` `(item.Value > 1)``            ``{``                ``count++;``            ``}``        ``}` `        ``// return the count``        ``return` `count;``    ``}` `    ``public` `static` `void` `Main()``    ``{``        ``int` `N = 1232145;` `        ``// Function call``        ``Console.WriteLine(countRepeatingDigits(N));``    ``}``}`

Output

`2`

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

My Personal Notes arrow_drop_up