# Count numbers from a given range whose product of digits is K

• Last Updated : 17 Jun, 2021

Given three positive integers L, R and K, the task is to count the numbers in the range [L, R] whose product of digits is equal to K

Examples:

Input: L = 1, R = 130, K = 14
Output: 3
Explanation:
Numbers in the range [1, 100] whose sum of digits is K(= 14) are:
27 => 2 * 7 = 14
72 => 7 * 2 = 14
127 => 1 * 2 * 7 = 14
Therefore, the required output is 3.

Input: L = 20, R = 10000, K = 14
Output: 20

Naive Approach: The simplest approach to solve this problem is to iterate over all the numbers in the range [L, R] and for every number, check if its product of digits is equal to K or not. If found to be true, then increment the count. Finally, print the count obtained.

Below is the implementation of the above approach:

## C++

 // C++ program to implement// the above approach #include using namespace std; // Function to find the product// of digits of a numberint prodOfDigit(int N){    // Stores product of    // digits of N    int res = 1;     while (N) {         // Update res        res = res * (N % 10);         // Update N        N /= 10;    }     return res;} // Function to count numbers in the range// [0, X] whose product of digit is Kint cntNumRange(int L, int R, int K){    // Stores count of numbers in the range    // [L, R] whose product of digit is K    int cnt = 0;     // Iterate over the range [L, R]    for (int i = L; i <= R; i++) {         // If product of digits of        // i equal to K        if (prodOfDigit(i) == K) {             // Update cnt            cnt++;        }    }     return cnt;} // Driver Codeint main(){    int L = 20, R = 10000, K = 14;    cout << cntNumRange(L, R, K);}

## Java

 // Java program to implement// the above approachimport java.util.*; class GFG{ // Function to find the product// of digits of a numberstatic int prodOfDigit(int N){       // Stores product of    // digits of N    int res = 1;    while (N > 0)    {         // Update res        res = res * (N % 10);         // Update N        N /= 10;    }     return res;} // Function to count numbers in the range// [0, X] whose product of digit is Kstatic int cntNumRange(int L, int R, int K){       // Stores count of numbers in the range    // [L, R] whose product of digit is K    int cnt = 0;     // Iterate over the range [L, R]    for (int i = L; i <= R; i++)    {         // If product of digits of        // i equal to K        if (prodOfDigit(i) == K)        {             // Update cnt            cnt++;        }    }    return cnt;} // Driver Codepublic static void main(String[] args){    int L = 20, R = 10000, K = 14;    System.out.print(cntNumRange(L, R, K));}} // This code is contributed by Amit Katiyar

## Python3

 # Python3 program to implement# the above approach # Function to find the product# of digits of a numberdef prodOfDigit(N):         # Stores product of    # digits of N    res = 1     while (N):                 # Update res        res = res * (N % 10)         # Update N        N //= 10     return res # Function to count numbers in the range# [0, X] whose product of digit is Kdef cntNumRange(L, R, K):         # Stores count of numbers in the range    # [L, R] whose product of digit is K    cnt = 0     # Iterate over the range [L, R]    for i in range(L, R + 1):                 # If product of digits of        # i equal to K        if (prodOfDigit(i) == K):             # Update cnt            cnt += 1     return cnt # Driver Codeif __name__ == '__main__':         L, R, K = 20, 10000, 14         print(cntNumRange(L, R, K)) # This code is contributed by mohit kumar 29

## C#

 // C# program to implement// the above approachusing System;  class GFG{      // Function to find the product// of digits of a numberstatic int prodOfDigit(int N){         // Stores product of    // digits of N    int res = 1;         while (N > 0)    {                 // Update res        res = res * (N % 10);          // Update N        N /= 10;    }    return res;}  // Function to count numbers in the range// [0, X] whose product of digit is Kstatic int cntNumRange(int L, int R, int K){        // Stores count of numbers in the range    // [L, R] whose product of digit is K    int cnt = 0;      // Iterate over the range [L, R]    for(int i = L; i <= R; i++)    {          // If product of digits of        // i equal to K        if (prodOfDigit(i) == K)        {              // Update cnt            cnt++;        }    }    return cnt;}  // Driver Codestatic void Main(){    int L = 20, R = 10000, K = 14;         Console.WriteLine(cntNumRange(L, R, K));}} // This code is contributed by code_hunt

## Javascript

 

Output:

20

Time Complexity: O(R – L + 1) * log10(R)
Auxiliary Space: O(1)

Efficient approach: To optimize the above approach, the idea is to use Digit DP. Following are the dynamic programming states of the Digit DP:

Dynamic programming states are:
prod: Represents sum of digits.
tight: Check if sum of digits exceed K or not.
end: Stores the maximum possible value of ith digit of a number.
st: Check if a number contains leading 0 or not.

Following are the Recurrence Relation of the Dynamic programming states:

• If i == 0 and st == 0:  cntNum(N, K, st, tight): Returns the count of numbers in the range [0, X] whose product of digits is K.

• Otherwise,  cntNum(N, K, st, tight): Returns the count of numbers in the range [0, X] whose product of digits is K.

Follow the steps below to solve the problem:

1. Initialize a 3D array dp[N][K][tight] to compute and store the values of all subproblems of the above recurrence relation.
2. Finally, return the value of dp[N][sum][tight].

Below is the implementation of the above approach:

## C++

 // C++ program to implement// the above approach#include using namespace std;#define M 100 // Function to count numbers in the range// [0, X] whose product of digit is Kint cntNum(string X, int i, int prod, int K,           int st, int tight, int dp[M][M]){    // If count of digits in a number    // greater than count of digits in X    if (i >= X.length() || prod > K) {         // If product of digits of a        // number equal to K        return prod == K;    }     // If overlapping subproblems    // already occurred    if (dp[prod][i][tight][st] != -1) {        return dp[prod][i][tight][st];    }     // Stores count of numbers whose    // product of digits is K    int res = 0;     // Check if the numbers    // exceeds K or not    int end = tight ? X[i] - '0' : 9;     // Iterate over all possible    // value of i-th digits    for (int j = 0; j <= end; j++) {         // if number contains leading 0        if (j == 0 && !st) {             // Update res            res += cntNum(X, i + 1, prod, K,                          false, (tight & (j == end)), dp);        }         else {             // Update res            res += cntNum(X, i + 1, prod * j, K,                          true, (tight & (j == end)), dp);        }         // Update res    }     // Return res    return dp[prod][i][tight][st] = res;} // Utility function to count the numbers in// the range [L, R] whose prod of digits is Kint UtilCntNumRange(int L, int R, int K){    // Stores numbers in the form    // of string    string str = to_string(R);     // Stores overlapping subproblems    int dp[M][M];     // Initialize dp[][][] to -1    memset(dp, -1, sizeof(dp));     // Stores count of numbers in    // the range [0, R] whose    // product of  digits is k    int cntR = cntNum(str, 0, 1, K,                      false, true, dp);     // Update str    str = to_string(L - 1);     // Initialize dp[][][] to -1    memset(dp, -1, sizeof(dp));     // Stores count of numbers in    // the range [0, L - 1] whose    // product of  digits is k    int cntL = cntNum(str, 0, 1, K,                      false, true, dp);     return (cntR - cntL);} // Driver Codeint main(){    int L = 20, R = 10000, K = 14;    cout << UtilCntNumRange(L, R, K);}

## Java

 // Java program to implement// the above approachimport java.util.*; class GFG{     static final int M = 100; // Function to count numbers in the range// [0, X] whose product of digit is Kstatic int cntNum(String X, int i, int prod, int K,                    int st, int tight, int [][][][]dp){         // If count of digits in a number    // greater than count of digits in X    if (i >= X.length() || prod > K)    {                 // If product of digits of a        // number equal to K        return prod == K ? 1 : 0;    }     // If overlapping subproblems    // already occurred    if (dp[prod][i][tight][st] != -1)    {        return dp[prod][i][tight][st];    }     // Stores count of numbers whose    // product of digits is K    int res = 0;     // Check if the numbers    // exceeds K or not    int end = tight > 0 ? X.charAt(i) - '0' : 9;     // Iterate over all possible    // value of i-th digits    for(int j = 0; j <= end; j++)    {                 // If number contains leading 0        if (j == 0 && st == 0)        {                         // Update res            res += cntNum(X, i + 1, prod, K, 0,                  (tight & ((j == end) ? 1 : 0)), dp);        }        else        {                         // Update res            res += cntNum(X, i + 1, prod * j, K, 1,                  (tight & ((j == end) ? 1 : 0)), dp);        }    }     // Return res    return dp[prod][i][tight][st] = res;} // Utility function to count the numbers in// the range [L, R] whose prod of digits is Kstatic int UtilCntNumRange(int L, int R, int K){         // Stores numbers in the form    // of String    String str = String.valueOf(R);     // Stores overlapping subproblems    int [][][][]dp = new int[M][M];     // Initialize dp[][][] to -1    for(int i = 0; i < M; i++)    {        for(int j = 0; j < M; j++)        {            for(int k = 0; k < 2; k++)                for(int l = 0; l < 2; l++)                    dp[i][j][k][l] = -1;        }    }     // Stores count of numbers in    // the range [0, R] whose    // product of  digits is k    int cntR = cntNum(str, 0, 1, K,                      0, 1, dp);     // Update str    str = String.valueOf(L - 1);     // Initialize dp[][][] to -1    for(int i = 0;i

## Python3

 # Python 3 program to implement# the above approachM = 100 # Function to count numbers in the range# [0, X] whose product of digit is Kdef cntNum(X, i, prod, K, st, tight, dp):    end = 0         # If count of digits in a number    # greater than count of digits in X    if (i >= len(X) or prod > K):               # If product of digits of a        # number equal to K        if(prod == K):          return 1        else:          return 0     # If overlapping subproblems    # already occurred    if (dp[prod][i][tight][st] != -1):        return dp[prod][i][tight][st]     # Stores count of numbers whose    # product of digits is K    res = 0     # Check if the numbers    # exceeds K or not    if(tight != 0):        end = ord(X[i]) - ord('0')     # Iterate over all possible    # value of i-th digits    for j in range(end + 1):               # if number contains leading 0        if (j == 0 and st == 0):            # Update res            res += cntNum(X, i + 1, prod, K, False, (tight & (j == end)), dp)         else:            # Update res            res += cntNum(X, i + 1, prod * j, K, True, (tight & (j == end)), dp)        # Update res     # Return res    dp[prod][i][tight][st] = res    return res # Utility function to count the numbers in# the range [L, R] whose prod of digits is Kdef UtilCntNumRange(L, R, K):    global M         # Stores numbers in the form    # of string    str1 = str(R)     # Stores overlapping subproblems    dp = [[[[-1 for i in range(2)] for j in range(2)] for k in range(M)] for l in range(M)]     # Stores count of numbers in    # the range [0, R] whose    # product of  digits is k    cntR = cntNum(str1, 0, 1, K, False, True, dp)     # Update str    str1 = str(L - 1)    dp = [[[[-1 for i in range(2)] for j in range(2)] for k in range(M)] for l in range(M)]     # Stores count of numbers in    cntR = 20         # the range [0, L - 1] whose    # product of  digits is k    cntL = cntNum(str1, 0, 1, K, False, True, dp)    return (cntR - cntL) # Driver Codeif __name__ == '__main__':    L = 20    R = 10000    K = 14    print(UtilCntNumRange(L, R, K))     # This code is contributed by SURENDRA_GANGWAR.

## C#

 // C# program to implement// the above approachusing System;class GFG{   static readonly int M = 100;   // Function to count numbers in the range  // [0, X] whose product of digit is K  static int cntNum(String X, int i, int prod, int K,                    int st, int tight, int [,,,]dp)  {     // If count of digits in a number    // greater than count of digits in X    if (i >= X.Length || prod > K)    {       // If product of digits of a      // number equal to K      return prod == K ? 1 : 0;    }     // If overlapping subproblems    // already occurred    if (dp[prod, i, tight, st] != -1)    {      return dp[prod, i, tight, st];    }     // Stores count of numbers whose    // product of digits is K    int res = 0;     // Check if the numbers    // exceeds K or not    int end = tight > 0 ? X[i] - '0' : 9;     // Iterate over all possible    // value of i-th digits    for(int j = 0; j <= end; j++)    {       // If number contains leading 0      if (j == 0 && st == 0)      {         // Update res        res += cntNum(X, i + 1, prod, K, 0,                      (tight & ((j == end) ? 1 : 0)), dp);      }      else      {         // Update res        res += cntNum(X, i + 1, prod * j, K, 1,                      (tight & ((j == end) ? 1 : 0)), dp);      }    }     // Return res    return dp[prod, i, tight, st] = res;  }   // Utility function to count the numbers in  // the range [L, R] whose prod of digits is K  static int UtilCntNumRange(int L, int R, int K)  {     // Stores numbers in the form    // of String    String str = String.Join("", R);     // Stores overlapping subproblems    int [,,,]dp = new int[M, M, 2, 2];     // Initialize [,]dp[] to -1    for(int i = 0; i < M; i++)    {      for(int j = 0; j < M; j++)      {        for(int k = 0; k < 2; k++)          for(int l = 0; l < 2; l++)            dp[i, j, k, l] = -1;      }    }     // Stores count of numbers in    // the range [0, R] whose    // product of  digits is k    int cntR = cntNum(str, 0, 1, K,                      0, 1, dp);     // Update str    str = String.Join("", L - 1);     // Initialize [,]dp[] to -1    for(int i = 0; i < M; i++)    {      for(int j = 0; j < M; j++)      {        for(int k = 0; k < 2; k++)          for(int l = 0; l < 2; l++)            dp[i, j, k, l] = -1;      }    }     // Stores count of numbers in    // the range [0, L - 1] whose    // product of  digits is k    int cntL = cntNum(str, 0, 1, K,                      0, 1, dp);     return (cntR - cntL);  }   // Driver Code  public static void Main(String[] args)  {    int L = 20, R = 10000, K = 14;     Console.Write(UtilCntNumRange(L, R, K));  }}   // This code is contributed by 29AjayKumar

## Javascript

 

Output:

20`

Time Complexity: O(K * log10(R) * 10 * 4)
Auxiliary Space: O(K * log10(R) * 4)

My Personal Notes arrow_drop_up