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
#include <iostream> #include <string> 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;
} |
// Java program for the above approach public class GFG {
// Function to count the number of repeating digits
// in a given number
public static int countRepeatingDigits( int num) {
int count = 0 ;
String strNum = Integer.toString(num); // Convert the number to a string
// Outer loop to iterate through each digit in the number
for ( int i = 0 ; i < strNum.length(); i++) {
// Inner loop to compare the current digit with subsequent digits
for ( int j = i + 1 ; j < strNum.length(); j++) {
// Check if the current digit (at index i) is equal to the subsequent digit (at index j)
if (strNum.charAt(i) == strNum.charAt(j)) {
count++; // Increment count if a repeating digit is found
break ; // Exit the inner loop once a repeating digit is found
}
}
}
return count;
}
public static void main(String[] args) {
int num = 99677 ;
int repeatingDigits = countRepeatingDigits(num);
System.out.println( "Number of repeating digits: " + repeatingDigits);
}
} |
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)
|
using System;
class GFG
{ // Function to count the number of repeating digits
// in a given number
public static int CountRepeatingDigits( int num)
{
int count = 0;
string strNum = num.ToString(); // Convert the number to a string
// Outer loop to iterate through each digit in the number
for ( int i = 0; i < strNum.Length; i++)
{
// Inner loop to compare the current digit with subsequent digits
for ( int j = i + 1; j < strNum.Length; j++)
{
// Check if the current digit (at index i) is
// equal to the subsequent digit (at index j)
if (strNum[i] == strNum[j])
{
count++; // Increment count if a repeating digit is found
break ; // Exit the inner loop once a repeating digit is found
}
}
}
return count;
}
public static void Main( string [] args)
{
int num = 99677;
int repeatingDigits = CountRepeatingDigits(num);
Console.WriteLine( "Number of repeating digits: " + repeatingDigits);
}
} |
function count_repeating_digits(num) {
let count = 0;
let str_num = num.toString(); // Convert the number to a string
for (let i = 0; i < str_num.length; i++) {
for (let 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;
} let num=99677; let repeating_digits = count_repeating_digits(num); document.write( "Number of repeating digits: " + repeating_digits);
|
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++ program for the above approach #include <bits/stdc++.h> 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 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 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# 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 |
<script> // Javascript program for the above approach // Function that returns the count of // repeating digits of the given number function countRepeatingDigits(N)
{ // Initialize a variable to store
// count of Repeating digits
var res = 0;
// Initialize cnt array to
// store digit count
var cnt = Array(10).fill(0);
// Iterate through the digits of N
while (N > 0) {
// Retrieve the last digit of N
var 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 ( var 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 // Given array arr[] var N = 12;
// Function Call document.write( countRepeatingDigits(N)); // This code is contributed by rrrtnx. </script> |
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:
#include <iostream> #include <unordered_map> #include <string> 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;
} |
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<Character, Integer> 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 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 |
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));
}
} |
// 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)); |
2
Time Complexity: O(N)
Auxiliary Space: O(N)