 GeeksforGeeks App
Open App Browser
Continue

# Count of Array elements in given range with remainder X when divided by K for Q queries

Given an array arr[] of size N, an integer K and Q queries, each of form {x, l, r}. For each query, the task is to find the count of all elements in index range [l, r] which have remainder x when divided by K.

Examples:

Input: arr[] = {15, 28, 72, 43, 20, 0, 97}, K = 5, queries[] = {{3, 0, 3}, {0, 0, 6}, {6, 2, 4}}
Output: 2, 3, 0
Explanation: For the first query, there are 2 elements in the range [0, 3] whose remainder is 3 (28, 43).
Similarly 3 elements in range [0, 6] whose remainder is 0 (15, 20, 0).
In the third query, elements whose remainder are 6 should be found.
But for the given K = 5 possible remainders are only [0, 4]. So for any x >= K, answer will be 0.

Input: arr[] = {2, 4, 6, 7, 5}, K = 3, queries[] = {{2, 1, 4}}
Output: 1

Method 1: A simple approach is, for each query, iterate through l to r and count all elements whose remainder is x

Algorithm:

1. For each query in the vector, extract the values of x, l and r from the query.
2. Call the function ‘countRemainder‘ with the given parameters.
3. Print the count returned by the function.
4. In the function ‘countRemainder‘, initialize count as 0.
5. For each index i in range l to r:
•  Check if the remainder of arr[i] when divided by K is equal to x.
•  If true, increment count.
•  Return the count.

Below is the implementation of the approach:

## C++

 `// C++ code for the approach` `#include ``#include ``using` `namespace` `std;` `// Function to count elements in range [l, r] with remainder``// x when divided by K``int` `countRemainder(``int` `arr[], ``int` `n, ``int` `K, ``int` `x, ``int` `l,``                   ``int` `r) {``    ``int` `count = 0;``    ``for` `(``int` `i = l; i <= r; i++) {``        ``// Check if remainder is x``        ``// when divided by K``        ``if` `(arr[i] % K == x) {``            ``// Increment count if condition is true``            ``count++;``        ``}``    ``}` `    ``// Return the count``    ``return` `count;``}` `// Driver's code``int` `main() {``      ``// Input array, K and Queries``    ``int` `arr[] = { 15, 28, 72, 43, 20, 0, 97 };` `    ``int` `K = 5;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``vector > queries{ { 3, 0, 3 },``                                  ``{ 0, 0, 6 },``                                  ``{ 6, 2, 4 } };``      ` `      ` `      ``for``( ``int` `i = 0; i < queries.size(); i++) {``        ``int` `x = queries[i];``          ``int` `l = queries[i];``          ``int` `r = queries[i]; ``          ` `          ``// Function call``        ``int` `count = countRemainder(arr, N, K, x, l, r);``        ``cout << count << ``" "``;``    ``}` `    ``return` `0;``}`

## Java

 `// Java code for the approach``import` `java.util.*;` `public` `class` `Main``{``  ` `    ``// Function to count elements in range [l, r] with remainder``    ``// x when divided by K``    ``static` `int` `countRemainder(``int``[] arr, ``int` `n, ``int` `K, ``int` `x, ``int` `l, ``int` `r) {``        ``int` `count = ``0``;``        ``for` `(``int` `i = l; i <= r; i++)``        ``{``          ` `            ``// Check if remainder is x when divided by K``            ``if` `(arr[i] % K == x)``            ``{``              ` `                ``// Increment count if condition is true``                ``count++;``            ``}``        ``}``        ``// Return the count``        ``return` `count;``    ``}``    ` `    ``// Driver's code``    ``public` `static` `void` `main(String[] args)``    ``{``      ` `        ``// Input array, K and Queries``        ``int``[] arr = { ``15``, ``28``, ``72``, ``43``, ``20``, ``0``, ``97` `};``        ``int` `K = ``5``;``        ``int` `N = arr.length;``        ``List> queries = ``new` `ArrayList<>();``        ``queries.add(Arrays.asList(``3``, ``0``, ``3``));``        ``queries.add(Arrays.asList(``0``, ``0``, ``6``));``        ``queries.add(Arrays.asList(``6``, ``2``, ``4``));``        ` `        ``for` `(List query : queries) {``            ``int` `x = query.get(``0``);``            ``int` `l = query.get(``1``);``            ``int` `r = query.get(``2``);``            ` `            ``// Function call``            ``int` `count = countRemainder(arr, N, K, x, l, r);``            ``System.out.print(count + ``" "``);``        ``}``    ``}``}` `// This code is contributed by Vaibhav`

Output

`2 3 0 `

Time Complexity: O(N * Q)
Auxiliary Space: O(1)

Method 2: This problem can also be solved with help of precalculation based on the following idea:

Precalculate what will be the remainder, when arr[i] is divided by K and store them in a matrix (say mat[]) where mat[i][j] represents the remainder of arr[j] is i when divided by K.
Now prefix sum of ith row of the matrix gives the count of elements which will have remainder i when divided by K. Therefore, after prefix sum mat[i][j] will represent total count of elements till jth index having remainder i when divided by K.
So for a query {x, l, r} the answer will be (mat[x][r] – mat[x][l] [+1 if arr[l]%K is x])

Follow the illustration below for a better understanding of the construction of the matrix.

Illustration:

Consider arr[] = {15, 28, 72, 43, 20, 0, 97}, K = 5

Make a 2D matrix named precompute, of size (K*N), and initialize it with 0.
For the ith element, mark  precompute[arr[i]%K][i] = 1, do this for all i which states that the ith element has remainder arr[i]%K.

For the given example our precompute matrix will look like the following where row: remainder, column: index num.

Then for each row calculate prefix sum. Now matrix will look like this:

Here precompute denotes that till 6th index there are a total of 3 elements which will have remainder 3 when divided by 5.

Follow the steps mentioned below to implement the idea:

• Create the 2D array (say precompute).
• Construct the array as mentioned above.
• Traverse the queries:
• For each query calculate the number of elements as per the formula shown above and store that in the answer array.
• Return the array having the answers.

Note: This method is more efficient only when the number of queries is greater than K.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;``const` `int` `MXN = 2e5;``int` `precompute[MXN];` `// To precompute count prefix sum of all``// possible remainders``void` `precomputation(``int` `arr[], ``int` `n, ``int` `k)``{``    ``// Mark cell whose remainder is arr[i]%k``    ``for` `(``int` `i = 0; i < n; i++)``        ``precompute[arr[i] % k][i] = 1;` `    ``// Take prefix sum for all rows``    ``for` `(``int` `i = 0; i < k; i++) {``        ``for` `(``int` `j = 1; j < n; j++) {``            ``precompute[i][j]``                ``+= precompute[i][j - 1];``        ``}``    ``}``}` `// Function to find the``// count of numbers for the queries``vector<``int``> findCount(``int` `arr[], ``int` `K, ``int` `N,``                      ``vector >& queries)``{``    ``vector<``int``> res;` `    ``// Initialise matrix with 0``    ``memset``(precompute, 0, ``sizeof` `precompute);` `    ``// To calculate count of remainders``    ``precomputation(arr, N, K);``    ``for` `(``int` `i = 0; i < queries.size(); i++) {``        ``int` `x = queries[i];``        ``int` `l = queries[i];``        ``int` `r = queries[i];``        ``if` `(x >= K) {``            ``res.push_back(0);``            ``continue``;``        ``}``        ``int` `count = precompute[x][r]``                    ``- precompute[x][l]``                    ``+ (arr[l] % K == x);``        ``res.push_back(count);``    ``}``    ``return` `res;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 15, 28, 72, 43, 20, 0, 97 };` `    ``int` `K = 5;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``vector > queries{ { 3, 0, 3 },``                                  ``{ 0, 0, 6 },``                                  ``{ 6, 2, 4 } };` `    ``vector<``int``> ans``        ``= findCount(arr, K, N, queries);``    ``for` `(``int` `x : ans)``        ``cout << x << ``" "``;``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.ArrayList;` `class` `GFG {` `  ``static` `int` `MXN = ``200000``;``  ``static` `int``[][] precompute = ``new` `int``[``100``][MXN];` `  ``// To precompute count prefix sum of all``  ``// possible remainders``  ``static` `void` `precomputation(``int``[] arr, ``int` `n, ``int` `k)``  ``{``    ` `    ``// Mark cell whose remainder is arr[i]%k``    ``for` `(``int` `i = ``0``; i < n; i++)``      ``precompute[arr[i] % k][i] = ``1``;` `    ``// Take prefix sum for all rows``    ``for` `(``int` `i = ``0``; i < k; i++) {``      ``for` `(``int` `j = ``1``; j < n; j++) {``        ``precompute[i][j] += precompute[i][j - ``1``];``      ``}``    ``}``  ``}` `  ``// Function to find the``  ``// count of numbers for the queries``  ``static` `ArrayList``    ``findCount(``int``[] arr, ``int` `K, ``int` `N, ``int``[][] queries)``  ``{``    ``ArrayList res = ``new` `ArrayList();` `    ``// Initialise matrix with 0``    ``for` `(``int` `i = ``0``; i < ``100``; i++) {``      ``for` `(``int` `j = ``0``; j < MXN; j++)``        ``precompute[i][j] = ``0``;``    ``}` `    ``// To calculate count of remainders``    ``precomputation(arr, N, K);` `    ``for` `(``int` `i = ``0``; i < queries.length; i++) {``      ``int` `x = queries[i][``0``];``      ``int` `l = queries[i][``1``];``      ``int` `r = queries[i][``2``];``      ``if` `(x >= K) {``        ``res.add(``0``);``        ``continue``;``      ``}``      ``int` `count = precompute[x][r] - precompute[x][l]``        ``+ ((arr[l] % K == x) ? ``1` `: ``0``);``      ``res.add(count);``    ``}``    ``return` `res;``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `arr[] = { ``15``, ``28``, ``72``, ``43``, ``20``, ``0``, ``97` `};` `    ``int` `K = ``5``;``    ``int` `N = arr.length;``    ``int``[][] queries``      ``= { { ``3``, ``0``, ``3` `}, { ``0``, ``0``, ``6` `}, { ``6``, ``2``, ``4` `} };` `    ``ArrayList ans``      ``= findCount(arr, K, N, queries);``    ``for` `(``int` `i = ``0``; i < ans.size(); i++)``      ``System.out.print(ans.get(i) + ``" "``);``  ``}``}` `// This code is contributed by phasing17`

## Python3

 `# python3 program for the above approach``MXN ``=` `int``(``2e5``)``precompute ``=` `[[``0` `for` `_ ``in` `range``(MXN)] ``for` `_ ``in` `range``(``100``)]` `# To precompute count prefix sum of all``# possible remainders``def` `precomputation(arr, n, k):``    ``global` `precompute``    ``# Mark cell whose remainder is arr[i]%k``    ``for` `i ``in` `range``(``0``, n):``        ``precompute[arr[i] ``%` `k][i] ``=` `1` `        ``# Take prefix sum for all rows``    ``for` `i ``in` `range``(``0``, k):``        ``for` `j ``in` `range``(``1``, n):``            ``precompute[i][j] ``+``=` `precompute[i][j ``-` `1``]` `# Function to find the``# count of numbers for the queries``def` `findCount(arr, K, N, queries):``    ``global` `precompute``    ``res ``=` `[]` `    ``# Initialise matrix with 0` `    ``# To calculate count of remainders``    ``precomputation(arr, N, K)``    ``for` `i ``in` `range``(``0``, ``len``(queries)):``        ``x ``=` `queries[i][``0``]``        ``l ``=` `queries[i][``1``]``        ``r ``=` `queries[i][``2``]``        ``if` `(x >``=` `K):``            ``res.append(``0``)``            ``continue` `        ``count ``=` `precompute[x][r] ``-` `precompute[x][l] ``+` `(arr[l] ``%` `K ``=``=` `x)``        ``res.append(count)` `    ``return` `res` `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``15``, ``28``, ``72``, ``43``, ``20``, ``0``, ``97``]` `    ``K ``=` `5``    ``N ``=` `len``(arr)``    ``queries ``=` `[[``3``, ``0``, ``3``],``               ``[``0``, ``0``, ``6``],``               ``[``6``, ``2``, ``4``]]` `    ``ans ``=` `findCount(arr, K, N, queries)``    ``for` `x ``in` `ans:``        ``print``(x, end``=``" "``)` `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# code for the above discussed approach``using` `System;``using` `System.Collections;` `public` `class` `GFG {``  ``static` `int` `MXN = 200000;``  ``static` `int``[, ] precompute = ``new` `int``[100, MXN];` `  ``// To precompute count prefix sum of all``  ``// possible remainders``  ``static` `void` `precomputation(``int``[] arr, ``int` `n, ``int` `k)``  ``{``    ``// Mark cell whose remainder is arr[i]%k``    ``for` `(``int` `i = 0; i < n; i++)``      ``precompute[arr[i] % k, i] = 1;` `    ``// Take prefix sum for all rows``    ``for` `(``int` `i = 0; i < k; i++) {``      ``for` `(``int` `j = 1; j < n; j++) {``        ``precompute[i, j] += precompute[i, j - 1];``      ``}``    ``}``  ``}` `  ``// Function to find the``  ``// count of numbers for the queries``  ``static` `ArrayList findCount(``int``[] arr, ``int` `K, ``int` `N,``                             ``int``[, ] queries)``  ``{``    ``var` `res = ``new` `ArrayList();` `    ``// Initialise matrix with 0``    ``for` `(``int` `i = 0; i < 100; i++) {``      ``for` `(``int` `j = 0; j < MXN; j++)``        ``precompute[i, j] = 0;``    ``}` `    ``// To calculate count of remainders``    ``precomputation(arr, N, K);` `    ``for` `(``int` `i = 0; i < queries.GetLength(0); i++) {``      ``int` `x = queries[i, 0];``      ``int` `l = queries[i, 1];``      ``int` `r = queries[i, 2];``      ``if` `(x >= K) {``        ``res.Add(0);``        ``continue``;``      ``}``      ``int` `count = precompute[x, r] - precompute[x, l]``        ``+ ((arr[l] % K == x) ? 1 : 0);``      ``res.Add(count);``    ``}``    ``return` `res;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int``[] arr = { 15, 28, 72, 43, 20, 0, 97 };` `    ``int` `K = 5;``    ``int` `N = arr.Length;``    ``int``[, ] queries``      ``= { { 3, 0, 3 }, { 0, 0, 6 }, { 6, 2, 4 } };` `    ``ArrayList ans = findCount(arr, K, N, queries);``    ``for` `(``int` `i = 0; i < ans.Count; i++)``      ``Console.Write(ans[i] + ``" "``);``  ``}``}` `// This code is contributed by phasing17`

## Javascript

 ``

Output

`2 3 0 `

Time Complexity: O(Q + K*N)
Auxiliary Space: O(K*N)

My Personal Notes arrow_drop_up