Count N-digit numbers possible consisting of digits X and Y

Given three integers N, X, and Y, the task is to find the count of N-digit numbers that can be formed using digits 0 to 9 satisfying the following conditions:

Note: Since the answer can be very large, print the answer modulo 109 + 7.

Examples:

Input: N = 2, X = 1, Y = 2
Output: 2
Explanation:
There are only two possible numbers 12 and 21.

Input: N = 10, X = 3, Y = 4 
Output: 100172994

Approach: The idea is to use permutation and combination techniques to solve the problem. Follow the steps below to solve the problem:



Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
const int mod = 1e9 + 7;
 
// Function for calculate
// (x ^ y) % mod in O(log y)
long long power(int x, int y)
{
 
    // Base Condition
    if (y == 0)
        return 1;
 
    // Transition state of
    // power Function
    long long int p
        = power(x, y / 2) % mod;
 
    p = (p * p) % mod;
 
    if (y & 1) {
        p = (x * p) % mod;
    }
 
    return p;
}
 
// Function for counting total numbers
// that can be formed such that digits
// X, Y are present in each number
int TotalNumber(int N)
{
 
    // Calculate the given expression
    int ans = (power(10, N)
               - 2 * power(9, N)
               + power(8, N) + 2 * mod)
              % mod;
 
    // Return the final answer
    return ans;
}
 
// Driver Code
int main()
{
 
    int N = 10, X = 3, Y = 4;
    cout << TotalNumber(N) << endl;
 
    return 0;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
import java.util.*;
 
class GFG{
 
static int mod = (int)(1e9 + 7);
 
// Function for calculate
// (x ^ y) % mod in O(log y)
static long power(int x, int y)
{
 
    // Base Condition
    if (y == 0)
        return 1;
 
    // Transition state of
    // power Function
    int p = (int)(power(x, y / 2) % mod);
 
    p = (p * p) % mod;
 
    if (y % 2 == 1)
    {
        p = (x * p) % mod;
    }
    return p;
}
 
// Function for counting total numbers
// that can be formed such that digits
// X, Y are present in each number
static int TotalNumber(int N)
{
     
    // Calculate the given expression
    int ans = (int)((power(10, N) - 2 *
                     power(9, N) +
                     power(8, N) +
                        2 * mod) % mod);
 
    // Return the final answer
    return ans;
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 10, X = 3, Y = 4;
     
    System.out.print(TotalNumber(N) + "\n");
}
}
 
// This code is contributed by Amit Katiyar
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
mod = 1e9 + 7
 
# Function for calculate
# (x ^ y) % mod in O(log y)
def power(x, y):
 
    # Base Condition
    if (y == 0):
        return 1
 
    # Transition state of
    # power Function
    p = power(x, y // 2) % mod
 
    p = (p * p) % mod
 
    if (y & 1):
        p = (x * p) % mod
 
    return p
 
# Function for counting total numbers
# that can be formed such that digits
# X, Y are present in each number
def TotalNumber(N):
 
    # Calculate the given expression
    ans = (power(10, N) - 2 *
           power(9, N) +
           power(8, N) + 2 * mod) % mod
 
    # Return the final answer
    return ans
 
# Driver Code
if __name__ == '__main__':
 
    N = 10
    X = 3
    Y = 4
     
    print(TotalNumber(N))
 
# This code is contributed by mohit kumar 29
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
class GFG{
 
static int mod = (int)(1e9 + 7);
 
// Function for calculate
// (x ^ y) % mod in O(log y)
static long power(int x, int y)
{
  // Base Condition
  if (y == 0)
    return 1;
 
  // Transition state of
  // power Function
  int p = (int)(power(x,
           y / 2) % mod);
 
  p = (p * p) % mod;
 
  if (y % 2 == 1)
  {
    p = (x * p) % mod;
  }
  return p;
}
 
// Function for counting
// total numbers that can be
// formed such that digits
// X, Y are present in each number
static int TotalNumber(int N)
{   
  // Calculate the given expression
  int ans = (int)((power(10, N) - 2 *
                   power(9, N) +
                   power(8, N) +
                   2 * mod) % mod);
 
  // Return the
  // readonly answer
  return ans;
}
 
// Driver Code
public static void Main(String[] args)
{
  int N = 10;
  Console.Write(TotalNumber(N) + "\n");
}
}
 
// This code is contributed by 29AjayKumar
chevron_right

Output
100172994


Time Complexity: O(log N)
Auxiliary Space: O(1) 

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.




Article Tags :