Given two numbers **M, D** and an array **arr[]** which represents the range **[L, R]**, the task is to count the numbers in the range **[L, R]** which is divisible by **M** and the digit **D** occurs at every odd positions.

**Note:** The numbers might be large. So, the range array {L, R} is given in the form of a string.

**Examples:**

Input:arr[] = {20, 32}, M = 2, D = 2

Output:4

Explanation:

There are 4 numbers in the range [20, 32] which are divisible by 2 and 2 at the odd (first) position. They are:

20, 24, 26, 28.

Input:arr[] = {40, 60}, M = 2, D = 5

Output:5

Explanation:

There are 5 numbers in the range [40, 60] which are divisible by 2 and 5 at the odd (first) position. They are:

50, 52, 54, 56, 58.

**Naive Approach:** The naive approach for this problem is to take every number between **L to R** and check whether the digit **D** occurs at odd positions or not and whether the number is divisible by **M** or not. The time complexity of this solution will be O(N*K) where N is the count of numbers in the range [L, R] and K is the maximum number of digits in any number in the range [L, R].

**Efficient Approach:** The idea is to use the concept of digit-dp and find the number of combinations of the numbers that solves the problem. In order to find the count of numbers satisfying the condition, we find the count of numbers satisfying the condition up to the highest number R in the range. This includes all the 1 digit, 2 digit, 3 digit numbers. After finding this count, we simply subtract the count of numbers satisfying up to L – 1 from the above value to get the final answer.

- On assuming the numbers as a sequence of digits, we try to form an N digit number which follows the conditions at every iteration where N is the number of digits in the given upper range R. Let the count be C.
- This count C includes the 1-digit numbers, 2-digit numbers, 3-digit numbers … up to N-digit numbers where N is the number of digits in R.
- Similarly, we find the count of numbers satisfying the condition up to L – 1. Let this count be D.
- The required answer needed is the difference between both the counts
**C – D**. - The count of numbers satisfying the given condition is found out by the concept of digit dp.
- A three-dimensional table is formed and filled using this concept.

Below is the implementation of the above approach:

`// C++ program to find the count of numbers ` `// in the range [L, R] which are divisible ` `// by M and have digit D at the odd places ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` `#define ll long long int ` ` ` `// Variables to store M, N, D ` `ll m, n, d; ` ` ` `// Vector to store the digit number ` `// in the form of digits ` `vector<` `int` `> v; ` `ll ` `const` `k = 1e9 + 7; ` ` ` `// Dp table to compute the answer ` `ll dp[2001][2001][2]; ` ` ` `// Function to add the individual ` `// digits into the vector ` `void` `init(string s) ` `{ ` ` ` `memset` `(dp, -1, ` `sizeof` `(dp)); ` ` ` `v.clear(); ` ` ` ` ` `// Iterating through the number ` ` ` `// and adding the digits into ` ` ` `// the vector ` ` ` `for` `(` `int` `i = 0; i < s.size(); i++) { ` ` ` `v.push_back(s[i] - ` `'0'` `); ` ` ` `} ` ` ` `n = s.size(); ` `} ` ` ` `// Function to subtract 1 from a number ` `// represented in a form of a string ` `string number_minus_one(string a) ` `{ ` ` ` `string s = a.substr(1); ` ` ` `string s1 = ` `""` `; ` ` ` ` ` `// Iterating through the number ` ` ` `for` `(` `int` `i = 0; i < s.size() - 1; i++) ` ` ` `s1 += ` `'0'` `; ` ` ` ` ` `// If the first digit is 1, then make it 0 ` ` ` `// and add 9 at the end of the string. ` ` ` `if` `(a[0] == 1 and s == s1) { ` ` ` `ll l = s.size(); ` ` ` `a = ` `""` `; ` ` ` `a += ` `'0'` `; ` ` ` `for` `(` `int` `i = 0; i < l; i++) ` ` ` `a += ` `'9'` `; ` ` ` `} ` ` ` `else` `{ ` ` ` `for` `(` `int` `i = a.size() - 1; i >= 0; i--) { ` ` ` ` ` `// If we need to subtract 1 from 0, ` ` ` `// then make it 9 and subtract 1 ` ` ` `// from the previous digits ` ` ` `if` `(a[i] == ` `'0'` `) ` ` ` `a[i] = ` `'9'` `; ` ` ` ` ` `// Else, simply subtract 1 ` ` ` `else` `{ ` ` ` `a[i] = (((a[i] - ` `'0'` `) - 1) + ` `'0'` `); ` ` ` `break` `; ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` `return` `a; ` `} ` ` ` `// Function to find the count of numbers ` `// in the range [L, R] which are divisible ` `// by M and have digit D at the odd places ` `ll fun(ll pos, ll sum, ll f) ` `{ ` ` ` ` ` `// Base case ` ` ` `if` `(pos == n) { ` ` ` `if` `(sum == 0) { ` ` ` ` ` `// If we have built N-digit number ` ` ` `// and the number is divisible ` ` ` `// by m then we have got ` ` ` `// one possible answer. ` ` ` `return` `1; ` ` ` `} ` ` ` `return` `0; ` ` ` `} ` ` ` ` ` `// If the answer has already been computed, ` ` ` `// then return the answer ` ` ` `if` `(dp[pos][sum][f] != -1) ` ` ` `return` `dp[pos][sum][f]; ` ` ` `ll lmt = 9; ` ` ` ` ` `// The possible digits which we can ` ` ` `// place at the pos position. ` ` ` `if` `(!f) ` ` ` `lmt = v[pos]; ` ` ` ` ` `ll ans = 0; ` ` ` ` ` `// Iterating through all the digits ` ` ` `for` `(ll i = 0; i <= lmt; i++) { ` ` ` `if` `(i == d and pos % 2 == 1) ` ` ` `ans += 0; ` ` ` `else` `if` `(i != d and pos % 2 == 0) ` ` ` `ans += 0; ` ` ` `else` `{ ` ` ` `ll new_f = f; ` ` ` ` ` `// If we have placed all the digits ` ` ` `// up to pos-1 equal to their ` ` ` `// limit and currently we are placing ` ` ` `// a digit which is smaller than this ` ` ` `// position's limit then we can place ` ` ` `// 0 to 9 at all the next positions ` ` ` `// to make the number smaller than R ` ` ` `if` `(f == 0 and i < lmt) ` ` ` `new_f = 1; ` ` ` ` ` `// Calculating the number upto pos mod m. ` ` ` `ll new_sum = sum; ` ` ` ` ` `// Combinations of numbers as there are ` ` ` `// 10 digits in the range [0, 9] ` ` ` `new_sum *= 10; ` ` ` `new_sum += i; ` ` ` `new_sum %= m; ` ` ` ` ` `// Recursively call the function ` ` ` `// for the next position ` ` ` `ans += fun(pos + 1, new_sum, new_f); ` ` ` `ans %= k; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Returning the final answer ` ` ` `return` `dp[pos][sum][f] = ans; ` `} ` ` ` `// Function to call the function ` `// for every query ` `void` `operations(string L, string R) ` `{ ` ` ` `init(R); ` ` ` `ll ans = fun(0, 0, 0); ` ` ` `L = number_minus_one(L); ` ` ` `init(L); ` ` ` `ans -= fun(0, 0, 0); ` ` ` `if` `(ans < 0) ` ` ` `ans += k; ` ` ` `cout << ans << ` `"\n"` `; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `m = 2, d = 2; ` ` ` `ll Q = 1; ` ` ` `string arr[][2] = { { ` `"20"` `, ` `"32"` `} }; ` ` ` ` ` `for` `(ll i = 0; i < Q; i++) { ` ` ` `operations(arr[i][0], arr[i][1]); ` ` ` `} ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

4

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 numbers in a range with digit sum divisible by K having first and last digit different
- Count of Numbers in a Range divisible by m and having digit d in even positions
- Count of Numbers in Range where first digit is equal to last digit of the number
- Count n digit numbers divisible by given number
- Count of N digit palindromic numbers divisible by 9
- Count numbers with unit digit k in given range
- Count of numbers from the range [L, R] which contains at least one digit that divides K
- Count numbers in range 1 to N which are divisible by X but not by Y
- Count the numbers divisible by 'M' in a given range
- Count of Numbers in a Range where digit d occurs exactly K times
- 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
- Count of pairs (A, B) in range 1 to N such that last digit of A is equal to the first digit of B
- Count of numbers between range having only non-zero digits whose sum of digits is N and number is divisible by M
- Sum of n digit numbers divisible by a given number
- Smallest n digit number divisible by given three numbers
- N digit numbers divisible by 5 formed from the M digits
- Largest N digit number divisible by given three numbers
- Sum of all N-digit palindromic numbers which doesn't contains 0 and are divisible by 9
- Count of m digit integers that are divisible by an integer n

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.