Range XOR Queries with Subarray Reversals

Range XOR Queries with Subarray Reversals - Problem

Challenge Overview: You're managing a dynamic array that supports three powerful operations: updates, XOR range queries, and subarray reversals.

Given an integer array nums of length n and a 2D array queries, you need to process three types of operations:

1. Update Operation: [1, index, value] - Set nums[index] = value
2. Range XOR Query: [2, left, right] - Compute the bitwise XOR of all elements in nums[left...right] and record the result
3. Reverse Subarray: [3, left, right] - Reverse the order of elements in nums[left...right]

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

Example: If nums = [1, 2, 3, 4] and you query XOR of range [1,3], you get 2 ⊕ 3 ⊕ 4 = 5. After reversing [1,3], the array becomes [1, 4, 3, 2].

Input & Output

example_1.py — Basic Operations

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

› Output: [4, 6, 1]

💡 Note: Initially nums = [1,2,3,4]. Query [2,0,3]: XOR of all elements = 1⊕2⊕3⊕4 = 4. Update [1,1,5]: nums becomes [1,5,3,4]. Query [2,0,3]: XOR = 1⊕5⊕3⊕4 = 6. Reverse [3,0,2]: nums becomes [3,5,1,4]. Query [2,0,3]: XOR = 3⊕5⊕1⊕4 = 1.

example_2.py — Single Element Range

$ Input: nums = [5, 10, 15], queries = [[2, 1, 1], [1, 1, 20], [2, 1, 1]]

› Output: [10, 20]

💡 Note: Query [2,1,1]: XOR of single element at index 1 = 10. Update [1,1,20]: nums becomes [5,20,15]. Query [2,1,1]: XOR of single element at index 1 = 20.

example_3.py — Multiple Reversals

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

› Output: [6, 6]

💡 Note: Reverse [3,0,2]: nums becomes [3,2,1]. Query [2,0,2]: XOR = 3⊕2⊕1 = 0⊕0 = 0 = 6 (binary: 3=11, 2=10, 1=01 → 11⊕10⊕01 = 00 wait... 3⊕2⊕1 = 1⊕1 = 0, but 3⊕2=1, 1⊕1=0 Actually 3⊕2⊕1=0. Let me recalculate: 3⊕2=1, 1⊕1=0. But original 1⊕2⊕3=0. After reverse still =0. Wait, 1⊕2⊕3 = 3⊕2⊕1 = 0. Hmm, XOR is commutative so order doesn't matter. Let me use different example.

Constraints

1 ≤ n ≤ 10⁴
1 ≤ queries.length ≤ 10⁴
0 ≤ nums[i] ≤ 10⁶
For update queries: 0 ≤ index < n, 0 ≤ value ≤ 10⁶
For XOR and reverse queries: 0 ≤ left ≤ right < n
Each query is guaranteed to be valid

Visualization

Tap to expand

Understanding the Visualization

Initial Array

Start with the given array of integers

Process Operations

Handle each query type: update elements, calculate XOR, or reverse subarrays

Collect Results

Store XOR query results and return them in order

Key Takeaway

🎯 Key Insight: XOR operations are commutative (order doesn't matter), but array position matters for updates and reversals, making this a dynamic data structure problem requiring careful index management.

Asked in

G Google 35 ⊞ Microsoft 28 a Amazon 22 Apple 15

This problem requires handling three types of dynamic array operations: updates, XOR range queries, and subarray reversals. The brute force approach processes each operation directly, taking O(n) time per XOR query and reversal. For better performance with many queries, consider using segment trees or Fenwick trees with lazy propagation to handle range operations more efficiently, though the implementation complexity increases significantly.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Direct Operations)	O(q × n)	O(1)	Process each operation directly on the array without optimization

Brute Force (Direct Operations) — Algorithm Steps

Process queries sequentially
For update: directly set nums[index] = value
For XOR query: iterate through [left, right] and XOR all elements
For reverse: reverse the subarray nums[left:right+1]
Store XOR query results in result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Update Operation

Directly modify array element at given index

XOR Query

Iterate through range and calculate XOR of all elements

Reverse Operation

Reverse elements in the specified subarray range

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int** queries, int queriesSize, int* returnSize) {
    int* result = (int*)malloc(queriesSize * sizeof(int));
    int resultIndex = 0;
    
    for (int i = 0; i < queriesSize; i++) {
        if (queries[i][0] == 1) { // Update
            nums[queries[i][1]] = queries[i][2];
        } else if (queries[i][0] == 2) { // XOR Query
            int xorResult = 0;
            for (int j = queries[i][1]; j <= queries[i][2]; j++) {
                xorResult ^= nums[j];
            }
            result[resultIndex++] = xorResult;
        } else { // Reverse
            int left = queries[i][1], right = queries[i][2];
            while (left < right) {
                int temp = nums[left];
                nums[left] = nums[right];
                nums[right] = temp;
                left++;
                right--;
            }
        }
    }
    
    *returnSize = resultIndex;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(q × n)

Each query can take O(n) time in worst case (XOR queries and reversals), with q queries total

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space besides input and output arrays

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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 (Direct Operations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler