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 ^{9} + 7**.

**Examples:**

Input:N = 2, X = 1, Y = 2Output:1Explanation: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 = 5Output:4Explanation: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 ^{9} + 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**.^{9}+ 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` `}` |

*chevron_right*

*filter_none*

## 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);` ` ` `}` `}` |

*chevron_right*

*filter_none*

## 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` |

*chevron_right*

*filter_none*

## 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` |

*chevron_right*

*filter_none*

**Output**

4

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.