GFG App
Open App
Browser
Continue

# n-th number with digits in {0, 1, 2, 3, 4, 5}

Given a number n and we have to find the n-th number such that its digits only consist of 0, 1, 2, 3, 4, or 5.

Examples :

Input: n = 6
Output: 5

Input:  n = 10
Output: 13

Recommended Practice

We first store 0, 1, 2, 3, 4, 5 in an array. We can see that next numbers will be 10, 11, 12,,13, 14, 15 and after that numbers will be 20, 21, 23, 24, 25 and so on. We can see the pattern that is repeating again and again. We save the calculated result and use it for further calculations.
next 6 numbers are-
1*10+0 = 10
1*10+1 = 11
1*10+2 = 12
1*10+3 = 13
1*10+4 = 14
1*10+5 = 15
and after that next 6 numbers will be-
2*10+0 = 20
2*10+1 = 21
2*10+2 = 22
2*10+3 = 23
2*10+4 = 24
2*10+5 = 25
We use this pattern to find the n-th number. Below is the complete algorithm.

```1) push 0 to 5 in ans vector
2) for i=0 to n/6
for j=0 to 6
// this will be the case when first
// digit will be zero
if (ans[i]*10! = 0)
ans.push_back(ans[i]*10 + ans[j])
3) print ans[n-1]```

## C++

 `// C++ program to find n-th number with digits` `// in {0, 1, 2, 3, 4, 5}` `#include ` `using` `namespace` `std;`   `// Returns the N-th number with given digits` `int` `findNth(``int` `n)` `{` `    ``// vector to store results` `    ``vector<``int``> ans;`   `    ``// push first 6 numbers in the answer` `    ``for` `(``int` `i = 0; i < 6; i++)` `        ``ans.push_back(i);`   `    ``// calculate further results` `    ``for` `(``int` `i = 0; i <= n / 6; i++)` `        ``for` `(``int` `j = 0; j < 6; j++)` `            ``if` `((ans[i] * 10) != 0)` `                ``ans.push_back(ans[i] ` `                              ``* 10 + ans[j]);`   `    ``return` `ans[n - 1];` `}`   `// Driver code` `int` `main()` `{` `    ``int` `n = 10;` `    ``cout << findNth(n);` `    ``return` `0;` `}`

## Java

 `// Java program to find n-th number with digits` `// in {0, 1, 2, 3, 4, 5}` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG ` `{`   `  ``// Returns the N-th number with given digits` `  ``public` `static` `int` `findNth(``int` `n)` `  ``{` `    ``// vector to store results` `    ``ArrayList ans = ``new` `ArrayList();`   `    ``// push first 6 numbers in the answer` `    ``for` `(``int` `i = ``0``; i < ``6``; i++)` `      ``ans.add(i);`   `    ``// calculate further results` `    ``for` `(``int` `i = ``0``; i <= n / ``6``; i++)` `      ``for` `(``int` `j = ``0``; j < ``6``; j++)` `        ``if` `((ans.get(i) * ``10``) != ``0``)` `          ``ans.add(ans.get(i) * ``10` `+ ans.get(j));` `    ``return` `ans.get(n - ``1``);` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `n = ``10``;` `    ``int` `ans = findNth(n);` `    ``System.out.println(ans);` `  ``}` `}`   `// This code is contributed by RohitOberoi.`

## Python3

 `# Python3 program to find n-th number with digits` `# in {0, 1, 2, 3, 4, 5}`   `# Returns the N-th number with given digits` `def` `findNth(n):`   `    ``# vector to store results` `    ``ans ``=` `[]`   `    ``# push first 6 numbers in the answer` `    ``for` `i ``in` `range``(``6``):` `        ``ans.append(i)`   `    ``# calculate further results` `    ``for` `i ``in` `range``(n ``/``/` `6` `+` `1``):` `        ``for` `j ``in` `range``(``6``):` `            ``if` `((ans[i] ``*` `10``) !``=` `0``):` `                ``ans.append(ans[i]` `                           ``*` `10` `+` `ans[j])`   `    ``return` `ans[n ``-` `1``]`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``n ``=` `10` `    ``print``(findNth(n))`   `    ``# This code is contributed by ukasp.`

## C#

 `// C# program to find n-th number with digits` `// in {0, 1, 2, 3, 4, 5}` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `// Returns the N-th number with given digits` `public` `static` `int` `findNth(``int` `n)` `{` `    `  `    ``// Vector to store results` `    ``List<``int``> ans = ``new` `List<``int``>();`   `    ``// Push first 6 numbers in the answer` `    ``for``(``int` `i = 0; i < 6; i++)` `        ``ans.Add(i);`   `    ``// Calculate further results` `    ``for``(``int` `i = 0; i <= n / 6; i++)` `        ``for``(``int` `j = 0; j < 6; j++)` `            ``if` `((ans[i] * 10) != 0)` `                ``ans.Add(ans[i] * 10 + ans[j]);` `                `  `    ``return` `ans[n - 1];` `}`   `// Driver code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `n = 10;` `    ``int` `ans = findNth(n);` `    `  `    ``Console.WriteLine(ans);` `}` `}`   `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

`13`

Time complexity: O(N) where N is given number
Auxiliary space: O(N)

Another Approach:

• Initialize a variable num = 0
• Run a while loop till N != 0.
• Check if num is special
• Decrement N by 1
• Break if N becomes 0
• Increment num by 1
• Return num as the final answer

Below is the implementation of the above approach:

## C++

 `#include ` `using` `namespace` `std;`   `bool` `isSpecial(``int` `num)` `{` `    ``while` `(num != 0) {` `        ``int` `rem = num % 10;` `        ``if` `(rem == 6 || rem == 7 || rem == 8 || rem == 9) {` `            ``return` `false``;` `        ``}` `        ``num = num / 10;` `    ``}` `    ``return` `true``;` `}`   `int` `getSpecialNumber(``int` `N)` `{` `    ``int` `num = 0;` `    ``while` `(N != 0) {` `        ``if` `(isSpecial(num)) {` `            ``N--;` `        ``}` `        ``if` `(N == 0) {` `            ``break``;` `        ``}` `        ``num++;` `    ``}` `    ``return` `num;` `}`   `int` `main()` `{` `    ``int` `n = 10;` `    ``cout << getSpecialNumber(n);` `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `public` `class` `Main {` `  ``public` `static` `boolean` `isSpecial(``int` `num) {` `    ``while` `(num != ``0``) {` `      ``int` `rem = num % ``10``;` `      ``if` `(rem == ``6` `|| rem == ``7` `|| rem == ``8` `|| rem == ``9``) {` `        ``return` `false``;` `      ``}` `      ``num = num / ``10``;` `    ``}` `    ``return` `true``;` `  ``}`   `  ``public` `static` `int` `getSpecialNumber(``int` `N) {` `    ``int` `num = ``0``;` `    ``while` `(N != ``0``) {` `      ``if` `(isSpecial(num)) {` `        ``N--;` `      ``}` `      ``if` `(N == ``0``) {` `        ``break``;` `      ``}` `      ``num++;` `    ``}` `    ``return` `num;` `  ``}`   `  ``public` `static` `void` `main(String[] args) {` `    ``int` `n = ``10``;` `    ``System.out.println(getSpecialNumber(n));` `  ``}` `}`   `// This code is contributed by lokeshpotta20.`

## Python3

 `# Python code for the above approach` `def` `isSpecial(num):` `    ``while` `num !``=` `0``:` `        ``rem ``=` `num ``%` `10` `        ``if` `rem ``=``=` `6` `or` `rem ``=``=` `7` `or` `rem ``=``=` `8` `or` `rem ``=``=` `9``:` `            ``return` `False` `        ``num ``=` `num ``/``/` `10` `    ``return` `True`   `def` `getSpecialNumber(N):` `    ``num ``=` `0` `    ``while` `N !``=` `0``:` `        ``if` `isSpecial(num):` `            ``N ``-``=` `1` `        ``if` `N ``=``=` `0``:` `            ``break` `        ``num ``+``=` `1` `    ``return` `num` `  `  `# Driver code` `n ``=` `10` `print``(getSpecialNumber(n))`   `# This code is contributed by lokeshpotta20.`

## C#

 `//C# code for the above approach` `using` `System;`   `class` `GFG{` `    ``static` `bool` `IsSpecial(``int` `num)` `    ``{` `        ``while` `(num != 0) {` `            ``int` `rem = num % 10;` `            ``if` `(rem == 6 || rem == 7 || rem == 8` `                ``|| rem == 9) {` `                ``return` `false``;` `            ``}` `            ``num = num / 10;` `        ``}` `        ``return` `true``;` `    ``}`   `    ``static` `int` `GetSpecialNumber(``int` `N)` `    ``{` `        ``int` `num = 0;` `        ``while` `(N != 0) {` `            ``if` `(IsSpecial(num)) {` `                ``N--;` `            ``}` `            ``if` `(N == 0) {` `                ``break``;` `            ``}` `            ``num++;` `        ``}` `        ``return` `num;` `    ``}`   `    ``static` `void` `Main(``string``[] args)` `    ``{` `        ``int` `n = 10;` `        ``Console.WriteLine(GetSpecialNumber(n));` `    ``}` `}`

## Javascript

 `function` `isSpecial(num)` `{` `    ``while` `(num != 0) {` `        ``let rem = num % 10;` `        ``if` `(rem == 6 || rem == 7 || rem == 8 || rem == 9) {` `            ``return` `false``;` `        ``}` `        ``num = num / 10;` `    ``}` `    ``return` `true``;` `}`   `function` `getSpecialNumber(N)` `{` `    ``let num = 0;` `    ``while` `(N != 0) {` `        ``if` `(isSpecial(num)) {` `            ``N--;` `        ``}` `        ``if` `(N == 0) {` `            ``break``;` `        ``}` `        ``num++;` `    ``}` `    ``return` `num;` `}`   `let n = 10;` `console.log(getSpecialNumber(n));`

Output

`13`

Time Complexity: O(n log n)
Space Complexity: O(1)

Efficient Method :

Algorithm :

1. First, convert number n to base 6.
2. Store the converted value simultaneously in an array.
3. Print that array in reverse order.

Below is the implementation of the above algorithm:

## C++

 `// CPP code to find nth number` `// with digits 0, 1, 2, 3, 4, 5` `#include ` `using` `namespace` `std;`   `#define max 100000`   `// function to convert num to base 6` `int` `baseconversion(``int` `arr[], ``int` `num, ``int` `base)`   `{` `    ``int` `i = 0, rem, j;`   `    ``if` `(num == 0) {` `        ``return` `0;` `    ``}`   `    ``while` `(num > 0) {` `        ``rem = num % base;`   `        ``arr[i++] = rem;`   `        ``num /= base;` `    ``}`   `    ``return` `i;` `}`   `// Driver code` `int` `main()` `{`   `    ``// initialize an array to 0` `    ``int` `arr[max] = { 0 };`   `    ``int` `n = 10;`   `    ``// function calling to convert` `    ``// number n to base 6` `    ``int` `size = baseconversion(arr, n - 1, 6);`   `    ``// if size is zero then return zero` `    ``if` `(size == 0)`   `        ``cout << size;`   `    ``for` `(``int` `i = size - 1; i >= 0; i--) {`   `        ``cout << arr[i];` `    ``}`   `    ``return` `0;` `}`   `// Code is contributed by Anivesh Tiwari.`

## Java

 `// Java code to find nth number` `// with digits 0, 1, 2, 3, 4, 5` `class` `GFG {` `    `  `    ``static` `final` `int` `max = ``100000``;` `    `  `    ``// function to convert num to base 6` `    ``static` `int` `baseconversion(``int` `arr[], ` `                          ``int` `num, ``int` `base)` `    ``{` `        ``int` `i = ``0``, rem, j;` `    `  `        ``if` `(num == ``0``) {` `            ``return` `0``;` `        ``}` `    `  `        ``while` `(num > ``0``) {` `            `  `            ``rem = num % base;` `            ``arr[i++] = rem;` `            ``num /= base;` `        ``}` `    `  `        ``return` `i;` `    ``}` `    `  `    ``// Driver code` `    ``public` `static` `void` `main (String[] args)` `    ``{` `        `  `        ``// initialize an array to 0` `        ``int` `arr[] = ``new` `int``[max];` `    `  `        ``int` `n = ``10``;` `    `  `        ``// function calling to convert` `        ``// number n to base 6` `        ``int` `size = baseconversion(arr, n - ``1``, ``6``);` `    `  `        ``// if size is zero then return zero` `        ``if` `(size == ``0``)` `            ``System.out.print(size);` `    `  `        ``for` `(``int` `i = size - ``1``; i >= ``0``; i--) {` `            ``System.out.print(arr[i]);` `        ``}` `    ``}` `}`   `// This code is contributed by Anant Agarwal.`

## Python3

 `# Python code to find nth number` `# with digits 0, 1, 2, 3, 4, 5` `max` `=` `100000``;`   `# function to convert num to base 6` `def` `baseconversion(arr, num, base):` `    ``i ``=` `0``;`   `    ``if` `(num ``=``=` `0``):` `        ``return` `0``;` `    ``while` `(num > ``0``):`   `        ``rem ``=` `num ``%` `base;` `        ``i ``=` `i ``+` `1``;` `        ``arr[i] ``=` `rem;` `        ``num ``=` `num``/``/``base;` `    ``return` `i;`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``# initialize an array to 0` `    ``arr ``=` `[``0` `for` `i ``in` `range``(``max``)];` `    ``n ``=` `10``;`   `    ``# function calling to convert` `    ``# number n to base 6` `    ``size ``=` `baseconversion(arr, n ``-` `1``, ``6``);`   `    ``# if size is zero then return zero` `    ``if` `(size ``=``=` `0``):` `        ``print``(size);`   `    ``for` `i ``in` `range``(size, ``0``, ``-``1``):` `        ``print``(arr[i], end ``=` `"");`   `# This code is contributed by gauravrajput1 `

## C#

 `// C# code to find nth number` `// with digits 0, 1, 2, 3, 4, 5` `using` `System;`   `class` `GFG {` `    `  `    ``static` `int` `max = 100000;` `    `  `    ``// function to convert num to base 6` `    ``static` `int` `baseconversion(``int` `[]arr, ` `                              ``int` `num, ``int` `bas)` `    ``{` `        ``int` `i = 0, rem;` `    `  `        ``if` `(num == 0) {` `            ``return` `0;` `        ``}` `    `  `        ``while` `(num > 0) {` `            `  `            ``rem = num % bas;` `            ``arr[i++] = rem;` `            ``num /= bas;` `        ``}` `    `  `        ``return` `i;` `    ``}` `    `  `    ``// Driver code` `    ``public` `static` `void` `Main ()` `    ``{` `        ``// initialize an array to 0` `        ``int` `[]arr = ``new` `int``[max];` `    `  `        ``int` `n = 10;` `    `  `        ``// function calling to convert` `        ``// number n to base 6` `        ``int` `size = baseconversion(arr, n - 1, 6);` `    `  `        ``// if size is zero then return zero` `        ``if` `(size == 0)` `            ``Console.Write(size);` `    `  `        ``for` `(``int` `i = size - 1; i >= 0; i--) {` `            ``Console.Write(arr[i]);` `        ``}` `    ``}` `}`   `// This code is contributed by nitin mittal`

## Javascript

 ``

Output:

`13`

Time Complexity:  O(log(n))

Space Complexity: O(log(n))

Another Efficient Method:

Algorithm:

1. Decrease the number N by 1.
2. Convert the number N to base 6.

Below is the implementation of the above algorithm :

## C++

 `// C++ code to find nth number` `// with digits 0, 1, 2, 3, 4, 5`   `#include ` `using` `namespace` `std;`   `int` `ans(``int` `n){` `  ``// If the Number is less than 6 return the number as it is.` `  ``if``(n < 6){` `    ``return` `n;` `  ``}` `  ``//Call the function again and again the get the desired result.` `  ``//And convert the number to base 6.` `  ``return` `n%6 + 10*(ans(n/6));` `}`   `int` `getSpecialNumber(``int` `N)` `{` `  ``//Decrease the Number by 1 and Call ans function` `  ``// to convert N to base 6` `  ``return` `ans(--N);` `}`   `/*Example:-` `Input: N = 17` `Output: 24`   `Explanation:-` `decrease 17 by 1` `N = 16` `call ans() on 16`   `ans():` `    ``16%6 + 10*(ans(16/6))` `        ``since 16/6 = 2 it is less than 6 the ans returns value as it is.` `    ``4 + 10*(2)` `    ``= 24`   `hence answer is 24.*/`   `int` `main() ` `{` `  ``int` `N = 17;` `  ``int` `answer = getSpecialNumber(N);` `  ``cout<

## Java

 `// Java code to find nth number` `// with digits 0, 1, 2, 3, 4, 5` `import` `java.util.*;`   `class` `GFG{`   `static` `int` `ans(``int` `n) ` `{` `    `  `    ``// If the Number is less than 6 return` `    ``// the number as it is.` `    ``if` `(n < ``6``) ` `    ``{` `        ``return` `n;` `    ``}` `    `  `    ``// Call the function again and again ` `    ``// the get the desired result.` `    ``// And convert the number to base 6.` `    ``return` `n % ``6` `+ ``10` `* (ans(n / ``6``));` `}`   `static` `int` `getSpecialNumber(``int` `N)` `{` `    `  `    ``// Decrease the Number by 1 and Call ` `    ``// ans function to convert N to base 6` `    ``return` `ans(--N);` `}`   `/*` ` ``* Example:- Input: N = 17 Output: 24` ` ``* ` ` ``* Explanation:- decrease 17 by 1 N = 16 call ans() on 16` ` ``* ` ` ``* ans(): 16%6 + 10*(ans(16/6)) since 16/6 = 2 it is less` ` ``* than 6 the ans returns value as it is. 4 + 10*(2) = 24` ` ``* ` ` ``* hence answer is 24.` ` ``*/` `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `N = ``17``;` `    ``int` `answer = getSpecialNumber(N);` `    `  `    ``System.out.println(answer);` `}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 code to find nth number` `# with digits 0, 1, 2, 3, 4, 5` `def` `ans(n):`   `    ``# If the Number is less than 6 return` `    ``# the number as it is.` `    ``if` `(n < ``6``):` `        ``return` `n` `    `  `    ``# Call the function again and again` `    ``# the get the desired result.` `    ``# And convert the number to base 6.` `    ``return` `n ``%` `6` `+` `10` `*` `(ans(n ``/``/` `6``)) ``-` `1`   `def` `getSpecialNumber(N):` `    `  `    ``# Decrease the Number by 1 and Call` `    ``# ans function to convert N to base 6` `    ``return` `ans(N)`   `'''` ` ``* Example:- Input: N = 17 Output: 24` ` ``* ` ` ``* Explanation:- decrease 17 by 1 N = 16 call ans() on 16` ` ``* ` ` ``* ans(): 16%6 + 10*(ans(16/6)) since 16/6 = 2 it is less than 6 the ans returns` ` ``* value as it is. 4 + 10*(2) = 24` ` ``* ` ` ``* hence answer is 24.` ` ``'''` `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``N ``=` `17` `    ``answer ``=` `getSpecialNumber(N)`   `    ``print``(answer)`   `# This code contributed by aashish1995`

## C#

 `// C# code to find nth number` `// with digits 0, 1, 2, 3, 4, 5` `using` `System;`   `public` `class` `GFG{`   `static` `int` `ans(``int` `n) ` `{` `    `  `    ``// If the Number is less than 6 return` `    ``// the number as it is.` `    ``if` `(n < 6) ` `    ``{` `        ``return` `n;` `    ``}` `    `  `    ``// Call the function again and again ` `    ``// the get the desired result.` `    ``// And convert the number to base 6.` `    ``return` `n % 6 + 10 * (ans(n / 6));` `}`   `static` `int` `getSpecialNumber(``int` `N)` `{` `    `  `    ``// Decrease the Number by 1 and Call ` `    ``// ans function to convert N to base 6` `    ``return` `ans(--N);` `}`   `/*` ` ``* Example:- Input: N = 17 Output: 24` ` ``* ` ` ``* Explanation:- decrease 17 by 1 N = 16 call ans() on 16` ` ``* ` ` ``* ans(): 16%6 + 10*(ans(16/6)) since 16/6 = 2 it is less` ` ``* than 6 the ans returns value as it is. 4 + 10*(2) = 24` ` ``* ` ` ``* hence answer is 24.` ` ``*/` `// Driver code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `N = 17;` `    ``int` `answer = getSpecialNumber(N);` `    `  `    ``Console.WriteLine(answer);` `}` `}`     `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

`24`

Time Complexity: O(logN)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up