GFG App
Open App
Browser
Continue

# Java Program to Find Range sum queries for anticlockwise rotations of Array by K indices

Given an array arr consisting of N elements and Q queries of the following two types:

• 1 K: For this type of query, the array needs to be rotated by K indices anticlockwise from its current state.
• 2 L R: For this query, the sum of the array elements present in the indices [L, R] needs to be calculated.

Example:

Input: arr = { 1, 2, 3, 4, 5, 6 }, query = { {2, 1, 3}, {1, 3}, {2, 0, 3}, {1, 4}, {2, 3, 5} }
Output:

16
12
Explanation:
For the 1st query {2, 1, 3} -> Sum of the elements in the indices [1, 3] = 2 + 3 + 4 = 9.
For the 2nd query {1, 3} -> Modified array after anti-clockwise rotation by 3 places is { 4, 5, 6, 1, 2, 3 }
For the 3rd query {2, 0, 3} -> Sum of the elements in the indices [0, 3] = 4 + 5 + 6 + 1 = 16.
For the 4th query {1, 4} -> Modified array after anti-clockwise rotation by 4 places is { 2, 3, 4, 5, 6, 1 }
For the 5th query {2, 3, 5} -> Sum of the elements in the indices [3, 5] = 5 + 6 + 1 = 12.

Approach:

• Create a prefix array which is double the size of the arr and copy the element at the ith index of arr to ith and N + ith index of prefix for all i in [0, N).
• Precompute the prefix sum for every index of that array and store in prefix.
• Set the pointer start at 0 to denote the starting index of the initial array.
• For query of type 1, shift start to
`((start + K) % N)th position`
• For query of type 2, calculate

```prefix[start + R]
- prefix[start + L- 1 ]```
• if start + L >= 1 then print the value of

`prefix[start + R]`

Below code is the implementation of the above approach:

## Java

 `// Java program to calculate range sum` `// queries for anticlockwise` `// rotations of array by K` `class` `GFG{`   `// Function to execute the queries` `static` `void` `rotatedSumQuery(``int` `arr[], ``int` `n,` `                            ``int` `[][]query, ``int` `Q)` `{` `    `  `    ``// Construct a new array` `    ``// of size 2*N to store` `    ``// prefix sum of every index` `    ``int` `[]prefix = ``new` `int``[``2` `* n];`   `    ``// Copy elements to the new array` `    ``for``(``int` `i = ``0``; i < n; i++)` `    ``{` `        ``prefix[i] = arr[i];` `        ``prefix[i + n] = arr[i];` `    ``}`   `    ``// Calculate the prefix sum` `    ``// for every index` `    ``for``(``int` `i = ``1``; i < ``2` `* n; i++)` `        ``prefix[i] += prefix[i - ``1``];`   `    ``// Set start pointer as 0` `    ``int` `start = ``0``;`   `    ``for``(``int` `q = ``0``; q < Q; q++)` `    ``{`   `        ``// Query to perform` `        ``// anticlockwise rotation` `        ``if` `(query[q][``0``] == ``1``)` `        ``{` `            ``int` `k = query[q][``1``];` `            ``start = (start + k) % n;` `        ``}`   `        ``// Query to answer range sum` `        ``else` `if` `(query[q][``0``] == ``2``) ` `        ``{` `            ``int` `L, R;` `            ``L = query[q][``1``];` `            ``R = query[q][``2``];`   `            ``// If pointing to 1st index` `            ``if` `(start + L == ``0``)`   `                ``// Display the sum upto start + R` `                ``System.out.print(prefix[start + R] + "` `");`   `            ``else`   `                ``// Subtract sum upto start + L - 1` `                ``// from sum upto start + R` `                ``System.out.print(prefix[start + R] -` `                                 ``prefix[start + L - ``1``] + ` `                                 ``"` `");` `        ``}` `    ``}` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `arr[] = { ``1``, ``2``, ``3``, ``4``, ``5``, ``6` `};`   `    ``// Number of query` `    ``int` `Q = ``5``;`   `    ``// Store all the queries` `    ``int` `[][]query = { { ``2``, ``1``, ``3` `},` `                      ``{ ``1``, ``3` `},` `                      ``{ ``2``, ``0``, ``3` `},` `                      ``{ ``1``, ``4` `},` `                      ``{ ``2``, ``3``, ``5` `} };`   `    ``int` `n = arr.length;` `    ``rotatedSumQuery(arr, n, query, Q);` `}` `}`   `// This code is contributed by Rohit_ranjan`

Output:

```9
16
12```

Time Complexity: O(Q), where Q is the number of queries, and as each query will cost O (1) time for Q queries time complexity would be O(Q).

Auxiliary Space: O(N), as we are using  extra space for prefix.

Please refer complete article on Range sum queries for anticlockwise rotations of Array by K indices for more details!

My Personal Notes arrow_drop_up