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][0] as the resultant count.
Below is the implementation of the above approach:
// 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 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 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# 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 |
<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> |
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++ 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 |
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 ));
}
} |
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 ))
|
using System;
class GFG
{ const int N = 1000 + 5;
const int M = 9000 + 5;
const int MOD = 1000000007;
static int [,] dp = new int [N, M];
// Function to check whether a number
// has 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 digits
// also has digit X or Y
static int CountNumbers( int n, int x, int y, int sum)
{
// Initialize dp array
for ( int i = 0; i < N; i++)
{
for ( int j = 0; j < M; j++)
{
dp[i, j] = 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 the current state result
dp[i, j] = (option1 + option2) % MOD;
}
}
// Get the answer
int ans = 0;
for ( int i = 0; i <= sum; i++)
{
// Update the answer
ans = (ans + Check(i, x, y) * dp[n, i]) % MOD;
}
return ans;
}
// Driver code
static void Main()
{
int n = 3, x = 1, y = 5;
Console.WriteLine(CountNumbers(n, x, y, 9000));
}
} |
// Nikunj Sonigara // JavaScript program for the above approach const N = 1000 + 5; const M = 9000 + 5; const MOD = 1000000007; let dp = new Array(N);
for (let i = 0; i < N; i++) {
dp[i] = new Array(M).fill(0);
} // Function to check whether a number // have only digits X or Y or not function check(sum, x, y) {
while (sum > 0) {
let ln = sum % 10;
if (ln !== x && ln !== y) {
return 0;
}
sum = Math.floor(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 function countNumbers(n, x, y, sum) {
// Initialize dp array
for (let i = 0; i <= n; i++) {
for (let j = 0; j <= sum; j++) {
dp[i][j] = 0;
}
}
// base case
dp[0][0] = 1;
for (let i = 1; i <= n; i++) {
for (let j = 0; j <= sum; j++) {
// Place the digit X at the
// current position
let option1 = (j >= x ? dp[i - 1][j - x] : 0);
// Place the digit Y at the
// current position
let option2 = (j >= y ? dp[i - 1][j - y] : 0);
// Update current state result
dp[i][j] = (option1 + option2) % MOD;
}
}
// get answer
let ans = 0;
for (let i = 0; i <= sum; i++) {
// update answer
ans = (ans + check(i, x, y) * dp[n][i]) % MOD;
}
return ans;
} // Driver code const n = 3; const x = 1; const y = 5; console.log(countNumbers(n, x, y, 9000)); |
Output
4
Time Complexity: (N*sum)
Auxiliary Space: O(N*sum)