# Count of N-digit numbers in base K with no two consecutive zeroes

Given two integers N and K, the task is to find the count of all the integer in base K which satisfy the following conditions:

1. The integers must be of exactly N digits.
2. There should be no leading 0.
3. There must not be any consecutive digit pair such that both the digits are 0.

Examples:

Input: N = 3, K = 10
Output: 891
All 3-digit numbers in base 10 are from the range [100, 999]
Out of these numbers only 100, 200, 300, 400, …, 900 are invalid.
Hence valid integers are 900 – 9 = 891

Input: N = 2, K = 10
Output: 90

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive approach: Write a function count_numbers(int k, int n, bool flag) which will return the count of N digit numbers possible of base K and flag will tell whether the previously chosen digit was 0 or not. Call this function recursively for count_numbers(int k, int n-1, bool flag) and using the flag, the occurrence of two consecutive 0s can be avoided.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the count of ` `// n-digit numbers that satisfy ` `// the given conditions ` `int` `count_numbers(``int` `k, ``int` `n, ``bool` `flag) ` `{ ` ` `  `    ``// Base case ` `    ``if` `(n == 1) { ` ` `  `        ``// If 0 wasn't chosen previously ` `        ``if` `(flag) { ` `            ``return` `(k - 1); ` `        ``} ` `        ``else` `{ ` `            ``return` `1; ` `        ``} ` `    ``} ` ` `  `    ``// If 0 wasn't chosen previously ` `    ``if` `(flag) ` `        ``return` `(k - 1) * (count_numbers(k, n - 1, 0) ` `                          ``+ count_numbers(k, n - 1, 1)); ` `    ``else` `        ``return` `count_numbers(k, n - 1, 1); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 3; ` `    ``int` `k = 10; ` `    ``cout << count_numbers(k, n, ``true``); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach  ` `class` `GFG  ` `{ ` `     `  `// Function to return the count of  ` `// n-digit numbers that satisfy  ` `// the given conditions  ` `static` `int` `count_numbers(``int` `k, ``int` `n, ` `                         ``boolean` `flag)  ` `{  ` ` `  `    ``// Base case  ` `    ``if` `(n == ``1``)  ` `    ``{  ` ` `  `        ``// If 0 wasn't chosen previously  ` `        ``if` `(flag)  ` `        ``{  ` `            ``return` `(k - ``1``);  ` `        ``}  ` `        ``else`  `        ``{  ` `            ``return` `1``;  ` `        ``}  ` `    ``}  ` ` `  `    ``// If 0 wasn't chosen previously  ` `    ``if` `(flag)  ` `        ``return` `(k - ``1``) * (count_numbers(k, n - ``1``, ``false``) + ` `                          ``count_numbers(k, n - ``1``, ``true``));  ` `    ``else` `        ``return` `count_numbers(k, n - ``1``, ``true``);  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `main (String[] args) ` `{  ` `    ``int` `n = ``3``;  ` `    ``int` `k = ``10``;  ` `    ``System.out.println(count_numbers(k, n, ``true``));  ` `}  ` `} ` ` `  `// This code is contributed by AnkitRai01 `

## Python3

 `# Python3 implementation of the approach  ` ` `  `# Function to return the count of  ` `# n-digit numbers that satisfy  ` `# the given conditions  ` `def` `count_numbers(k, n, flag) :  ` ` `  `    ``# Base case  ` `    ``if` `(n ``=``=` `1``) :  ` ` `  `        ``# If 0 wasn't chosen previously  ` `        ``if` `(flag) :  ` `            ``return` `(k ``-` `1``)  ` `        ``else` `:  ` `            ``return` `1` ` `  `    ``# If 0 wasn't chosen previously  ` `    ``if` `(flag) :  ` `        ``return` `(k ``-` `1``) ``*` `(count_numbers(k, n ``-` `1``, ``0``) ``+` `                          ``count_numbers(k, n ``-` `1``, ``1``))  ` `    ``else` `: ` `        ``return` `count_numbers(k, n ``-` `1``, ``1``)  ` ` `  `# Driver code  ` `n ``=` `3` `k ``=` `10` `print``(count_numbers(k, n, ``True``)) ` ` `  `# This code is contributed by ` `# divyamohan123 `

## C#

 `// C# implementation of the approach ` `using` `System; ` `                     `  `class` `GFG  ` `{ ` `     `  `// Function to return the count of  ` `// n-digit numbers that satisfy  ` `// the given conditions  ` `static` `int` `count_numbers(``int` `k, ``int` `n, ` `                         ``bool` `flag)  ` `{  ` ` `  `    ``// Base case  ` `    ``if` `(n == 1)  ` `    ``{  ` ` `  `        ``// If 0 wasn't chosen previously  ` `        ``if` `(flag)  ` `        ``{  ` `            ``return` `(k - 1);  ` `        ``}  ` `        ``else` `        ``{  ` `            ``return` `1;  ` `        ``}  ` `    ``}  ` ` `  `    ``// If 0 wasn't chosen previously  ` `    ``if` `(flag)  ` `        ``return` `(k - 1) * (count_numbers(k, n - 1, ``false``) + ` `                          ``count_numbers(k, n - 1, ``true``));  ` `    ``else` `        ``return` `count_numbers(k, n - 1, ``true``);  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `Main (String[] args) ` `{  ` `    ``int` `n = 3;  ` `    ``int` `k = 10;  ` `    ``Console.Write(count_numbers(k, n, ``true``));  ` `}  ` `} ` ` `  `// This code is contributed by 29AjayKuma `

Output:

```891
```

Efficient approach: Now that the problem has been solved using recursion, a 2-D DP can be used to solve this problem dp[n + 1][2] where dp[i][0] will give the number of i digit numbers possible ending with 0 and dp[i][1] will give the number of i digit numbers possible ending with non-zero.
The recurrence relation will be:

dp[i][0] = dp[i – 1][1];
dp[i][1] = (dp[i – 1][0] + dp[i – 1][1]) * (K – 1);

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the count of ` `// n-digit numbers that satisfy ` `// the given conditions ` `int` `count_numbers(``int` `k, ``int` `n) ` `{ ` ` `  `    ``// DP array to store the ` `    ``// pre-caluclated states ` `    ``int` `dp[n + 1][2]; ` ` `  `    ``// Base cases ` `    ``dp[1][0] = 0; ` `    ``dp[1][1] = k - 1; ` `    ``for` `(``int` `i = 2; i <= n; i++) { ` ` `  `        ``// i-digit numbers ending with 0 ` `        ``// can be formed by concatenating ` `        ``// 0 in the end of all the (i - 1)-digit ` `        ``// number ending at a non-zero digit ` `        ``dp[i][0] = dp[i - 1][1]; ` ` `  `        ``// i-digit numbers ending with non-zero ` `        ``// can be formed by concatenating any non-zero ` `        ``// digit in the end of all the (i - 1)-digit ` `        ``// number ending with any digit ` `        ``dp[i][1] = (dp[i - 1][0] + dp[i - 1][1]) * (k - 1); ` `    ``} ` ` `  `    ``// n-digit number ending with ` `    ``// and ending with non-zero ` `    ``return` `dp[n][0] + dp[n][1]; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `k = 10; ` `    ``int` `n = 3; ` `    ``cout << count_numbers(k, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` ` `  `// Function to return the count of ` `// n-digit numbers that satisfy ` `// the given conditions ` `static` `int` `count_numbers(``int` `k, ``int` `n) ` `{ ` ` `  `    ``// DP array to store the ` `    ``// pre-caluclated states ` `    ``int` `[][]dp = ``new` `int``[n + ``1``][``2``]; ` ` `  `    ``// Base cases ` `    ``dp[``1``][``0``] = ``0``; ` `    ``dp[``1``][``1``] = k - ``1``; ` `    ``for` `(``int` `i = ``2``; i <= n; i++)  ` `    ``{ ` ` `  `        ``// i-digit numbers ending with 0 ` `        ``// can be formed by concatenating ` `        ``// 0 in the end of all the (i - 1)-digit ` `        ``// number ending at a non-zero digit ` `        ``dp[i][``0``] = dp[i - ``1``][``1``]; ` ` `  `        ``// i-digit numbers ending with non-zero ` `        ``// can be formed by concatenating any non-zero ` `        ``// digit in the end of all the (i - 1)-digit ` `        ``// number ending with any digit ` `        ``dp[i][``1``] = (dp[i - ``1``][``0``] +  ` `                    ``dp[i - ``1``][``1``]) * (k - ``1``); ` `    ``} ` ` `  `    ``// n-digit number ending with ` `    ``// and ending with non-zero ` `    ``return` `dp[n][``0``] + dp[n][``1``]; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `k = ``10``; ` `    ``int` `n = ``3``; ` `    ``System.out.println(count_numbers(k, n)); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## Python3

 `# Python3 implementation of the approach ` ` `  `# Function to return the count of ` `# n-digit numbers that satisfy ` `# the given conditions ` `def` `count_numbers(k, n): ` ` `  `    ``# DP array to store the ` `    ``# pre-caluclated states ` `    ``dp ``=` `[[``0` `for` `i ``in` `range``(``2``)]  ` `             ``for` `i ``in` `range``(n ``+` `1``)] ` ` `  `    ``# Base cases ` `    ``dp[``1``][``0``] ``=` `0` `    ``dp[``1``][``1``] ``=` `k ``-` `1` `    ``for` `i ``in` `range``(``2``, n ``+` `1``): ` ` `  `        ``# i-digit numbers ending with 0 ` `        ``# can be formed by concatenating ` `        ``# 0 in the end of all the (i - 1)-digit ` `        ``# number ending at a non-zero digit ` `        ``dp[i][``0``] ``=` `dp[i ``-` `1``][``1``] ` ` `  `        ``# i-digit numbers ending with non-zero ` `        ``# can be formed by concatenating any non-zero ` `        ``# digit in the end of all the (i - 1)-digit ` `        ``# number ending with any digit ` `        ``dp[i][``1``] ``=` `(dp[i ``-` `1``][``0``] ``+`  `                    ``dp[i ``-` `1``][``1``]) ``*` `(k ``-` `1``) ` ` `  `    ``# n-digit number ending with ` `    ``# and ending with non-zero ` `    ``return` `dp[n][``0``] ``+` `dp[n][``1``] ` ` `  `# Driver code ` `k ``=` `10` `n ``=` `3` `print``(count_numbers(k, n)) ` ` `  `# This code is contributed by Mohit Kumar `

## C#

 `// C# implementation of the approach ` `using` `System; ` `                     `  `class` `GFG  ` `{ ` ` `  `// Function to return the count of ` `// n-digit numbers that satisfy ` `// the given conditions ` `static` `int` `count_numbers(``int` `k, ``int` `n) ` `{ ` ` `  `    ``// DP array to store the ` `    ``// pre-caluclated states ` `    ``int` `[,]dp = ``new` `int``[n + 1, 2]; ` ` `  `    ``// Base cases ` `    ``dp[1, 0] = 0; ` `    ``dp[1, 1] = k - 1; ` `    ``for` `(``int` `i = 2; i <= n; i++)  ` `    ``{ ` ` `  `        ``// i-digit numbers ending with 0 ` `        ``// can be formed by concatenating ` `        ``// 0 in the end of all the (i - 1)-digit ` `        ``// number ending at a non-zero digit ` `        ``dp[i, 0] = dp[i - 1, 1]; ` ` `  `        ``// i-digit numbers ending with non-zero ` `        ``// can be formed by concatenating any non-zero ` `        ``// digit in the end of all the (i - 1)-digit ` `        ``// number ending with any digit ` `        ``dp[i, 1] = (dp[i - 1, 0] +  ` `                    ``dp[i - 1, 1]) * (k - 1); ` `    ``} ` ` `  `    ``// n-digit number ending with ` `    ``// and ending with non-zero ` `    ``return` `dp[n, 0] + dp[n, 1]; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `k = 10; ` `    ``int` `n = 3; ` `    ``Console.WriteLine(count_numbers(k, n)); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```891
```

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.