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:
9 
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 i^th index of arr to i^th and N + i^th 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!