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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Output:

891


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.