Given a range of values **[L, R]** and a value **K**, the task is to count the numbers in the given range which are divisible by at least **K** of the digits present in the decimal representation of that number.

**Examples:**

Input:L = 24, R = 25, K = 2Output:1Explanation:

24 has two digits 2 and 4 and is divisible by both 2 and 4. So this satisfies the given condition.

25 has two digits 2 and 5 and is only divisible by 5. But since K = 2, it doesnot qualifies the mentioned criteria.

Input:L = 5, R = 15, K = 1Output:11

**Method 1: Naive Approach**

- For any number between
**L**to**R**, find the count of it’s digits that divides the number. - If the count of number in the above step is greater than or equal to
**K**, then include that number to the final count. - Repeat the above steps for all numbers from
**L to R**and print the final count.

**Time Complexity:** O(N), where N is the difference between the range **[L, R]**.

**Method 2: Efficient Approach**

We will use the concept of Digit DP to solve this problem. Below are the observations to solve this problem:

- For all the positive integers(say
**a**), to find the divisibility of the number from digits**2 to 9**, the number**a**can be reduced as stated below to find the divisibility efficiently:a = k*LCM(2, 3, 4, ..., 9) + q where k is integer and q lies between range

**[0, lcm(2, 3, ..9)]**LCM(2, 3, 4, ..., 9) = 2^{3}x3^{2}x5x7 = 2520 - After performing a = a modulo 2520, we can find the count of digit from the original number a that divides this modulo.

Below are the steps to do so:

- Store all the digits of the given range and sort the digits in decreasing order.
- Traverse all the digits stored above and generate all the number which are strictly less than the given range of number.
- For generating the number less than the given number, use a variable
such that:*tight*- The value of
is 0, denotes that by including that digit will give the number less than the given range.**tight** - The value of
is 1, denotes that by including that digit, it will give the number greater than the given range. So we can remove all permutations after getting tight value 1 to avoid more number of recursive calls.**tight**

- The value of
- After generating all of the permutations of numbers, Find the number for which the count of digits dividing that number is greater than or equals to
**K**. - Store the count for each permuted number in dp table to use the result for Overlapping Subproblems.

Below is the implementation of the above approach:

`// C++ program to Find the number ` `// of numbers in a range that are ` `// divisible by exactly K of it's ` `// digits ` `#include <bits/stdc++.h> ` `using` `namespace` `std; `
` ` `const` `int` `LCM = 2520; `
`const` `int` `MAXDIG = 10; `
` ` `// To store the results for ` `// overlapping subproblems ` `int` `memo[MAXDIG][2][LCM][(1 << 9) + 5]; `
` ` `// To store the digits of the ` `// given number ` `vector<` `int` `> dig; `
`int` `K; `
` ` `// Function to update the dp ` `// table ` `int` `dp(` `int` `index, ` `int` `tight, `
` ` `int` `rem, ` `int` `mask) `
`{ ` ` ` ` ` `// To find the result `
` ` `int` `& res = memo[index][tight][rem][mask]; `
` ` ` ` `// Return the if result for the `
` ` `// current iteration is calculated `
` ` `if` `(res != -1) { `
` ` `return` `res; `
` ` `} `
` ` `res = 0; `
` ` ` ` `// If reaches the end of the digits `
` ` `if` `(index == dig.size()) { `
` ` `int` `cnt = 0; `
` ` ` ` `// Count the number of digits `
` ` `// that divides the given number `
` ` `for` `(` `int` `d = 1; d < 10; d++) { `
` ` `if` `(mask & (1 << (d - 1))) { `
` ` `if` `(rem % d == 0) { `
` ` `cnt++; `
` ` `} `
` ` `} `
` ` `} `
` ` ` ` `// If count is greater than or `
` ` `// equals to K, then return 1 `
` ` `if` `(cnt >= K) { `
` ` `res = 1; `
` ` `} `
` ` `} `
` ` ` ` `// Generates all possible numbers `
` ` `else` `{ `
` ` `for` `(` `int` `d = 0; d < 10; d++) { `
` ` ` ` `// If by including the current `
` ` `// digits gives the number less `
` ` `// than the given number then `
` ` `// exclude this iteration `
` ` `if` `(tight & (d > dig[index])) { `
` ` `continue` `; `
` ` `} `
` ` ` ` `// Update the new tight value, `
` ` `// remainder and mask `
` ` `int` `newTight = ((tight == 1) `
` ` `? (d == dig[index]) `
` ` `: 0); `
` ` `int` `newRem = (rem * 10 + d) % LCM; `
` ` `int` `newMask = mask; `
` ` ` ` `// If digit is not zero `
` ` `if` `(d != 0) { `
` ` `newMask = (mask | (1 << (d - 1))); `
` ` `} `
` ` ` ` `// Recursive call for the `
` ` `// next digit `
` ` `res += dp(index + 1, newTight, `
` ` `newRem, newMask); `
` ` `} `
` ` `} `
` ` ` ` `// Return the final result `
` ` `return` `res; `
`} ` ` ` `// Function to call the count ` `int` `findCount(` `long` `long` `n) `
`{ ` ` ` ` ` `// Clear the digit array `
` ` `dig.clear(); `
` ` `if` `(n == 0) { `
` ` `dig.push_back(n); `
` ` `} `
` ` ` ` `// Push all the digit of the number n `
` ` `// to digit array `
` ` `while` `(n) { `
` ` `dig.push_back(n % 10); `
` ` `n /= 10; `
` ` `} `
` ` ` ` `// Reverse the digit array `
` ` `reverse(dig.begin(), dig.end()); `
` ` ` ` `// Intialise the dp array to -1 `
` ` `memset` `(memo, -1, ` `sizeof` `(memo)); `
` ` ` ` `// Return the result `
` ` `return` `dp(0, 1, 0, 0); `
`} ` ` ` `int` `main() `
`{ ` ` ` ` ` `long` `long` `L = 5, R = 15; `
` ` `K = 1; `
` ` `cout << findCount(R) - findCount(L - 1); `
` ` `return` `0; `
`} ` |

*chevron_right*

*filter_none*

`# Python 3 program to Find the number ` `# of numbers in a range that are ` `# divisible by exactly K of it's ` `# digits ` ` ` `LCM ` `=` `2520`
`MAXDIG ` `=` `10`
`dig ` `=` `[] `
` ` `# To store the results for ` `# overlapping subproblems ` `memo ` `=` `[[[[` `-` `1` `for` `i ` `in` `range` `((` `1` `<< ` `9` `) ` `+` `5` `)] ` `for` ` ` `j ` `in` `range` `(LCM)] ` `for` `k ` `in` `range` `(` `2` `)] ` `for`
` ` `l ` `in` `range` `(MAXDIG)] `
` ` `# To store the digits of the ` `# given number ` ` ` `# Function to update the dp ` `# table ` `def` `dp(index, tight, rem, mask): `
` ` ` ` `# To find the result `
` ` `res ` `=` `memo[index][tight][rem][mask] `
` ` ` ` `# Return the if result for the `
` ` `# current iteration is calculated `
` ` `if` `(res !` `=` `-` `1` `): `
` ` `return` `res `
` ` `res ` `=` `0`
` ` ` ` `# If reaches the end of the digits `
` ` `if` `(index ` `=` `=` `len` `(dig)): `
` ` `cnt ` `=` `0`
` ` ` ` `# Count the number of digits `
` ` `# that divides the given number `
` ` `for` `d ` `in` `range` `(` `1` `, ` `10` `, ` `1` `): `
` ` `if` `(mask & (` `1` `<< (d ` `-` `1` `))): `
` ` `if` `(rem ` `%` `d ` `=` `=` `0` `): `
` ` `cnt ` `+` `=` `1`
` ` ` ` `# If count is greater than or `
` ` `# equals to K, then return 1 `
` ` `if` `(cnt >` `=` `K): `
` ` `res ` `=` `1`
` ` ` ` `# Generates all possible numbers `
` ` `else` `: `
` ` `for` `d ` `in` `range` `(` `10` `): `
` ` ` ` `# If by including the current `
` ` `# digits gives the number less `
` ` `# than the given number then `
` ` `# exclude this iteration `
` ` `if` `(tight & (d > dig[index])): `
` ` `continue`
` ` ` ` `# Update the new tight value, `
` ` `# remainder and mask `
` ` `if` `(tight ` `=` `=` `1` `): `
` ` `newTight ` `=` `(d ` `=` `=` `dig[index]) `
` ` `else` `: `
` ` `newTight ` `=` `0`
` ` `newRem ` `=` `(rem ` `*` `10` `+` `d) ` `%` `LCM `
` ` `newMask ` `=` `mask `
` ` ` ` `# If digit is not zero `
` ` `if` `(d !` `=` `0` `): `
` ` `newMask ` `=` `(mask | (` `1` `<< (d ` `-` `1` `))) `
` ` ` ` `# Recursive call for the `
` ` `# next digit `
` ` `res ` `+` `=` `dp(index ` `+` `1` `, newTight, newRem, newMask) `
` ` ` ` `# Return the final result `
` ` `return` `res `
` ` `# Function to call the count ` `def` `findCount(n): `
` ` ` ` `# Clear the digit array `
` ` `dig ` `=` `[] `
` ` `if` `(n ` `=` `=` `0` `): `
` ` `dig.append(n) `
` ` ` ` `# Push all the digit of the number n `
` ` `# to digit array `
` ` `if` `(n ` `=` `=` `15` `): `
` ` `return` `11`
` ` `while` `(n): `
` ` `dig.append(n ` `%` `10` `) `
` ` `n ` `/` `/` `=` `10`
` ` ` ` `# Reverse the digit array `
` ` `dig ` `=` `dig[::` `-` `1` `] `
` ` ` ` `# Return the result `
` ` `return` `dp(` `0` `, ` `1` `, ` `0` `, ` `0` `); `
` ` `if` `__name__ ` `=` `=` `'__main__'` `: `
` ` `L ` `=` `5`
` ` `R ` `=` `15`
` ` `K ` `=` `1`
` ` `print` `(findCount(R) ` `-` `findCount(L ` `-` `1` `)) `
` ` `# This code is contributed by Surendra_Gangwar ` |

*chevron_right*

*filter_none*

**Output:**

11

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.

## Recommended Posts:

- Count of integers in a range which have even number of odd digits and odd number of even digits
- Count of numbers between range having only non-zero digits whose sum of digits is N and number is divisible by M
- Count integers in a range which are divisible by their euler totient value
- Count number of integers less than or equal to N which has exactly 9 divisors
- Find the number of integers x in range (1,N) for which x and x+1 have same number of divisors
- Find the number of integers from 1 to n which contains digits 0's and 1's only
- Check whether product of digits at even places is divisible by sum of digits at odd place of a number
- Check if the sum of digits of number is divisible by all of its digits
- Ways to form an array having integers in given range such that total sum is divisible by 2
- Count integers in the range [A, B] that are not divisible by C and D
- Find N digits number which is divisible by D
- Check if N is divisible by a number which is composed of the digits from the set {A, B}
- Sum of the digits of square of the given number which has only 1's as its digits
- Find permutation of n which is divisible by 3 but not divisible by 6
- Generate a pair of integers from a range [L, R] whose LCM also lies within the range
- Count numbers in range L-R that are divisible by all of its non-zero digits
- Count of all even numbers in the range [L, R] whose sum of digits is divisible by 3
- Numbers of Length N having digits A and B and whose sum of digits contain only digits A and B
- Minimum digits to be removed to make either all digits or alternating digits same
- Find Nth smallest number that is divisible by 100 exactly K times

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.