Count N-digit numbers made up of X or Y whose sum of digits is also made up of X or Y

Given three positive integers N, X, and Y, the task is to count N-digit numbers containing of X or Y only as digits and the sum of digits also contains X or Y. Since the count can be very large, print the count modulo 10⁹ + 7.

Examples:

Input: N = 2, X = 1, Y = 2
Output: 1
Explanation: All possible 2-digit numbers that can be formed using X and Y are 11, 12, 21, 22. Among them, only 11 is a valid number since its sum of digits is 2 (= Y).

Input: N = 3, X = 1, Y = 5
Output: 4
Explanation: All possible 3-digit numbers that can be formed using X and Y are 111, 115, 151, 155. But only 155, 515, 551 and 555 satisfies the given condition. Therefore, the count is 4.

Naive Approach: The simplest approach to solve this problem by using recursion. At each step, there are 2 choices, to place digit X or Y at the current position and calculate the sum of digits when the length of the formed number becomes equal to N. If the sum is also formed of only X or Y the count this number. After checking all the numbers print the count modulo 10⁹ + 7. 

Time Complexity: O(2^N)
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized by using Dynamic Programming since this problem has both properties of Optimal Substructure and Overlapping Subproblems. The computations of the same subproblems can be avoided by using an auxiliary array dp[N][sum] to store the value when the number of digits left is N and the sum of filled digits is the sum. Below are the steps:

• Initialize an auxiliary array dp[][] to store intermediate computations.
• At each step, there are 2 choices to place digit X or Y at the current position.
• When the number of digits left is 0, check if the sum of digits can be made using X or Y. If yes then increment the current state value by 1.
• Else Update the current state as 0.
• If the same subproblem is encountered, return the already computed value modulo 10⁹ + 7.
• Place digit X and digit Y at the current position and recur for the remaining positions, and pass the sum of digits at each step.
• For each recursive call for value x and y, update the current state as the sum of values returned by these states.
• After the above steps, print the value of dp[N][0] as the resultant count.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Stores the value of overlapping
// states
int dp[1000 + 5][9000 + 5];
int mod = 1000000007;

// Function to check whether a number
// have only digits X or Y or not
int check(int sum, int x, int y)
{
    // Until sum is positive
    while (sum > 0) {

        int ln = sum % 10;

        // If any digit is not
        // X or Y then return 0
        if (ln != x && ln != y) {
            return 0;
        }
        sum /= 10;
    }

    // Return 1
    return 1;
}

// Function to find the count of
// numbers that are formed by digits
// X and Y and whose sum of digit
// also have digit X or Y
int countNumbers(int n, int x, int y, int sum)
{
    // Initialize dp array
    memset(dp, -1, sizeof(dp));

    // Base Case
    if (n == 0) {

        // Check if sum of digits
        // formed by only X or Y
        return check(sum, x, y);
    }

    // Return the already computed
    if (dp[n][sum] != -1) {
        return dp[n][sum] % mod;
    }

    // Place the digit X at the
    // current position
    int option1 = countNumbers(n - 1, x,
                               y, sum + x) % mod;

    // Place the digit Y at the
    // current position
    int option2 = countNumbers(n - 1, x,
                               y, sum + y) % mod;

    // Update current state result
    return dp[n][sum] = (option1 + option2) % mod;
}

// Driver Code
int main()
{
    int N = 3, X = 1, Y = 5;

    // Function Call
    cout << countNumbers(N, X, Y, 0) % mod;
    // This code is contributed by bolliranadheer
}

Java

// Java program for the above approach

import java.util.*;
public class Main {

    // Stores the value of overlapping
    // states
    static int dp[][] = new int[1000 + 5][9000 + 5];
    static int mod = 1000000007;

    // Function to find the count of
    // numbers that are formed by digits
    // X and Y and whose sum of digit
    // also have digit X or Y
    public static int countNumbers(int n, int x, int y,
                                   int sum)
    {
        // Initialize dp array
        for (int i[] : dp)
            Arrays.fill(i, -1);

        // Base Case
        if (n == 0) {

            // Check if sum of digits
            // formed by only X or Y
            return check(sum, x, y);
        }

        // Return the already computed
        if (dp[n][sum] != -1) {
            return dp[n][sum] % mod;
        }

        // Place the digit X at the
        // current position
        int option1
            = countNumbers(n - 1, x, y, sum + x) % mod;

        // Place the digit Y at the
        // current position
        int option2
            = countNumbers(n - 1, x, y, sum + y) % mod;

        // Update current state result
        return dp[n][sum] = (option1 + option2) % mod;
    }

    // Function to check whether a number
    // have only digits X or Y or not
    public static int check(int sum, int x, int y)
    {
        // Until sum is positive
        while (sum > 0) {

            int ln = sum % 10;

            // If any digit is not
            // X or Y then return 0
            if (ln != x && ln != y) {
                return 0;
            }
            sum /= 10;
        }

        // Return 1
        return 1;
    }

    // Driver Code
    public static void main(String args[])
    {
        int N = 3, X = 1, Y = 5;

        // Function Call
        System.out.println(countNumbers(N, X, Y, 0) % mod);
    }
}

Python3

# Python3 program for the above approach

# Stores the value of overlapping
# states
dp = [[-1 for x in range(9000 + 5)]
          for y in range(1000 + 5)]
mod = 1000000007

# Function to check whether a number
# have only digits X or Y or not
def check(sum, x, y):

    # Until sum is positive
    while (sum > 0):
        ln = sum % 10

        # If any digit is not
        # X or Y then return 0
        if (ln != x and ln != y):
            return 0

        sum //= 10

    # Return 1
    return 1

# Function to find the count of
# numbers that are formed by digits
# X and Y and whose sum of digit
# also have digit X or Y
def countNumbers(n, x, y, sum):

    # Initialize dp array
    global dp

    # Base Case
    if (n == 0):

        # Check if sum of digits
        # formed by only X or Y
        return check(sum, x, y)

    # Return the already computed
    if (dp[n][sum] != -1):
        return dp[n][sum] % mod

    # Place the digit X at the
    # current position
    option1 = countNumbers(n - 1, x,
                      y, sum + x) % mod

    # Place the digit Y at the
    # current position
    option2 = countNumbers(n - 1, x,
                      y, sum + y) % mod

    # Update current state result
    dp[n][sum] = (option1 + option2) % mod

    return dp[n][sum]

# Driver Code
if __name__ == "__main__":

    N = 3
    X = 1
    Y = 5

    # Function Call
    print(countNumbers(N, X, Y, 0) % mod)

# This code is contributed by chitranayal

C#

// C# program for the above approach
using System;

class GFG{

// Stores the value of overlapping
// states
static int [,]dp = new int[100 + 5, 900 + 5];
static int mod = 10000007;

// Function to find the count of
// numbers that are formed by digits
// X and Y and whose sum of digit
// also have digit X or Y
public static int countNumbers(int n, int x,
                               int y, int sum)
{

    // Initialize dp array
    for(int i = 0; i < dp.GetLength(0); i++)
    {
        for(int j = 0; j < dp.GetLength(1); j++)
        {
            dp[i, j] = -1;
        }
    }

    // Base Case
    if (n == 0)
    {

        // Check if sum of digits
        // formed by only X or Y
        return check(sum, x, y);
    }

    // Return the already computed
    if (dp[n, sum] != -1)
    {
        return dp[n, sum] % mod;
    }

    // Place the digit X at the
    // current position
    int option1 = countNumbers(n - 1, x, y,
                             sum + x) % mod;

    // Place the digit Y at the
    // current position
    int option2 = countNumbers(n - 1, x, y,
                             sum + y) % mod;

    // Update current state result
    return dp[n,sum] = (option1 + option2) % mod;
}

// Function to check whether a number
// have only digits X or Y or not
public static int check(int sum, int x, int y)
{

    // Until sum is positive
    while (sum > 0)
    {
        int ln = sum % 10;

        // If any digit is not
        // X or Y then return 0
        if (ln != x && ln != y)
        {
            return 0;
        }
        sum /= 10;
    }

    // Return 1
    return 1;
}

// Driver Code
public static void Main(String []args)
{
    int N = 3, X = 1, Y = 5;

    // Function Call
    Console.WriteLine(countNumbers(
        N, X, Y, 0) % mod);
}
}

// This code is contributed by Princi Singh

Javascript

<script>

// JavaScript program for the above approach

// Stores the value of overlapping
// states
let dp = [];
for(let i = 0;i<1005;i++){
   dp[i] = [];
   for(let j = 0;j<9005;j++){
        dp[i][j] = 0;
   }
}
let mod = 1000000007;

// Function to check whether a number
// have only digits X or Y or not
function check( sum,  x, y)
{
    // Until sum is positive
    while (sum > 0) {

        let ln = sum % 10;

        // If any digit is not
        // X or Y then return 0
        if (ln != x && ln != y) {
            return 0;
        }
        sum = Math.floor(sum/10);
    }

    // Return 1
    return 1;
}

// Function to find the count of
// numbers that are formed by digits
// X and Y and whose sum of digit
// also have digit X or Y
function countNumbers(n, x, y, sum)
{
    // Initialize dp array
    for(let i = 0;i<1005;i++){
   for(let j = 0;j<9005;j++){
        dp[i][j] = -1;
   }
}
    // Base Case
    if (n == 0) {

        // Check if sum of digits
        // formed by only X or Y
        return check(sum, x, y);
    }

    // Return the already computed
    if (dp[n][sum] != -1) {
        return dp[n][sum] % mod;
    }

    // Place the digit X at the
    // current position
    let option1 = countNumbers(n - 1, x,
                               y, sum + x) % mod;

    // Place the digit Y at the
    // current position
    let option2 = countNumbers(n - 1, x,
                               y, sum + y) % mod;

    // Update current state result
    return dp[n][sum] = (option1 + option2) % mod;
}

// Driver Code
let N = 3, X = 1, Y = 5;

    // Function Call
    document.write(countNumbers(N, X, Y, 0) % mod);

</script>

Output

4

Time Complexity:(N*sum)
Auxiliary Space: O(N*sum)

Efficient approach : Using DP Tabulation method ( Iterative approach )

The approach to solve this problem is same but DP tabulation(bottom-up) method is better then Dp + memorization(top-down) because memorization method needs extra stack space of recursion calls.

Steps to solve this problem :

• Create a vector to store the solution of the subproblems.
• Initialize the table with base cases
• Fill up the table iteratively
• Return the final solution

Implementation :

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

const int N = 1000 + 5, M = 9000 + 5, MOD = 1000000007;

int dp[N][M];

// Function to check whether a number
// have only digits X or Y or not
int check(int sum, int x, int y) {
    while (sum > 0) {
        int ln = sum % 10;
        if (ln != x && ln != y) {
            return 0;
        }
        sum /= 10;
    }
    return 1;
}

// Function to find the count of
// numbers that are formed by digits
// X and Y and whose sum of digit
// also have digit X or Y
int countNumbers(int n, int x, int y, int sum) {
    // Initialize dp array
    memset(dp, 0, sizeof(dp));

    // base case
    dp[0][0] = 1;

    for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= sum; j++) {

            // Place the digit X at the
            // current position
            int option1 = (j >= x ? dp[i-1][j-x] : 0);
            // Place the digit Y at the
            // current position
            int option2 = (j >= y ? dp[i-1][j-y] : 0);
            // Update current state result
            dp[i][j] = (option1 + option2) % MOD;
        }
    }

    // get answer
    int ans = 0;
    for (int i = 0; i <= sum; i++) {
        // update answer
        ans = (ans + check(i, x, y) * dp[n][i]) % MOD;
    }

    return ans;
}

// Driver code
int main() {
    int n = 3, x = 1, y = 5;
    cout << countNumbers(n, x, y, 9000) << endl;
    return 0;
}

// This code is contributed by bhardwajji

Java

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

class GFG{
  static final int N = 1000 + 5, M = 9000 + 5, MOD = 1000000007;

  static int[][] dp = new int[N][M];

  // Function to check whether a number
  // have only digits X or Y or not
  static int check(int sum, int x, int y) {
    while (sum > 0) {
      int ln = sum % 10;
      if (ln != x && ln != y) {
        return 0;
      }
      sum /= 10;
    }
    return 1;
  }

  // Function to find the count of
  // numbers that are formed by digits
  // X and Y and whose sum of digit
  // also have digit X or Y
  static int countNumbers(int n, int x, int y, int sum)
  {

    // Initialize dp array
    for (int[] row : dp)
      Arrays.fill(row, 0);

    // base case
    dp[0][0] = 1;

    for (int i = 1; i <= n; i++) {
      for (int j = 0; j <= sum; j++) {

        // Place the digit X at the
        // current position
        int option1 = (j >= x ? dp[i - 1][j - x] : 0);

        // Place the digit Y at the
        // current position
        int option2 = (j >= y ? dp[i - 1][j - y] : 0);

        // Update current state result
        dp[i][j] = (option1 + option2) % MOD;
      }
    }

    // get answer
    int ans = 0;
    for (int i = 0; i <= sum; i++)
    {

      // update answer
      ans = (ans + check(i, x, y) * dp[n][i]) % MOD;
    }

    return ans;
  }

  public static void main(String[] args) {
    int n = 3, x = 1, y = 5;
    System.out.println(countNumbers(n, x, y, 9000));
  }
}

Python

MOD = 1000000007
N = 1000 + 5
M = 9000 + 5

dp = [[0 for j in range(M)] for i in range(N)]

# Function to check whether a number
# have only digits X or Y or not
def check(sum, x, y):
    while sum > 0:
        ln = sum % 10
        if ln != x and ln != y:
            return 0
        sum //= 10
    return 1

# Function to find the count of
# numbers that are formed by digits
# X and Y and whose sum of digit
# also have digit X or Y
def countNumbers(n, x, y, sum):
    # Initialize dp array
    for i in range(N):
        for j in range(M):
            dp[i][j] = 0

    # base case
    dp[0][0] = 1

    for i in range(1, n+1):
        for j in range(sum+1):

            # Place the digit X at the
            # current position
            option1 = dp[i-1][j-x] if j >= x else 0
            # Place the digit Y at the
            # current position
            option2 = dp[i-1][j-y] if j >= y else 0
            # Update current state result
            dp[i][j] = (option1 + option2) % MOD

    # get answer
    ans = 0
    for i in range(sum+1):
        # update answer
        ans = (ans + check(i, x, y) * dp[n][i]) % MOD

    return ans

# Driver code
if __name__ == "__main__":
    n = 3
    x = 1
    y = 5
    print(countNumbers(n, x, y, 9000))

Output

4

Time Complexity: (N*sum)
Auxiliary Space: O(N*sum)