Count numbers that does not contain digit N in given range

// Java code to implement the approach

import java.io.*;
import java.util.*;

class GFG {

    static final int MOD = 1_000_000_007;

    // dp table initialized with -1
    static int[][] dp = new int[100001][2];

    // Recursive Function to find numbers
    // in the range L to R such that they
    // do not contain digit N
    static int recur(int i, int j, int N, String a)
    {
        // Base case
        if (i == a.length()) {
            return 1;
        }

        // If answer for current state is already
        // calculated then just return dp[i][j]
        if (dp[i][j] != -1)
            return dp[i][j];

        // Answer initialized with zero
        int ans = 0;

        // Tight condition true
        if (j == 1) {
            // Iterating from 0 to max value
            // of tight condition
            for (int k = 0; k <= a.charAt(i) - '0'; k++) {
                // N is not allowed to use
                if (k == N)
                    continue;
                // When k is at max tight condition
                // remains even in next state
                if (k == a.charAt(i) - '0')
                    // Calling recursive function
                    // for tight digit
                    ans += recur(i + 1, 1, N, a);
                // Tight condition drops
                else
                    ans += recur(i + 1, 0, N, a);
            }
        }
        // Tight condition false
        else {
            // Iterating for all digits
            for (int k = 0; k <= 9; k++) {
                // Digit N is not possible
                if (k == N)
                    continue;
                // Calling recursive function for
                // all digits from 0 to 9
                ans += recur(i + 1, 0, N, a);
            }
        }

        // Save and return dp value
        return dp[i][j] = ans;
    }

    // Function to find numbers
    // in the range L to R such that they
    // do not contain digit N
    static int countInRange(int N, int A, int B)
    {
        // Initializing dp array with - 1
        for (int[] row : dp) {
            Arrays.fill(row, -1);
        }

        A--;
        String L = Integer.toString(A);
        String R = Integer.toString(B);

        // Numbers with sum of digits T from
        // 1 to L - 1
        int ans1 = recur(0, 1, N, L);

        // Initializing dp array with - 1
        for (int[] row : dp) {
            Arrays.fill(row, -1);
        }

        // Numbers with sum of digits T in the
        // range 1 to R
        int ans2 = recur(0, 1, N, R);

        // Difference of ans2 and ans1
        // will generate answer for required
        // range
        return ans2 - ans1;
    }

    public static void main(String[] args)
    {
        // Input 1
        int N = 5;
        int L = 1;
        int R = 10;

        // Function Call
        System.out.println(countInRange(N, L, R));

        // Input 2
        int N1 = 5;
        int L1 = 1;
        int R1 = 100;

        // Function Call
        System.out.println(countInRange(N1, L1, R1));
    }
}

// This contributed by lokeshmvs21.