Números que tienen dígitos únicos (o distintos)

Dado un rango, imprime todos los números que tienen dígitos únicos. 

Ejemplos: 

Input : 10 20
Output : 10 12 13 14 15 16 17 18 19 20  (Except 11)

Input : 1 10
Output : 1 2 3 4 5 6 7 8 9 10

Acercarse:

As the problem is pretty simple, the only thing to be done is :-
1- Find the digits one by one and keep marking visited digits.
2- If all digits occurs one time only then print that number.
3- Else not.

Implementación:

// C++ implementation to find unique digit
// numbers in a range
#include<bits/stdc++.h>
using namespace std;
 
// Function to print unique digit numbers
// in range from l to r.
void printUnique(int l, int r)
{
    // Start traversing the numbers
    for (int i=l ; i<=r ; i++)
    {
        int num = i;
        bool visited[10] = {false};
 
        // Find digits and maintain its hash
        while (num)
        {
            // if a digit occurs more than 1 time
            // then break
            if (visited[num % 10])
                break;
 
            visited[num%10] = true;
 
            num = num/10;
        }
 
        // num will be 0 only when above loop
        // doesn't get break that means the
        // number is unique so print it.
        if (num == 0)
            cout << i << " ";
    }
}
 
// Driver code
int main()
{
    int l = 1, r = 20;
    printUnique(l, r);
    return 0;
}

// Java implementation to find unique digit
// numbers in a range
class Test
{
    // Method to print unique digit numbers
    // in range from l to r.
    static void printUnique(int l, int r)
    {
        // Start traversing the numbers
        for (int i=l ; i<=r ; i++)
        {
            int num = i;
            boolean visited[] = new boolean[10];
      
            // Find digits and maintain its hash
            while (num != 0)
            {
                // if a digit occurs more than 1 time
                // then break
                if (visited[num % 10])
                    break;
      
                visited[num%10] = true;
      
                num = num/10;
            }
      
            // num will be 0 only when above loop
            // doesn't get break that means the
            // number is unique so print it.
            if (num == 0)
                System.out.print(i + " ");
        }
    }
     
    // Driver method
    public static void main(String args[])
    {
        int l = 1, r = 20;
        printUnique(l, r);
    }
}

# Python3 implementation
# to find unique digit
# numbers in a range
 
# Function to print
# unique digit numbers
# in range from l to r.
def printUnique(l,r):
     
    # Start traversing
    # the numbers
    for i in range (l, r + 1):
        num = i;
        visited = [0,0,0,0,0,0,0,0,0,0];
         
        # Find digits and
        # maintain its hash
        while (num):
             
            # if a digit occurs
            # more than 1 time
            # then break
            if visited[num % 10] == 1:
                break;
            visited[num % 10] = 1;
            num = (int)(num / 10);
             
        # num will be 0 only when
        # above loop doesn't get
        # break that means the
        # number is unique so
        # print it.
        if num == 0:
            print(i, end = " ");
 
# Driver code
l = 1;
r = 20;
printUnique(l, r);
 
# This code is
# contributed by mits

// C# implementation to find unique digit
// numbers in a range
using System;
         
public class GFG {
     
    // Method to print unique digit numbers
    // in range from l to r.
    static void printUnique(int l, int r)
    {
         
        // Start traversing the numbers
        for (int i = l ; i <= r ; i++)
        {
            int num = i;
            bool []visited = new bool[10];
     
            // Find digits and maintain
            // its hash
            while (num != 0)
            {
                 
                // if a digit occurs more
                // than 1 time then break
                if (visited[num % 10])
                    break;
     
                visited[num % 10] = true;
     
                num = num / 10;
            }
     
            // num will be 0 only when
            // above loop doesn't get
            // break that means the number
            // is unique so print it.
            if (num == 0)
                Console.Write(i + " ");
        }
    }
     
    // Driver method
    public static void Main()
    {
        int l = 1, r = 20;
        printUnique(l, r);
    }
}
 
// This code is contributed by Sam007.

<?php
// PHP implementation to find unique
// digit numbers in a range
 
// Function to print unique digit
// numbers in range from l to r.
function printUnique($l, $r)
{
    // Start traversing the numbers
    for ($i = $l ; $i <= $r; $i++)
    {
        $num = $i;
        $visited = (false);
 
        // Find digits and
        // maintain its hash
        while ($num)
        {
            // if a digit occurs more
            // than 1 time then break
            if ($visited[$num % 10])
             
            $visited[$num % 10] = true;
 
            $num = (int)$num / 10;
        }
 
        // num will be 0 only when above
        // loop doesn't get break that
        // means the number is unique
        // so print it.
        if ($num == 0)
            echo $i , " ";
    }
}
 
// Driver code
$l = 1; $r = 20;
printUnique($l, $r);
 
// This code is contributed by aj_36
?>

<script>
 
// Javascript implementation to find unique digit
// numbers in a range
 
// Function to print unique digit numbers
// in range from l to r.
function printUnique(l, r)
{
    // Start traversing the numbers
    for (let i=l ; i<=r ; i++)
    {
        let num = i;
        let visited = new Array(10);
 
        // Find digits and maintain its hash
        while (num)
        {
            // if a digit occurs more than 1 time
            // then break
            if (visited[num % 10])
                break;
 
            visited[num%10] = true;
 
            num = Math.floor(num/10);
        }
 
        // num will be 0 only when above loop
        // doesn't get break that means the
        // number is unique so print it.
        if (num == 0)
            document.write(i + " ");
    }
}
 
// Driver code
 
    let l = 1, r = 20;
    printUnique(l, r);
     
// This code is contributed by Mayank Tyagi
 
</script>

1 2 3 4 5 6 7 8 9 10 12 13 14 15 16 17 18 19 20 

Complejidad de tiempo: O(nlogn)
Espacio auxiliar: O(1)

Otro enfoque: use set STL para C++ y Java Collections para Java para verificar si un número tiene solo dígitos únicos. Entonces podemos comparar el tamaño de las strings formadas a partir de un número dado y un conjunto recién creado. Por ejemplo, consideremos el número 1987, luego podemos convertir el número en la string,

Implementación:

int n;
cin>>n;
string s = to_string(n);

//creating scanner class object for taking user input
Scanner sc = new Scanner(System.in);
 
int n=sc.nextInt();
 
//converting the number to string using String.valueof(number);
string s = String.valueof(n);

n = int(input())
s = str(n)

int n = Convert.ToInt32(Console.ReadLine());
 
// converting the number to string using
// String.valueof(number);
string s = Convert.ToString(n);

Después de eso, inicialice un conjunto con el contenido de la string s.

set<int> uniDigits(s.begin(), s.end());

HashSet<Integer> uniDigits = new HashSet<Integer>();
for(int i:s.tocharArray())
{
    uniDigits.add(i);
}

uniDigits = set(s)

var uniDigits = new HashSet<char>(s.ToCharArray());

Luego podemos comparar el tamaño de las strings y los uniDigits recién creados.

Aquí está el código para el enfoque anterior:

// C++ code for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to print unique
// numbers
void printUnique(int l, int r){
   
  // Iterate from l to r
  for (int i = l; i <= r; i++) {
       
        // Convert the no. to
        // string
        string s = to_string(i);
       
        // Convert string to set using stl
        set<int> uniDigits(s.begin(), s.end());
       
        // Output if condition satisfies
        if (s.size() == uniDigits.size()) {
            cout << i << " ";
        }
    }
}
 
// Driver Code
int main()
{
   
    // Input of the lower and
    // higher limits
    int l = 1, r = 20;
     
    // Function Call
    printUnique(l, r);
    return 0;
}

// Java code for the above approach
import java.util.*;
 
class GFG{
 
// Function to print unique
// numbers
static void printUnique(int l, int r)
{
     
    // Iterate from l to r
    for(int i = l; i <= r; i++)
    {
         
        // Convert the no. to
        // String
        String s = String.valueOf(i);
       
        // Convert String to set using Java Collections
        HashSet<Integer> uniDigits = new HashSet<Integer>();
        for(int c : s.toCharArray())
            uniDigits.add(c);
             
        // Output if condition satisfies
        if (s.length() == uniDigits.size())
        {
            System.out.print(i+ " ");
        }
    }
}
 
// Driver Code
public static void main(String[] args)
{
   
    // Input of the lower and
    // higher limits
    int l = 1, r = 20;
     
    // Function Call
    printUnique(l, r);
}
}
 
// This code is contributed by Princi Singh

# Python code for the above approach
 
# Function to print unique
# numbers
def printUnique(l, r):
 
    # Iterate from l to r
    for i in range(l, r+1):
         
        # Convert the no. to
        # string
        s = list(str(i))
         
        # print(s)
        # Convert string to set using stl
        unitDigits = set()
        for j in range(len(s)):
            unitDigits.add(s[j])
 
        # Output if condition satisfies
        if len(s) == len(unitDigits):
            print(i, end = " ")
 
# Driver Code
# Input of the lower and
# higher limits
l = 1
r = 20
 
# Function Call
printUnique(l, r)
 
# The code is contributed by Nidhi goel

// C# code for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to print unique
// numbers
static void printUnique(int l, int r)
{
     
    // Iterate from l to r
    for(int i = l; i <= r; i++)
    {
         
        // Convert the no. to
        // String
        String s = String.Join("", i);
       
        // Convert String to set using stl
        HashSet<int> uniDigits = new HashSet<int>();
        foreach(int c in s.ToCharArray())
            uniDigits.Add(c);
             
        // Output if condition satisfies
        if (s.Length == uniDigits.Count)
        {
            Console.Write(i + " ");
        }
    }
}
 
// Driver Code
public static void Main(String[] args)
{
   
    // Input of the lower and
    // higher limits
    int l = 1, r = 20;
     
    // Function Call
    printUnique(l, r);
}
}
 
// This code is contributed by Princi Singh

<script>
 
// JavaScript code for the above approach
 
// Function to print unique
// numbers
function printUnique(l, r) {
 
    // Iterate from l to r
    for (let i = l; i <= r; i++) {
 
        // Convert the no. to
        // string
        let s = String(i);
 
        // Convert string to set using stl
        let uniDigits = new Set();
        for(let c of s.split(""))
            uniDigits.add(c);
             
        // Output if condition satisfies
        if (s.length == uniDigits.size) {
            document.write(i + " ");
        }
    }
}
 
// Driver Code
 
// Input of the lower and
// higher limits
let l = 1, r = 20;
 
// Function Call
printUnique(l, r);
 
</script>

1 2 3 4 5 6 7 8 9 10 12 13 14 15 16 17 18 19 20 

Complejidad temporal: O(nlogn)
Espacio auxiliar: O(n)

Este artículo es una contribución de Sahil Chhabra . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.