# 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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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`

My Personal Notes arrow_drop_up