Count of unique digits in a given number N

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

Examples:

Input: N = 22342 
Output:
Explanation:
The digits 3 and 4 occurs only once. Hence, the output is 2.

Input: N = 99677 
Output: 1
Explanation:
The digit 6 occurs only once. Hence, the output is 1. 

 

Naive Approach: By this approach, the problem can be solved using 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 no, then increase the required count by 1. In the end, print the calculated required count.
Time Complexity: O(L2
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 1. Follow the steps below to solve the problem:



  1. Create a HashTable of size 10 for digits 0-9. Initially store each index as 0.
  2. Now for each digit of number N, increment the count of that index in the hashtable.
  3. Traverse the hashtable and count the indices that have value equal to 1.
  4. At the end, print/return this count.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
#include <iostream>
using namespace std;
  
// Function that returns the count of
// unique digits of the given number
int countUniqueDigits(int N)
{
    // Initialize a variable to store
    // count of unique 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 the last 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 1
        if (cnt[i] == 1) {
  
            // Increment the count
            // of unique digits
            res++;
        }
    }
  
    // Return the count/ of unique digit
    return res;
}
  
// Driver Code
int main()
{
    // Given array arr[]
    int N = 2234262;
  
    // Function Call
    cout << countUniqueDigits(N);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
import java.util.*;
  
class GFG {
  
    // Function that returns the count
    // of unique digits of number N
    public static void
    countUniqueDigits(int N)
    {
        // Initialize a variable to
        // store count of unique digits
        int res = 0;
  
        // Initialize cnt array to
        // store digit count
        int cnt[] = { 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0 };
  
        // Iterate through digits of N
        while (N > 0) {
  
            // Retrieve the last
            // digit of N
            int rem = N % 10;
  
            // Increase the count
            // of the last digit
            cnt[rem]++;
  
            // Remove the last
            // digit of N
            N = N / 10;
        }
  
        // Iterate through the
        // cnt array
        for (int i = 0;
             i < cnt.length; i++) {
  
            // If frequency of
            // digit is 1
            if (cnt[i] == 1) {
  
                // Increment the count
                // of unique digits
                res++;
            }
        }
  
        // Return the count of unique digit
        System.out.println(res);
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        // Given Number N
        int N = 2234262;
  
        // Function Call
        countUniqueDigits(N);
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach 
  
# Function that returns the count of 
# unique digits of the given number 
def countUniqueDigits(N):
  
    # Initialize a variable to store
    # count of unique digits
    res = 0
  
    # Initialize cnt list 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 the last digit
        cnt[rem] += 1
  
        # Remove the last digit of N
        N = N // 10
  
    # Iterate through the cnt list
    for i in range(10):
  
        # If frequency of
        # digit is 1
        if (cnt[i] == 1):
  
            # Increment the count
            # of unique digits
            res += 1
  
    # Return the count of unique digit
    return res 
  
# Driver Code
  
# Given number N
N = 2234262
  
# Function call 
print(countUniqueDigits(N)) 
  
# This code is contributed by vishu2908

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
  
class GFG{
  
// Function that returns the count
// of unique digits of number N
public static void countUniqueDigits(int N)
{
      
    // Initialize a variable to
    // store count of unique digits
    int res = 0;
  
    // Initialize cnt array to
    // store digit count
    int[] cnt = { 0, 0, 0, 0, 0,
                  0, 0, 0, 0, 0 };
  
    // Iterate through digits of N
    while (N > 0) 
    {
          
        // Retrieve the last
        // digit of N
        int rem = N % 10;
  
        // Increase the count
        // of the last digit
        cnt[rem]++;
  
        // Remove the last
        // digit of N
        N = N / 10;
    }
  
    // Iterate through the
    // cnt array
    for(int i = 0; i < cnt.Length; i++)
    {
          
        // If frequency of
        // digit is 1
        if (cnt[i] == 1) 
        {
              
            // Increment the count
            // of unique digits
            res++;
        }
    }
      
    // Return the count of unique digit
    Console.WriteLine(res);
}
  
// Driver Code
public static void Main(String[] args)
{
      
    // Given Number N
    int N = 2234262;
  
    // Function Call
    countUniqueDigits(N);
}
}
  
// This code is contributed by jrishabh99

chevron_right


Output:

3

Time Complexity: O(N), where N is the number of digits of the number.
Auxiliary Space: O(1)

Note: As the used hashtable is of size only 10, therefore its time and space complexity will be near to constant. Hence it is not counted in the above time and auxiliary space.
 

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.




My Personal Notes arrow_drop_up

Recommended Posts:



If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : jrishabh99, vishu2908