# Maximum count of values of S modulo M lying in a range [L, R] after performing given operations on the array

Given an array **arr[]** of **N** integers along with integers **M, L, R**. Consider a variable **S**(initially **0**). The task is to find the maximum count of values of **S % M** that lies in the range **[L, R]** after performing the following operations for each element in the given array:

- Add
**arr[i]**or**arr[i] – 1**to**S**. - Change
**S to S % M**.

**Examples:**

Input:arr[] = {17, 11, 10, 8, 15}, M = 22, L = 14, R = 16Output:3Explanation:Initially S = 0,Step 1: Choose, arr[0] – 1 = 16 and add it to S = 16 and S%M = 16. Therefore, count = 1Step 2: Choose, arr[1] = 11 and add it to S = 16 + 11 = 27 and S%M = 5. Therefore, count = 1Step 3: Choose, arr[2] = 10 and add it to S = 16 + 10 +11 = 37 and S%M = 15. Therefore, count = 2Step 4: Choose, arr[3] = 8 and add it to S = 16 + 10 + 11 + 8 = 45 and S%M = 1. Therefore, count = 2Step 5: Choose, arr[4] = 15 and add it to S = 16 + 10 + 11 + 8 + 15 = 60 and S%M = 16. Therefore, count = 3.Hence the maximum count is 3.

Input:arr[] = {23, 1}, M = 24, L = 21, R = 23Output:2

**Naive Approach: **The simplest approach is to traverse the given array **arr[]** and add **arr[i]** or **arr[i – 1]** to the given **S** and check if **S%M** lies in the range **[L, R]** or not. Since there are two possibilities to choose the given numbers. Therefore, use recursion to recursively get the maximum count of values of **S%M** lies in the range **[L, R]**.

**Time Complexity: **O(2^{N})**Auxiliary Space:** O(N)

**Efficient Approach:** To optimize the above approach the idea is to use Dynamic Programming to store the overlapping subproblems and then find the maximum count of S%M lies in the range **[L, R]**. Follow the steps below to solve the problem:

- Initialize a unordered_map
**dp**to store the values of states that have overlapping subproblems. - Initialize the sum to be
**0**, and then recursively add**arr[i] or arr[i] – 1**value to the sum**S**. - At every step, check whether the
**S%M**lies in the range**[L, R]**or not. If it lies in the range then count that value and update this current state in the above map**dp**as 1. Else update as**0**. - After looking out for all possible combinations, return the count of values of
**S%M**that lies in the range**[L, R]**.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` ` ` `#include <bits/stdc++.h>` `using` `namespace` `std;` ` ` `// Lookup table` `map<pair<` `int` `, ` `int` `>, ` `int` `> dp;` ` ` `// Function to count the value of S` `// after adding arr[i] or arr[i - 1]` `// to the sum S at each time` `int` `countMagicNumbers(` `int` `idx, ` `int` `sum,` ` ` `int` `a[], ` `int` `n,` ` ` `int` `m, ` `int` `l, ` `int` `r)` `{` ` ` `// Base Case` ` ` `if` `(idx == n) {` ` ` ` ` `// Store the mod value` ` ` `int` `temp = sum % m;` ` ` ` ` `// If the mod value lies in` ` ` `// the range then return 1` ` ` `if` `(temp == l || temp == r` ` ` `|| (temp > l && temp < r))` ` ` `return` `dp[{ idx, sum }] = 1;` ` ` ` ` `// Else return 0` ` ` `else` ` ` `return` `dp[{ idx, sum }] = 0;` ` ` `}` ` ` ` ` `// Store the current state` ` ` `pair<` `int` `, ` `int` `> curr` ` ` `= make_pair(idx, sum);` ` ` ` ` `// If already computed, return the` ` ` `// computed value` ` ` `if` `(dp.find(curr) != dp.end())` ` ` `return` `dp[curr];` ` ` ` ` `// Recursively adding the elements` ` ` `// to the sum adding ai value` ` ` `int` `ls = countMagicNumbers(idx + 1,` ` ` `sum + a[idx],` ` ` `a, n,` ` ` `m, l, r);` ` ` ` ` `// Adding arr[i] - 1 value` ` ` `int` `rs = countMagicNumbers(idx + 1,` ` ` `sum + (a[idx] - 1),` ` ` `a, n, m, l, r);` ` ` ` ` `// Return the maximum count to` ` ` `// check for root value as well` ` ` `int` `temp1 = max(ls, rs);` ` ` `int` `temp = sum % m;` ` ` ` ` `// Avoid counting idx = 0 as possible` ` ` `// solution we are using idx != 0` ` ` `if` `((temp == l || temp == r` ` ` `|| (temp > l && temp < r))` ` ` `&& idx != 0) {` ` ` `temp1 += 1;` ` ` `}` ` ` ` ` `// Return the value of current state` ` ` `return` `dp[{ idx, sum }] = temp1;` `}` ` ` `// Driver Code` `int` `main()` `{` ` ` `int` `N = 5, M = 22, L = 14, R = 16;` ` ` `int` `arr[] = { 17, 11, 10, 8, 15 };` ` ` ` ` `cout << countMagicNumbers(0, 0, arr,` ` ` `N, M, L, R);` ` ` ` ` `return` `0;` `}` |

## Python3

`# Python3 program for the above approach` ` ` `# Lookup table` `dp ` `=` `{}` ` ` `# Function to count the value of S` `# after adding arr[i] or arr[i - 1]` `# to the sum S at each time` `def` `countMagicNumbers(idx, ` `sum` `, a, n, m, l, r):` ` ` ` ` `# Base Case` ` ` `if` `(idx ` `=` `=` `n):` ` ` ` ` `# Store the mod value` ` ` `temp ` `=` `sum` `%` `m` ` ` ` ` `# If the mod value lies in` ` ` `# the range then return 1` ` ` `if` `(temp ` `=` `=` `l ` `or` `temp ` `=` `=` `r ` `or` ` ` `(temp > l ` `and` `temp < r)):` ` ` `dp[(idx, ` `sum` `)] ` `=` `1` ` ` `return` `dp[(idx, ` `sum` `)]` ` ` ` ` `# Else return 0` ` ` `else` `:` ` ` `dp[(idx, ` `sum` `)] ` `=` `0` ` ` `return` `dp[(idx, ` `sum` `)]` ` ` ` ` `# Store the current state` ` ` `curr ` `=` `(idx, ` `sum` `)` ` ` ` ` `# If already computed, return the` ` ` `# computed value` ` ` `if` `(curr ` `in` `dp):` ` ` `return` `dp[curr]` ` ` ` ` `# Recursively adding the elements` ` ` `# to the sum adding ai value` ` ` `ls ` `=` `countMagicNumbers(idx ` `+` `1` `,` ` ` `sum` `+` `a[idx],` ` ` `a, n, m, l, r)` ` ` ` ` `# Adding arr[i] - 1 value` ` ` `rs ` `=` `countMagicNumbers(idx ` `+` `1` `,` ` ` `sum` `+` `(a[idx] ` `-` `1` `),` ` ` `a, n, m, l, r)` ` ` ` ` `# Return the maximum count to` ` ` `# check for root value as well` ` ` `temp1 ` `=` `max` `(ls, rs)` ` ` `temp ` `=` `sum` `%` `m` ` ` ` ` `# Avoid counting idx = 0 as possible` ` ` `# solution we are using idx != 0` ` ` `if` `((temp ` `=` `=` `l ` `or` `temp ` `=` `=` `r ` `or` ` ` `(temp > l ` `and` `temp < r)) ` `and` ` ` `idx !` `=` `0` `):` ` ` `temp1 ` `+` `=` `1` ` ` ` ` `# Return the value of current state` ` ` `dp[(idx, ` `sum` `)] ` `=` `temp1` ` ` `return` `dp[(idx, ` `sum` `)]` ` ` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `N ` `=` `5` ` ` `M ` `=` `22` ` ` `L ` `=` `14` ` ` `R ` `=` `16` ` ` ` ` `arr ` `=` `[ ` `17` `, ` `11` `, ` `10` `, ` `8` `, ` `15` `]` ` ` ` ` `print` `(countMagicNumbers(` `0` `, ` `0` `, arr, N, M, L, R))` ` ` `# This code is contributed by mohit kumar 29` |

**Output:**

3

* Time Complexity: O(S*N), where N is the size of the given array*,

*and S is the sum of all array elements.*

**Space Complexity:**O(S*N)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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.