Range XOR Queries with Subarray Reversals

Range XOR Queries with Subarray Reversals - Problem

You are given an integer array nums of length n and a 2D integer array queries of length q, where each query is one of the following three types:

Update: queries[i] = [1, index, value] - Set nums[index] = value.

Range XOR Query: queries[i] = [2, left, right] - Compute the bitwise XOR of all elements in the subarray nums[left...right], and record this result.

Reverse Subarray: queries[i] = [3, left, right] - Reverse the subarray nums[left...right] in place.

Return an array of the results of all range XOR queries in the order they were encountered.

Input & Output

Example 1 — Basic Mixed Operations

$ Input: nums = [1,3,4,8], queries = [[2,0,1],[1,1,5],[2,0,1],[3,0,3],[2,0,3]]

› Output: [2,4,6]

💡 Note: Query [2,0,1]: XOR of nums[0..1] = 1⊕3 = 2. Query [1,1,5]: Update nums[1] = 5. Query [2,0,1]: XOR of nums[0..1] = 1⊕5 = 4. Query [3,0,3]: Reverse nums[0..3] → [8,4,5,1]. Query [2,0,3]: XOR of nums[0..3] = 8⊕4⊕5⊕1 = 6.

Example 2 — Only XOR Queries

$ Input: nums = [2,3,4], queries = [[2,0,2],[2,1,2],[2,0,1]]

› Output: [5,7,1]

💡 Note: Query [2,0,2]: XOR of nums[0..2] = 2⊕3⊕4 = 5. Query [2,1,2]: XOR of nums[1..2] = 3⊕4 = 7. Query [2,0,1]: XOR of nums[0..1] = 2⊕3 = 1.

Example 3 — Update and Reverse

$ Input: nums = [5,6], queries = [[1,0,2],[3,0,1],[2,0,1]]

› Output: [4]

💡 Note: Query [1,0,2]: Update nums[0] = 2, so nums = [2,6]. Query [3,0,1]: Reverse nums[0..1] → [6,2]. Query [2,0,1]: XOR of nums[0..1] = 6⊕2 = 4.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁶
For update queries: 0 ≤ index < nums.length, 0 ≤ value ≤ 10⁶
For range queries: 0 ≤ left ≤ right < nums.length

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 15

The key insight is to process queries sequentially since XOR operations and array modifications don't require complex data structures for this problem. The brute force approach handles all three operation types (update, XOR range query, reverse subarray) directly on the array. Best approach is sequential processing with helper functions for better organization. Time: O(q × n), Space: O(1).

Common Approaches

✓ Brute Force Sequential Processing

⏱️ Time: O(q × n) Space: O(1)

For each query, directly perform the operation: update elements, reverse subarrays, or compute XOR by iterating through the range. This approach handles all operations straightforwardly but may be slow for large inputs.

Optimized with Helper Functions

⏱️ Time: O(q × n) Space: O(1)

Create dedicated helper functions for update, XOR range computation, and reverse operations. This approach maintains the same time complexity but improves code organization and readability while allowing for easier maintenance and potential future optimizations.

Brute Force Sequential Processing — Algorithm Steps

Iterate through each query
For type 1: update nums[index] = value
For type 2: XOR all elements from left to right
For type 3: reverse subarray from left to right

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Query

Handle each query type individually

Array Operation

Update, XOR range, or reverse as needed

Collect Results

Store XOR query results

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void reverseSubarray(int* nums, int left, int right) {
    while (left < right) {
        int temp = nums[left];
        nums[left] = nums[right];
        nums[right] = temp;
        left++;
        right--;
    }
}

static int nums[100005];
static int queries[100005][3];
static int result[100005];

int parseArray(char* line, int* arr) {
    int count = 0;
    char* ptr = line;
    
    while (*ptr) {
        if (*ptr >= '0' && *ptr <= '9') {
            arr[count++] = strtol(ptr, &ptr, 10);
        } else {
            ptr++;
        }
    }
    return count;
}

int parse2DArray(char* line, int queries[][3]) {
    int count = 0;
    char* ptr = line;
    
    while (*ptr) {
        if (*ptr == '[') {
            ptr++;
            int nums[3];
            int numCount = 0;
            
            while (*ptr && *ptr != ']' && numCount < 3) {
                if (*ptr >= '0' && *ptr <= '9') {
                    nums[numCount++] = strtol(ptr, &ptr, 10);
                } else {
                    ptr++;
                }
            }
            
            if (numCount == 3) {
                queries[count][0] = nums[0];
                queries[count][1] = nums[1];
                queries[count][2] = nums[2];
                count++;
            }
        } else {
            ptr++;
        }
    }
    return count;
}

int main() {
    char line[1000000];
    
    fgets(line, sizeof(line), stdin);
    int numsSize = parseArray(line, nums);
    
    fgets(line, sizeof(line), stdin);
    int queriesSize = parse2DArray(line, queries);
    
    int resultIndex = 0;
    
    for (int i = 0; i < queriesSize; i++) {
        if (queries[i][0] == 1) {  // Update
            int index = queries[i][1], value = queries[i][2];
            nums[index] = value;
        } else if (queries[i][0] == 2) {  // Range XOR Query
            int left = queries[i][1], right = queries[i][2];
            int xorResult = 0;
            for (int j = left; j <= right; j++) {
                xorResult ^= nums[j];
            }
            result[resultIndex++] = xorResult;
        } else if (queries[i][0] == 3) {  // Reverse Subarray
            int left = queries[i][1], right = queries[i][2];
            reverseSubarray(nums, left, right);
        }
    }
    
    printf("[");
    for (int i = 0; i < resultIndex; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(q × n)

For each of q queries, we may need to process up to n elements (XOR range or reverse)

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables, modifying input array in-place

✓ Linear Space

12.0K Views

Medium Frequency

~25 min Avg. Time

450 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Sequential Processing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler