Recuento de dígitos únicos en un número dado N

Dado un número N , la tarea es contar el número de dígitos únicos en el número dado.

Ejemplos:

Entrada: N = 22342 
Salida: 2 
Explicación:
Los dígitos 3 y 4 aparecen solo una vez. Por lo tanto, la salida es 2.

Entrada: N = 99677 
Salida: 1
Explicación:
El dígito 6 aparece solo una vez. Por lo tanto, la salida es 1. 

Enfoque ingenuo: mediante este enfoque, el problema se puede resolver utilizando dos bucles anidados. En el primer ciclo, recorra desde el primer dígito del número hasta el último, uno por uno. Luego, para cada dígito en el primer ciclo, ejecute un segundo ciclo y busque si este dígito también está presente en algún otro lugar del número. Si no, aumente el conteo requerido en 1. Al final, imprima el conteo requerido calculado.
Tiempo Complejidad: O(L ² ) 
Espacio Auxiliar: O(1)
 

Enfoque eficiente: la idea es usar Hashing para almacenar la frecuencia de los dígitos y luego contar los dígitos con una frecuencia igual a 1 . Siga los pasos a continuación para resolver el problema:
 

1. Cree una HashTable de tamaño 10 para los dígitos 0-9. Almacene inicialmente cada índice como 0.
2. Ahora, para cada dígito del número N, incremente el recuento de ese índice en la tabla hash.
3. Recorra la tabla hash y cuente los índices que tienen un valor igual a 1.
4. Al final, imprima/devuelva este recuento.

A continuación se muestra la implementación del enfoque anterior:

// 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;
}

// 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);
    }
}

# 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

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

<script>
 
// Javascript program for the above approach
 
// Function that returns the count of
// unique digits of the given number
function countUniqueDigits(N)
{
    // Initialize a variable to store
    // count of unique digits
    let res = 0;
 
    // Initialize cnt array to store
    // digit count
    let cnt = [0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0];
 
    // Iterate through the digits of N
    while (N > 0) {
 
        // Retrieve the last digit of N
        let rem = N % 10;
 
        // Increase the count
        // of the last digit
        cnt[rem]++;
 
        // Remove the last digit of N
        N = Math.floor(N / 10);
    }
 
    // Iterate through the cnt array
    for (let 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
 
    // Given array arr[]
    let N = 2234262;
 
    // Function Call
    document.write(countUniqueDigits(N));
     
// This code is contributed by Mayank Tyagi
 
</script>

3

Complejidad temporal: O(N) , donde N es el número de dígitos del número.
Espacio Auxiliar: O(1)

Nota: Como la tabla hash utilizada tiene un tamaño de solo 10, su complejidad de tiempo y espacio será casi constante. Por lo tanto, no se cuenta en el tiempo anterior y el espacio auxiliar.