# Count of numbers in the range [L, R] which satisfy the given conditions

• Difficulty Level : Hard
• Last Updated : 28 Feb, 2023

Given a range [L, R], the task is to find the count of numbers from this range that satisfy the below conditions:

1. All the digit in the number are distinct.
2. All the digits are less than or equal to 5.

Examples:

Input: L = 4, R = 13
Output:
4, 5, 10, 12 and 13 are the only
valid numbers in the range [4, 13].
Input: L = 100, R = 1000
Output: 100

Approach: The question seems simple if the range is small because in that case, all the numbers from the range can be iterated and checked whether they are valid or not. But since the range could be large, it can be observed all the digits of a valid number has to be distinct and from the range [0, 5] which suggests that the maximum number cannot exceed 543210.
Now instead of checking for every number, the next valid number in the series can be generated from the previously generated numbers. The idea is similar to the approach discussed here.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Maximum possible valid number``#define MAX 543210` `// To store all the required number``// from the range [1, MAX]``vector ans;` `// Function that returns true if x``// satisfies the given conditions``bool` `isValidNum(string x)``{` `    ``// To store the digits of x``    ``map<``int``, ``int``> mp;` `    ``for` `(``int` `i = 0; i < x.length(); i++) {` `        ``// If current digit appears more than once``        ``if` `(mp.find(x[i] - ``'0'``) != mp.end()) {``            ``return` `false``;``        ``}` `        ``// If current digit is greater than 5``        ``else` `if` `(x[i] - ``'0'` `> 5) {``            ``return` `false``;``        ``}` `        ``// Put the digit in the map``        ``else` `{``            ``mp[x[i] - ``'0'``] = 1;``        ``}``    ``}``    ``return` `true``;``}` `// Function to generate all the required``// numbers in the range [1, MAX]``void` `generate()``{` `    ``// Insert first 5 valid numbers``    ``queue q;``    ``q.push(``"1"``);``    ``q.push(``"2"``);``    ``q.push(``"3"``);``    ``q.push(``"4"``);``    ``q.push(``"5"``);` `    ``bool` `flag = ``true``;` `    ``// Inserting 0 externally because 0 cannot``    ``// be the leading digit in any number``    ``ans.push_back(``"0"``);` `    ``while` `(!q.empty()) {``        ``string x = q.front();``        ``q.pop();` `        ``// If x satisfies the given conditions``        ``if` `(isValidNum(x)) {``            ``ans.push_back(x);``        ``}` `        ``// Cannot append anymore digit as``        ``// adding a digit will repeat one of``        ``// the already present digits``        ``if` `(x.length() == 6)``            ``continue``;` `        ``// Append all the valid digits one by``        ``// one and push the new generated``        ``// number to the queue``        ``for` `(``int` `i = 0; i <= 5; i++) {``            ``string z = to_string(i);` `            ``// Append the digit``            ``string temp = x + z;` `            ``// Push the newly generated``            ``// number to the queue``            ``q.push(temp);``        ``}``    ``}``}` `// Function to compare two strings``// which represent a numerical value``bool` `comp(string a, string b)``{``    ``if` `(a.size() == b.size())``        ``return` `a < b;``    ``else``        ``return` `a.size() < b.size();``}` `// Function to return the count of``// valid numbers in the range [l, r]``int` `findcount(string l, string r)``{` `    ``// Generate all the valid numbers``    ``// in the range [1, MAX]``    ``generate();` `    ``// To store the count of numbers``    ``// in the range [l, r]``    ``int` `count = 0;` `    ``// For every valid number in``    ``// the range [1, MAX]``    ``for` `(``int` `i = 0; i < ans.size(); i++) {` `        ``string a = ans[i];` `        ``// If current number is within``        ``// the required range``        ``if` `(comp(l, a) && comp(a, r)) {``            ``count++;``        ``}` `        ``// If number is equal to either l or r``        ``else` `if` `(a == l || a == r) {``            ``count++;``        ``}``    ``}` `    ``return` `count;``}` `// Driver code``int` `main()``{` `    ``string l = ``"1"``, r = ``"1000"``;` `    ``cout << findcount(l, r);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{` `// Maximum possible valid number``static` `int` `MAX = ``543210``;` `// To store all the required number``// from the range [1, MAX]``static` `Vector ans = ``new` `Vector();` `// Function that returns true if x``// satisfies the given conditions``static` `boolean` `isValidNum(String x)``{` `    ``// To store the digits of x``    ``HashMap mp = ``new` `HashMap();` `    ``for` `(``int` `i = ``0``; i < x.length(); i++)``    ``{` `        ``// If current digit appears more than once``        ``if` `(mp.containsKey(x.charAt(i) - ``'0'``))``        ``{``            ``return` `false``;``        ``}` `        ``// If current digit is greater than 5``        ``else` `if` `(x.charAt(i) - ``'0'` `> ``5``)``        ``{``            ``return` `false``;``        ``}` `        ``// Put the digit in the map``        ``else``        ``{``            ``mp.put(x.charAt(i) - ``'0'``, ``1``);``        ``}``    ``}``    ``return` `true``;``}` `// Function to generate all the required``// numbers in the range [1, MAX]``static` `void` `generate()``{` `    ``// Insert first 5 valid numbers``    ``Queue q = ``new` `LinkedList();``    ``q.add(``"1"``);``    ``q.add(``"2"``);``    ``q.add(``"3"``);``    ``q.add(``"4"``);``    ``q.add(``"5"``);` `    ``boolean` `flag = ``true``;` `    ``// Inserting 0 externally because 0 cannot``    ``// be the leading digit in any number``    ``ans.add(``"0"``);` `    ``while` `(!q.isEmpty())``    ``{``        ``String x = q.peek();``        ``q.remove();` `        ``// If x satisfies the given conditions``        ``if` `(isValidNum(x))``        ``{``            ``ans.add(x);``        ``}` `        ``// Cannot append anymore digit as``        ``// adding a digit will repeat one of``        ``// the already present digits``        ``if` `(x.length() == ``6``)``            ``continue``;` `        ``// Append all the valid digits one by``        ``// one and push the new generated``        ``// number to the queue``        ``for` `(``int` `i = ``0``; i <= ``5``; i++)``        ``{``            ``String z = String.valueOf(i);` `            ``// Append the digit``            ``String temp = x + z;` `            ``// Push the newly generated``            ``// number to the queue``            ``q.add(temp);``        ``}``    ``}``}` `// Function to compare two Strings``// which represent a numerical value``static` `boolean` `comp(String a, String b)``{``    ``if` `(a.length()== b.length())``    ``{``        ``int` `i = a.compareTo(b);``    ` `        ``return` `i < ``0` `? ``true` `: ``false``;``    ``}``    ``else``        ``return` `a.length() < b.length();``}` `// Function to return the count of``// valid numbers in the range [l, r]``static` `int` `findcount(String l, String r)``{` `    ``// Generate all the valid numbers``    ``// in the range [1, MAX]``    ``generate();` `    ``// To store the count of numbers``    ``// in the range [l, r]``    ``int` `count = ``0``;` `    ``// For every valid number in``    ``// the range [1, MAX]``    ``for` `(``int` `i = ``0``; i < ans.size(); i++)``    ``{` `        ``String a = ans.get(i);` `        ``// If current number is within``        ``// the required range``        ``if` `(comp(l, a) && comp(a, r))``        ``{``            ``count++;``        ``}` `        ``// If number is equal to either l or r``        ``else` `if` `(a == l || a == r)``        ``{``            ``count++;``        ``}``    ``}``    ``return` `count;``}` `// Driver code``public` `static` `void` `main (String[] args)``{``    ``String l = ``"1"``, r = ``"1000"``;` `    ``System.out.println(findcount(l, r));``}``}` `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python3 implementation of the approach``from` `collections ``import` `deque` `# Maximum possible valid number``MAX` `=` `543210` `# To store all the required number``# from the range [1, MAX]``ans ``=` `[]` `# Function that returns true if x``# satisfies the given conditions``def` `isValidNum(x):` `    ``# To store the digits of x``    ``mp ``=` `dict``()` `    ``for` `i ``in` `range``(``len``(x)):` `        ``# If current digit appears more than once``        ``if` `(``ord``(x[i]) ``-` `ord``(``'0'``) ``in` `mp.keys()):``            ``return` `False` `        ``# If current digit is greater than 5``        ``elif` `(``ord``(x[i]) ``-` `ord``(``'0'``) > ``5``):``            ``return` `False` `        ``# Put the digit in the map``        ``else``:``            ``mp[``ord``(x[i]) ``-` `ord``(``'0'``)] ``=` `1` `    ``return` `True` `# Function to generate all the required``# numbers in the range [1, MAX]``def` `generate():` `    ``# Insert first 5 valid numbers``    ``q ``=` `deque()``    ``q.append(``"1"``)``    ``q.append(``"2"``)``    ``q.append(``"3"``)``    ``q.append(``"4"``)``    ``q.append(``"5"``)` `    ``flag ``=` `True` `    ``# Inserting 0 externally because 0 cannot``    ``# be the leading digit in any number``    ``ans.append(``"0"``)` `    ``while` `(``len``(q) > ``0``):``        ``x ``=` `q.popleft()` `        ``# If x satisfies the given conditions``        ``if` `(isValidNum(x)):``            ``ans.append(x)` `        ``# Cannot append anymore digit as``        ``# adding a digit will repeat one of``        ``# the already present digits``        ``if` `(``len``(x) ``=``=` `6``):``            ``continue` `        ``# Append all the valid digits one by``        ``# one and append the new generated``        ``# number to the queue``        ``for` `i ``in` `range``(``6``):``            ``z ``=` `str``(i)` `            ``# Append the digit``            ``temp ``=` `x ``+` `z` `            ``# Push the newly generated``            ``# number to the queue``            ``q.append(temp)` `# Function to compare two strings``# which represent a numerical value``def` `comp(a, b):``    ``if` `(``len``(a) ``=``=` `len``(b)):``        ``if` `a < b:``            ``return` `True``    ``else``:``        ``return` `len``(a) < ``len``(b)` `# Function to return the count of``# valid numbers in the range [l, r]``def` `findcount(l, r):` `    ``# Generate all the valid numbers``    ``# in the range [1, MAX]``    ``generate()` `    ``# To store the count of numbers``    ``# in the range [l, r]``    ``count ``=` `0` `    ``# For every valid number in``    ``# the range [1, MAX]``    ``for` `i ``in` `range``(``len``(ans)):` `        ``a ``=` `ans[i]` `        ``# If current number is within``        ``# the required range``        ``if` `(comp(l, a) ``and` `comp(a, r)):``            ``count ``+``=` `1` `        ``# If number is equal to either l or r``        ``elif` `(a ``=``=` `l ``or` `a ``=``=` `r):``            ``count ``+``=` `1` `    ``return` `count` `# Driver code``l ``=` `"1"``r ``=` `"1000"` `print``(findcount(l, r))` `# This code is contributed by Mohit Kumar`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;    ``    ` `class` `GFG``{` `// Maximum possible valid number``static` `int` `MAX = 543210;` `// To store all the required number``// from the range [1, MAX]``static` `List ans = ``new` `List();` `// Function that returns true if x``// satisfies the given conditions``static` `bool` `isValidNum(String x)``{` `    ``// To store the digits of x``    ``Dictionary<``int``, ``int``> mp = ``new` `Dictionary<``int``, ``int``>();` `    ``for` `(``int` `i = 0; i < x.Length; i++)``    ``{` `        ``// If current digit appears more than once``        ``if` `(mp.ContainsKey(x[i] - ``'0'``))``        ``{``            ``return` `false``;``        ``}` `        ``// If current digit is greater than 5``        ``else` `if` `(x[i] - ``'0'` `> 5)``        ``{``            ``return` `false``;``        ``}` `        ``// Put the digit in the map``        ``else``        ``{``            ``mp.Add(x[i] - ``'0'``, 1);``        ``}``    ``}``    ``return` `true``;``}` `// Function to generate all the required``// numbers in the range [1, MAX]``static` `void` `generate()``{` `    ``// Insert first 5 valid numbers``    ``Queue q = ``new` `Queue();``    ``q.Enqueue(``"1"``);``    ``q.Enqueue(``"2"``);``    ``q.Enqueue(``"3"``);``    ``q.Enqueue(``"4"``);``    ``q.Enqueue(``"5"``);` `    ``bool` `flag = ``true``;` `    ``// Inserting 0 externally because 0 cannot``    ``// be the leading digit in any number``    ``ans.Add(``"0"``);` `    ``while` `(q.Count!=0)``    ``{``        ``String x = q.Peek();``        ``q.Dequeue();` `        ``// If x satisfies the given conditions``        ``if` `(isValidNum(x))``        ``{``            ``ans.Add(x);``        ``}` `        ``// Cannot append anymore digit as``        ``// adding a digit will repeat one of``        ``// the already present digits``        ``if` `(x.Length == 6)``            ``continue``;` `        ``// Append all the valid digits one by``        ``// one and push the new generated``        ``// number to the queue``        ``for` `(``int` `i = 0; i <= 5; i++)``        ``{``            ``String z = i.ToString();` `            ``// Append the digit``            ``String temp = x + z;` `            ``// Push the newly generated``            ``// number to the queue``            ``q.Enqueue(temp);``        ``}``    ``}``}` `// Function to compare two Strings``// which represent a numerical value``static` `bool` `comp(String a, String b)``{``    ``if` `(a.Length == b.Length)``    ``{``        ``int` `i = a.CompareTo(b);``    ` `        ``return` `i < 0 ? ``true` `: ``false``;``    ``}``    ``else``        ``return` `a.Length < b.Length;``}` `// Function to return the count of``// valid numbers in the range [l, r]``static` `int` `findcount(String l, String r)``{` `    ``// Generate all the valid numbers``    ``// in the range [1, MAX]``    ``generate();` `    ``// To store the count of numbers``    ``// in the range [l, r]``    ``int` `count = 0;` `    ``// For every valid number in``    ``// the range [1, MAX]``    ``for` `(``int` `i = 0; i < ans.Count; i++)``    ``{` `        ``String a = ans[i];` `        ``// If current number is within``        ``// the required range``        ``if` `(comp(l, a) && comp(a, r))``        ``{``            ``count++;``        ``}` `        ``// If number is equal to either l or r``        ``else` `if` `(a == l || a == r)``        ``{``            ``count++;``        ``}``    ``}``    ``return` `count;``}` `// Driver code``public` `static` `void` `Main (String[] args)``{``    ``String l = ``"1"``, r = ``"1000"``;` `    ``Console.WriteLine(findcount(l, r));``}``}` `// This code is contributed by Princi Singh`

## Javascript

 ``

Output

`130`

Another Approach :

The next valid number in the series can be generated from the previously generated numbers and binary search is used instead of linear search to reduce the time complexity.

## C++

 `#include``using` `namespace` `std;` `// Function to check if all digits of a number are unique``bool` `possible(string x)``{` `  ``// creating unordered_map to check if duplicate digit exists``  ``unordered_map<``char``, ``int``> mp;``  ``for``(``char` `i : x) {``    ``if``(mp.find(i) == mp.end()) {``      ``mp[i] = 1;``    ``} ``else` `{``      ``return` `false``;``    ``}``  ``}``  ``return` `true``;``}` `// Function to create a list containing all``// possible no. with unique digits (digits <= 5)``void` `total(vector &a)``{` `  ``// initializing i for the first index of list 'a'``  ``int` `i = 1;` `  ``// traversing till i is less than length of list 'a'``  ``while``(i < a.size())``  ``{` `    ``// considering ith index value of list 'a'``    ``string x = a[i];``    ``i++;` `    ``// Cannot append anymore digit as``    ``// adding a digit will repeat one``    ``// of the already present digits``    ``if``(x.size() == 5) {``      ``continue``;``    ``}` `    ``// Append all the valid digits one``    ``// by one and append the new generated``    ``for``(``int` `j = 0; j <= 5; j++)``    ``{` `      ``// Append the digit``      ``string z = to_string(j);` `      ``// If combination satisfies the given conditions``      ``if``(possible(x + z))``      ``{` `        ``// Push the newly generated``        ``a.push_back(x+z);``      ``}``    ``}``  ``}``}` `// Function to print the count within range using binary search``void` `PrintSolution(vector &a, ``int` `l, ``int` `r) {``  ``int` `ans1 = 0, ans2 = 0;``  ``int` `low = 0, high = a.size()-1;` `  ``// finding the index for l``  ``while``(low <= high) {``    ``int` `mid = (low+high)/2;``    ``if``(stoi(a[mid]) == l) {``      ``ans1 = mid;``      ``break``;``    ``} ``else` `if``(stoi(a[mid]) > l) {``      ``ans1 = mid;``      ``high = mid - 1;``    ``} ``else` `{``      ``low = mid + 1;``    ``}``  ``}``  ``low = 0;``  ``high = a.size()-1;` `  ``// finding index for r``  ``while``(low <= high) {``    ``int` `mid = (low+high)/2;``    ``if``(stoi(a[mid]) == r) {``      ``ans2 = mid;``      ``break``;``    ``} ``else` `if``(stoi(a[mid]) < r) {``      ``ans2 = mid;``      ``low = mid + 1;``    ``} ``else` `{``      ``high = mid - 1;``    ``}``  ``}``  ``cout << ans2-ans1+1 << endl;``}` `// Driver Code``int` `main() {``  ``vector a = {``"0"``, ``"1"``, ``"2"``, ``"3"``, ``"4"``, ``"5"``};` `  ``// calling function to calculate all possible combination available``  ``total(a);``  ``int` `l = 1, r = 1000;``  ``PrintSolution(a, l, r);``  ``return` `0;``}`

## Java

 `import` `java.util.*;` `public` `class` `UniqueDigits``{` `  ``// function to check if a number has unique digits``  ``public` `static` `boolean` `possible(String x)``  ``{``    ` `    ``// creating a HashMap to check if duplicate digit exists``    ``HashMap d = ``new` `HashMap<>();` `    ``for` `(``int` `i = ``0``; i < x.length(); i++) {``      ``char` `c = x.charAt(i);``      ``if` `(!d.containsKey(c)) {``        ``d.put(c, ``1``);``      ``} ``else` `{``        ``return` `false``;``      ``}``    ``}``    ``return` `true``;``  ``}` `  ``// function to create a list containing all possible numbers``  ``// with unique digits. digits <= 5.``  ``public` `static` `void` `total(ArrayList a) {``    ``// initializing i for the first index of list 'a'``    ``int` `i = ``1``;` `    ``// traversing till i is less than length of list 'a'``    ``while` `(i < a.size())``    ``{``      ` `      ``// considering ith index value of list 'a'``      ``String x = a.get(i);` `      ``i++;` `      ``// Cannot append anymore digit as``      ``// adding a digit will repeat one of``      ``// the already present digits``      ``if` `(x.length() == ``5``) {``        ``continue``;``      ``}` `      ``// Append all the valid digits one by``      ``// one and append the new generated``      ``for` `(``int` `j = ``0``; j <= ``5``; j++)``      ``{``        ` `        ``// Append the digit``        ``String z = Integer.toString(j);``        ` `        ``// If combination satisfies the given conditions``        ``if` `(possible(x + z))``        ``{``          ` `          ``// Push the newly generated``          ``a.add(x + z);``        ``}``      ``}``    ``}``  ``}` `  ``// function to print the count within range using binary search``  ``public` `static` `void` `printSolution(ArrayList a, ``int` `l, ``int` `r) {``    ``int` `ans1 = ``0``, ans2 = ``0``;``    ``int` `low = ``0``, high = a.size() - ``1``;` `    ``// finding the index for l``    ``while` `(low <= high) {``      ``int` `mid = (low + high) / ``2``;` `      ``if` `(Integer.parseInt(a.get(mid)) == l) {``        ``ans1 = mid;``        ``break``;``      ``}` `      ``if` `(Integer.parseInt(a.get(mid)) > l) {``        ``ans1 = mid;``        ``high = mid - ``1``;``      ``} ``else` `{``        ``low = mid + ``1``;``      ``}``    ``}` `    ``low = ``0``;``    ``high = a.size() - ``1``;` `    ``// finding the index for r``    ``while` `(low <= high) {``      ``int` `mid = (low + high) / ``2``;` `      ``if` `(Integer.parseInt(a.get(mid)) == r) {``        ``ans2 = mid;``        ``break``;``      ``}` `      ``if` `(Integer.parseInt(a.get(mid)) < r) {``        ``ans2 = mid;``        ``low = mid + ``1``;``      ``} ``else` `{``        ``high = mid - ``1``;``      ``}``    ``}` `    ``System.out.println(ans2 - ans1 + ``1``);``  ``}` `  ``// main driver code``  ``public` `static` `void` `main(String[] args) {``    ``ArrayList a = ``new` `ArrayList(Arrays.asList(``"0"``, ``"1"``, ``"2"``, ``"3"``, ``"4"``, ``"5"``));` `    ``// calling function to calculate``    ``// all possible combination available``    ``total(a);` `    ``int` `l = ``1``, r = ``1000``;` `    ``printSolution(a, l, r);``  ``}``}`

## Python3

 `# Python3 implementation of the approach``# for checking if number has all unique digits`  `def` `possible(x):``    ``# creating dictionary to check if duplicate digit exists``    ``d ``=` `{}` `    ``for` `i ``in` `x:` `        ``if` `i ``not` `in` `d:` `            ``d[i] ``=` `1` `        ``else``:` `            ``return` `0` `    ``return` `1` `# to create a list containing all possible no.``# with unique digits``#digits <= 5`  `def` `total(a):``    ``# initializing i for the first index of list 'a'``    ``i ``=` `1` `    ``# traversing till i is less than length of list 'a'``    ``while` `i < ``len``(a):` `        ``# considering ith index value of list 'a'``        ``x ``=` `a[i]` `        ``i ``+``=` `1` `        ``# Cannot append anymore digit as``        ``# adding a digit will repeat one of``        ``# the already present digits``        ``if` `len``(x) ``=``=` `6``:` `            ``continue``        ``# Append all the valid digits one by``        ``# one and append the new generated``        ``for` `j ``in` `range``(``6``):``            ``# Append the digit``            ``z ``=` `str``(j)``            ``# If combination satisfies the given conditions``            ``if` `possible(x``+``z):``                ``# Push the newly generated``                ``a.append(x``+``z)` `# function to print the count within range``# using binary search`  `def` `PrintSolution(a, l, r):``    ``ans1 ``=` `ans2 ``=` `0` `    ``low ``=` `0` `    ``high ``=` `len``(a)``-``1` `    ``# finding the index for l``    ``while` `low <``=` `high:``        ``mid ``=` `(low``+``high)``/``/``2` `        ``if` `int``(a[mid]) ``=``=` `l:` `            ``ans1 ``=` `mid` `            ``break` `        ``if` `int``(a[mid]) > l:``            ``ans1 ``=` `mid``            ``high ``=` `mid ``-` `1` `        ``else``:` `            ``low ``=` `mid ``+` `1` `    ``low ``=` `0` `    ``high ``=` `len``(a) ``-` `1``    ``# finding index for r``    ``while` `low <``=` `high:` `        ``mid ``=` `(low``+``high)``/``/``2` `        ``if` `int``(a[mid]) ``=``=` `r:` `            ``ans2 ``=` `mid` `            ``break` `        ``if` `int``(a[mid]) < r:` `            ``ans2 ``=` `mid` `            ``low ``=` `mid ``+` `1` `        ``else``:` `            ``high ``=` `mid ``-` `1` `    ``print``(ans2``-``ans1``+``1``)`  `# Driver Code``a ``=` `[``'0'``, ``'1'``, ``'2'``, ``'3'``, ``'4'``, ``'5'``]` `# calling function to calculate``# all possible combination available``total(a)` `l ``=` `1``r ``=` `1000` `PrintSolution(a, l, r)` `# This code is contributed by Anvesh Govind Saxena`

## C#

 `using` `System;``using` `System.Collections.Generic;` `public` `class` `UniqueDigits``{``  ``// function to check if a number has unique digits``  ``public` `static` `bool` `Possible(``string` `x)``  ``{``    ``// creating a Dictionary to check if duplicate digit exists``    ``Dictionary<``char``, ``int``> d = ``new` `Dictionary<``char``, ``int``>();` `    ``for` `(``int` `i = 0; i < x.Length; i++)``    ``{``      ``char` `c = x[i];``      ``if` `(!d.ContainsKey(c))``      ``{``        ``d.Add(c, 1);``      ``}``      ``else``      ``{``        ``return` `false``;``      ``}``    ``}``    ``return` `true``;``  ``}` `  ``// function to create a list containing all possible numbers``  ``// with unique digits. digits <= 5.``  ``public` `static` `void` `Total(List<``string``> a)``  ``{``    ``// initializing i for the first index of list 'a'``    ``int` `i = 1;` `    ``// traversing till i is less than length of list 'a'``    ``while` `(i < a.Count)``    ``{``      ``// considering ith index value of list 'a'``      ``string` `x = a[i];``      ``i++;` `      ``// Cannot append anymore digit as``      ``// adding a digit will repeat one of``      ``// the already present digits``      ``if` `(x.Length == 5)``      ``{``        ``continue``;``      ``}` `      ``// Append all the valid digits one by``      ``// one and append the new generated``      ``for` `(``int` `j = 0; j <= 5; j++)``      ``{``        ``// Append the digit``        ``string` `z = j.ToString();` `        ``// If combination satisfies the given conditions``        ``if` `(Possible(x + z))``        ``{``          ``// Push the newly generated``          ``a.Add(x + z);``        ``}``      ``}``    ``}``  ``}` `  ``// function to print the count within range using binary search``  ``public` `static` `void` `PrintSolution(List<``string``> a, ``int` `l, ``int` `r)``  ``{``    ``int` `ans1 = 0, ans2 = 0;``    ``int` `low = 0, high = a.Count - 1;` `    ``// finding the index for l``    ``while` `(low <= high)``    ``{``      ``int` `mid = (low + high) / 2;` `      ``if` `(``int``.Parse(a[mid]) == l)``      ``{``        ``ans1 = mid;``        ``break``;``      ``}` `      ``if` `(``int``.Parse(a[mid]) > l)``      ``{``        ``ans1 = mid;``        ``high = mid - 1;``      ``}``      ``else``      ``{``        ``low = mid + 1;``      ``}``    ``}` `    ``low = 0;``    ``high = a.Count - 1;` `    ``// finding the index for r``    ``while` `(low <= high)``    ``{``      ``int` `mid = (low + high) / 2;` `      ``if` `(``int``.Parse(a[mid]) == r)``      ``{``        ``ans2 = mid;``        ``break``;``      ``}` `      ``if` `(``int``.Parse(a[mid]) < r)``      ``{``        ``ans2 = mid;``        ``low = mid + 1;``      ``}``      ``else``      ``{``        ``high = mid - 1;``      ``}``    ``}` `    ``Console.WriteLine(ans2 - ans1 + 1);``  ``}` `  ``// main driver code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``List<``string``> a = ``new` `List<``string``>(``new` `string``[] { ``"0"``, ``"1"``, ``"2"``, ``"3"``, ``"4"``, ``"5"` `});` `    ``// calling function to calculate``    ``// all possible combination available``    ``Total(a);` `    ``int` `l = 1, r = 1000;` `    ``PrintSolution(a, l, r);``  ``}``}`

## Javascript

 `// JavaScript implementation of the approach``// for checking if number has all unique digits` `// creating function to check if duplicate digit exists``function` `possible(x) {` `    ``// creating dictionary to check if duplicate digit exists``    ``var` `d = {};` `    ``for` `(``var` `i = 0; i < x.length; i++) {` `        ``if` `(!(x[i] ``in` `d)) {` `            ``d[x[i]] = 1;` `        ``} ``else` `{` `            ``return` `0;` `        ``}``    ``}``    ``return` `1;``}` `// to create a list containing all possible no.``// with unique digits``// digits <= 5``function` `total(a) {` `    ``// initializing i for the first index of list 'a'``    ``var` `i = 1;` `    ``// traversing till i is less than length of list 'a'``    ``while` `(i < a.length) {` `        ``// considering ith index value of list 'a'``        ``var` `x = a[i];` `        ``i += 1;` `        ``// Cannot append anymore digit as``        ``// adding a digit will repeat one of``        ``// the already present digits``        ``if` `(x.length == 6) {` `            ``continue``;``        ``}``        ``// Append all the valid digits one by``        ``// one and append the new generated``        ``for` `(``var` `j = 0; j < 6; j++) {``            ``// Append the digit``            ``var` `z = j.toString();``            ``// If combination satisfies the given conditions``            ``if` `(possible(x + z)) {``                ``// Push the newly generated``                ``a.push(x + z);``            ``}``        ``}``    ``}``}` `// function to print the count within range``// using binary search``function` `PrintSolution(a, l, r) {` `    ``var` `ans1 = 0;``    ``var` `ans2 = 0;` `    ``var` `low = 0;` `    ``var` `high = a.length - 1;` `    ``// finding the index for l``    ``while` `(low <= high) {``        ``var` `mid = Math.floor((low + high) / 2);` `        ``if` `(parseInt(a[mid]) === l) {` `            ``ans1 = mid;` `            ``break``;` `        ``}` `        ``if` `(parseInt(a[mid]) > l) {` `            ``ans1 = mid;``            ``high = mid - 1;` `        ``} ``else` `{` `            ``low = mid + 1;``        ``}``    ``}` `    ``low = 0;` `    ``high = a.length - 1;``    ``// finding index for r``    ``while` `(low <= high) {` `        ``var` `mid = Math.floor((low + high) / 2);` `        ``if` `(parseInt(a[mid]) === r) {` `            ``ans2 = mid;` `            ``break``;` `        ``}` `        ``if` `(parseInt(a[mid]) < r) {` `            ``ans2 = mid;``            ``low = mid + 1;` `        ``} ``else` `{` `            ``high = mid - 1;``        ``}``    ``}` `    ``console.log(ans2 - ans1 + 1);` `}` `// Driver Code``var` `a = [``'0'``, ``'1'``, ``'2'``, ``'3'``, ``'4'``, ``'5'``];` `// calling function to calculate``// all possible combination available``total(a);` `var` `l = 1;``var` `r = 1000;` `PrintSolution(a, l, r);` `// This code is contributed by phasing17`

Output

`130`

My Personal Notes arrow_drop_up