Skip to content
Related Articles

Related Articles

Total numbers with no repeated digits in a range

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 29 Aug, 2022
Improve Article
Save Article

Given a range L, R  find total such numbers in the given range such that they have no repeated digits. For example: 12 has no repeated digit. 22 has repeated digit. 102, 194 and 213 have no repeated digit. 212, 171 and 4004 have repeated digits. Examples: 

Input : 10 12
Output : 2
Explanation : In the given range 
10 and 12 have no repeated digit 
where as 11 has repeated digit.

Input : 1 100
Output : 90

Brute Force We will traverse through each element in the given range and count the number of digits which do not have repeated digits. 

C++




// C++ implementation of brute
// force solution.
#include <bits/stdc++.h>
using namespace std;
   
// Function to check if the given
// number has repeated digit or not
int repeated_digit(int n)
{
    unordered_set<int> s;
   
    // Traversing through each digit
    while(n != 0)
    {
        int d = n % 10;
   
        // if the digit is present
        // more than once in the
        // number
        if(s.find(d) != s.end())
        {
            // return 0 if the number
            // has repeated digit
            return 0;
        }
        s.insert(d);
        n = n / 10;
    }
    // return 1 if the number has
    // no repeated digit
    return 1;
}
   
// Function to find total number
// in the given range which has
// no repeated digit
int calculate(int L,int R)
{
    int answer = 0;
   
    // Traversing through the range
    for(int i = L; i < R + 1; ++i)
    {
   
        // Add 1 to the answer if i has
        // no repeated digit else 0
        answer = answer + repeated_digit(i);
    }
   
    return answer ;
}
   
// Driver Code
int main()
{
    int L = 1, R = 100;
   
    // Calling the calculate
    cout << calculate(L, R);
    return 0;
}
   
// This code is contributed by
// Sanjit_Prasad

Java




// Java implementation of brute
// force solution.
import java.util.LinkedHashSet;
 
class GFG
{
// Function to check if the given
// number has repeated digit or not
static int repeated_digit(int n)
{
    LinkedHashSet<Integer> s = new LinkedHashSet<>();
 
    // Traversing through each digit
    while (n != 0)
    {
        int d = n % 10;
 
        // if the digit is present
        // more than once in the
        // number
        if (s.contains(d))
        {
            // return 0 if the number
            // has repeated digit
            return 0;
        }
        s.add(d);
        n = n / 10;
    }
     
    // return 1 if the number has
    // no repeated digit
    return 1;
}
 
// Function to find total number
// in the given range which has
// no repeated digit
static int calculate(int L, int R)
{
    int answer = 0;
 
    // Traversing through the range
    for (int i = L; i < R + 1; ++i)
    {
 
        // Add 1 to the answer if i has
        // no repeated digit else 0
        answer = answer + repeated_digit(i);
    }
 
    return answer;
}
 
// Driver Code
public static void main(String[] args)
{
    int L = 1, R = 100;
     
    // Calling the calculate
    System.out.println(calculate(L, R));
}
}
 
// This code is contributed by RAJPUT-JI

Python3




# Python implementation of brute
# force solution.
 
# Function to check if the given
# number has repeated digit or not
def repeated_digit(n):
    a = []
     
    # Traversing through each digit
    while n != 0:
        d = n%10
         
        # if the digit is present
        # more than once in the
        # number
        if d in a:
             
            # return 0 if the number
            # has repeated digit
            return 0
        a.append(d)
        n = n//10
     
    # return 1 if the number has no
    # repeated digit
    return 1
 
# Function to find total number
# in the given range which has
# no repeated digit
def calculate(L,R):
    answer = 0
     
    # Traversing through the range
    for i in range(L,R+1):
         
        # Add 1 to the answer if i has
        # no repeated digit else 0
        answer = answer + repeated_digit(i)
     
    # return answer
    return answer
     
# Driver's Code
L=1
R=100
 
# Calling the calculate
print(calculate(L, R))

C#




// C# implementation of brute
// force solution.
using System;
using System.Collections.Generic;
 
class GFG
{
 
// Function to check if the given
// number has repeated digit or not
static int repeated_digit(int n)
{
    var s = new HashSet<int>();
 
    // Traversing through each digit
    while (n != 0)
    {
        int d = n % 10;
 
        // if the digit is present
        // more than once in the
        // number
        if (s.Contains(d))
        {
            // return 0 if the number
            // has repeated digit
            return 0;
        }
        s.Add(d);
        n = n / 10;
    }
     
    // return 1 if the number has
    // no repeated digit
    return 1;
}
 
// Function to find total number
// in the given range which has
// no repeated digit
static int calculate(int L, int R)
{
    int answer = 0;
 
    // Traversing through the range
    for (int i = L; i < R + 1; ++i)
    {
 
        // Add 1 to the answer if i has
        // no repeated digit else 0
        answer = answer + repeated_digit(i);
    }
 
    return answer;
}
 
// Driver Code
public static void Main(String[] args)
{
    int L = 1, R = 100;
     
    // Calling the calculate
    Console.WriteLine(calculate(L, R));
}
}
 
// This code is contributed by RAJPUT-JI

PHP




<?php
// PHP implementation of
// brute force solution.
 
// Function to check if
// the given number has
// repeated digit or not
function repeated_digit($n)
{
    $c = 10;
    $a = array_fill(0, $c, 0);
     
    // Traversing through
    // each digit
    while($n > 0)
    {
        $d = $n % 10;
         
        // if the digit is present
        // more than once in the
        // number
        if ($a[$d] > 0)
        {
            // return 0 if the number
            // has repeated digit
            return 0;
        }
        $a[$d]++;
        $n = (int)($n / 10);
    }
     
    // return 1 if the number
    // has no repeated digit
    return 1;
}
 
// Function to find total
// number in the given range
// which has no repeated digit
function calculate($L, $R)
{
    $answer = 0;
     
    // Traversing through
    // the range
    for($i = $L; $i <= $R; $i++)
    {
         
        // Add 1 to the answer if
        // i has no repeated digit
        // else 0
        $answer += repeated_digit($i);
    }
     
    // return answer
    return $answer;
}
 
// Driver Code
$L = 1;
$R = 100;
 
// Calling the calculate
echo calculate($L, $R);
 
// This code is contributed by mits
?>

Javascript




// JS implementation of brute
// force solution.
 
// Function to check if the given
// number has repeated digit or not
function repeated_digit(n)
{
    let s = new Set();
 
    // Traversing through each digit
    while(n != 0)
    {
        let d = n % 10;
 
        // if the digit is present
        // more than once in the
        // number
        if(s.has(d))
        {
            // return 0 if the number
            // has repeated digit
            return 0;
        }
        s.add(d);
        n = Math.floor(n / 10);
    }
    // return 1 if the number has
    // no repeated digit
    return 1;
}
 
// Function to find total number
// in the given range which has
// no repeated digit
function calculate(L, R)
{
    let answer = 0;
 
    // Traversing through the range
    for(var i = L; i < R + 1; ++i)
    {
 
        // Add 1 to the answer if i has
        // no repeated digit else 0
        answer = answer + repeated_digit(i);
    }
 
    return answer ;
}
 
// Driver Code
let  L = 1, R = 100;
 
// Calling the calculate
console.log(calculate(L, R))
 
 
// This code is contributed by
// phasing17

Output:

90

This method will answer each query in O( N ) time.

Efficient Approach

We will calculate a prefix array of the numbers which have no repeated digit. Prefix[i]  = Total number with no repeated digit less than or equal to 1. Therefore each query can be solved in O(1) time. Answer = Prefix[R] - Prefix[L-1]

Below is the implementation of above idea.

C++




// C++ implementation of above idea
#include <bits/stdc++.h>
 
using namespace std;
 
// Maximum
int MAX = 1000;
 
// Prefix Array
vector<int> Prefix = {0};
 
// Function to check if the given
// number has repeated digit or not
int repeated_digit(int n)
{
     
    unordered_set<int> a;
    int d;
     
    // Traversing through each digit
    while (n != 0)
    {
        d = n % 10;
         
        // if the digit is present
        // more than once in the
        // number
        if (a.find(d) != a.end())
             
            // return 0 if the number
            // has repeated digit
            return 0;
         
        a.insert(d);
        n = n / 10;
    }
     
    // return 1 if the number has no
    // repeated digit
    return 1;
}
 
// Function to pre calculate
// the Prefix array
void pre_calculation(int MAX)
{
     
    Prefix.push_back(repeated_digit(1));
     
    // Traversing through the numbers
    // from 2 to MAX
    for (int i = 2; i < MAX + 1; i++)
         
        // Generating the Prefix array
        Prefix.push_back(repeated_digit(i) + Prefix[i-1]);
}
 
// Calclute Function
int calculate(int L,int R)
{
     
    // Answer
    return Prefix[R] - Prefix[L-1];
}
 
// Driver code
int main()
{
    int L = 1, R = 100;
     
    // Pre-calculating the Prefix array.
    pre_calculation(MAX);
     
    // Calling the calculate function
    // to find the total number of number
    // which has no repeated digit
    cout << calculate(L, R) << endl;
 
    return 0;
}
 
// This code is contributed by Rituraj Jain

Java




// Java implementation of above idea
import java.util.*;
 
class GFG
{
 
    // Maximum
    static int MAX = 100;
 
    // Prefix Array
    static Vector<Integer> Prefix = new Vector<>();
 
    // Function to check if the given
    // number has repeated digit or not
    static int repeated_digit(int n)
    {
        HashSet<Integer> a = new HashSet<>();
        int d;
 
        // Traversing through each digit
        while (n != 0)
        {
            d = n % 10;
 
            // if the digit is present
            // more than once in the
            // number
            if (a.contains(d))
 
                // return 0 if the number
                // has repeated digit
                return 0;
            a.add(d);
            n /= 10;
        }
 
        // return 1 if the number has no
        // repeated digit
        return 1;
    }
 
    // Function to pre calculate
    // the Prefix array
    static void pre_calculations()
    {
        Prefix.add(0);
        Prefix.add(repeated_digit(1));
 
        // Traversing through the numbers
        // from 2 to MAX
        for (int i = 2; i < MAX + 1; i++)
 
            // Generating the Prefix array
            Prefix.add(repeated_digit(i) + Prefix.elementAt(i - 1));
    }
 
    // Calclute Function
    static int calculate(int L, int R)
    {
 
        // Answer
        return Prefix.elementAt(R) - Prefix.elementAt(L - 1);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int L = 1, R = 100;
 
        // Pre-calculating the Prefix array.
        pre_calculations();
 
        // Calling the calculate function
        // to find the total number of number
        // which has no repeated digit
        System.out.println(calculate(L, R));
    }
}
 
// This code is contributed by
// sanjeev2552

Python3




# Python implementation of
# above idea
 
# Prefix Array
Prefix = [0]
 
# Function to check if
# the given number has
# repeated digit or not
def repeated_digit(n):
    a = []
     
    # Traversing through each digit
    while n != 0:
        d = n%10
         
        # if the digit is present
        # more than once in the
        # number
        if d in a:
             
            # return 0 if the number
            # has repeated digit
            return 0
        a.append(d)
        n = n//10
     
    # return 1 if the number has no
    # repeated digit
    return 1
 
# Function to pre calculate
# the Prefix array
def pre_calculation(MAX):
     
    # To use to global Prefix array
    global Prefix
    Prefix.append(repeated_digit(1))
     
    # Traversing through the numbers
    # from 2 to MAX
    for i in range(2,MAX+1):
         
        # Generating the Prefix array
        Prefix.append( repeated_digit(i) +
                       Prefix[i-1] )
 
# Calclute Function
def calculate(L,R):
     
    # Answer
    return Prefix[R]-Prefix[L-1]
 
 
# Driver Code
 
# Maximum
MAX = 1000
 
# Pre-calculating the Prefix array.
pre_calculation(MAX)
 
# Range
L=1
R=100
 
# Calling the calculate function
# to find the total number of number
# which has no repeated digit
print(calculate(L, R))

C#




// C# implementation of above idea
using System;
using System.Collections.Generic;
 
class GFG
{
 
    // Maximum
    static int MAX = 100;
 
    // Prefix Array
    static List<int> Prefix = new List<int>();
 
    // Function to check if the given
    // number has repeated digit or not
    static int repeated_digit(int n)
    {
        HashSet<int> a = new HashSet<int>();
        int d;
 
        // Traversing through each digit
        while (n != 0)
        {
            d = n % 10;
 
            // if the digit is present
            // more than once in the
            // number
            if (a.Contains(d))
 
                // return 0 if the number
                // has repeated digit
                return 0;
            a.Add(d);
            n /= 10;
        }
 
        // return 1 if the number has no
        // repeated digit
        return 1;
    }
 
    // Function to pre calculate
    // the Prefix array
    static void pre_calculations()
    {
        Prefix.Add(0);
        Prefix.Add(repeated_digit(1));
 
        // Traversing through the numbers
        // from 2 to MAX
        for (int i = 2; i < MAX + 1; i++)
 
            // Generating the Prefix array
            Prefix.Add(repeated_digit(i) +
                           Prefix[i - 1]);
    }
 
    // Calclute Function
    static int calculate(int L, int R)
    {
 
        // Answer
        return Prefix[R] - Prefix[L - 1];
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int L = 1, R = 100;
 
        // Pre-calculating the Prefix array.
        pre_calculations();
 
        // Calling the calculate function
        // to find the total number of number
        // which has no repeated digit
        Console.WriteLine(calculate(L, R));
    }
}
 
// This code is contributed by 29AjayKumar

JavaScript




<script>
    // JavaScript implementation of brute
// force solution.
 
// Function to check if the given
// number has repeated digit or not
function repeated_digit(n){
    const s = new Set();
 
    // Traversing through each digit
    while(n != 0){
        let d = n % 10;
 
        // if the digit is present
        // more than once in the
        // number
        if(s.has(d)){
            // return 0 if the number
            // has repeated digit
            return 0;
        }
        s.add(d);
        n = Math.floor(n / 10);
    }
    // return 1 if the number has
    // no repeated digit
    return 1;
}
 
// Function to find total number
// in the given range which has
// no repeated digit
function calculate(L, R){
    let answer = 0;
 
    // Traversing through the range
    for(let i = L; i < R + 1; ++i){
        // Add 1 to the answer if i has
        // no repeated digit else 0
        answer = answer + repeated_digit(i);
    }
 
    return answer ;
}
 
// Driver Code
{
    let L = 1, R = 100;
 
    // Calling the calculate
    console.log(calculate(L, R));
}
 
// This code is contributed by Gautam goel (gautamgoel962)
</script>

Output:

90

My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!