Related Articles

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

• Last Updated : 27 May, 2021

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

Time Complexity: O(2N)
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 109 + 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] as the resultant count.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``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

 ``
Output
`4`

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up