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

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

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

public class Main {

    // Function to return the count of
    // n-digit numbers that satisfy
    // the given conditions
    public static int countNumbers(int k, int n)
    {
        // Stores the previous and current
        // computations
        int prevZero = 0, prevNonZero = k - 1;
        int currZero, currNonZero;

        // iterate over subproblems
        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
            currZero = prevNonZero;
            currNonZero
                = (prevZero + prevNonZero) * (k - 1);

            // assigning values to
            // compute further
            prevZero = currZero;
            prevNonZero = currNonZero;
        }

        // n-digit number ending with
        // and ending with non-zero
        return prevZero + prevNonZero;
    }

    // Driver Code
    public static void main(String[] args)
    {
        int k = 10;
        int n = 3;
        System.out.println(countNumbers(k, n));
    }
}

//Java program to implement above approach
import java.util.Arrays;

public class GFG {

    // Function to check if it's valid to place the 'digit' at the specified 'index' of the number array
    // It returns true if it's valid and false otherwise
    static boolean isValid(int[] number, int index, int digit) {
        if (index > 0 && number[index - 1] == 0 && digit == 0) {
            return false; // consecutive digit pair of zero (leading zeros)
        }
        return true;
    }

    // Recursive function to generate all possible combinations of digits for the number
    static void backtrack(int[] number, int index, int N, int K, int[] count) {
        if (index == N) {
            count[0]++; // A valid number has been formed, increment the count
            return;
        }

        // Skip generating numbers with leading zeros
        int start = (index == 0) ? 1 : 0;

        for (int digit = start; digit < K; digit++) {
            if (isValid(number, index, digit)) {
                number[index] = digit;
                backtrack(number, index + 1, N, K, count);
            }
        }
    }

    // Function to count the number of valid integers of length 'N' that can be formed using digits from '0' to 'K-1'
    static int countValidIntegers(int N, int K) {
        int[] number = new int[N]; // To store the digits of the number
        int[] count = new int[1];  // To keep track of the count

        // Backtrack to generate all combinations of digits and count the valid integers
        backtrack(number, 0, N, K, count);

        return count[0];
    }
//Driver Code
    public static void main(String[] args) {
        int N = 3; // Length of the number
        int K = 10; // Base of the number system (digits from 0 to 9)

        int result = countValidIntegers(N, K);
        System.out.println(result);
    }
}