C++ 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:

C++

// C++ Program to calculate range sum 
// queries for anticlockwise 
// rotations of array by K 

#include <bits/stdc++.h> 

using namespace std; 

// Function to execute the queries 

void rotatedSumQuery( 

    int arr[], int n, 

    vector<vector<int> >& query, 

    int Q) 
{ 

    // Construct a new array 

    // of size 2*N to store 

    // prefix sum of every index 

    int prefix[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 

                cout << prefix[start + R] << endl; 

            else

                // Subtract sum upto start + L - 1 

                // from sum upto start + R 

                cout << prefix[start + R] 

                            - prefix[start + L - 1] 

                     << endl; 

        } 

    } 
} 

// Driver code 

int main() 
{ 

    int arr[] = { 1, 2, 3, 4, 5, 6 }; 

    // Number of query 

    int Q = 5; 

    // Store all the queries 

    vector<vector<int> > query 

        = { { 2, 1, 3 }, 

            { 1, 3 }, 

            { 2, 0, 3 }, 

            { 1, 4 }, 

            { 2, 3, 5 } }; 

    int n = sizeof(arr) / sizeof(arr[0]); 

    rotatedSumQuery(arr, n, query, Q); 

    return 0; 
}