Related Articles
Count of N-digit numbers in base K with no two consecutive zeroes
• Difficulty Level : Hard
• Last Updated : 05 May, 2021

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

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`

## Javascript

 ``
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] where dp[i] will give the number of i digit numbers possible ending with 0 and dp[i] will give the number of i digit numbers possible ending with non-zero.
The recurrence relation will be:

dp[i] = dp[i – 1];
dp[i] = (dp[i – 1] + dp[i – 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];` `    ``// Base cases``    ``dp = 0;``    ``dp = 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] = dp[i - 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] = (dp[i - 1] + dp[i - 1]) * (k - 1);``    ``}` `    ``// n-digit number ending with``    ``// and ending with non-zero``    ``return` `dp[n] + dp[n];``}` `// 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`

## Javascript

 ``
Output:
`891`

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up