XOR Queries of a Subarray - Practice Coding Problems

XOR Queries of a Subarray - Problem

You're given an array arr of positive integers and an array queries where each query specifies a range [left, right].

Your task: For each query, compute the XOR (exclusive OR) of all elements from index left to right (inclusive).

Example: If arr = [1, 3, 4, 8] and we want XOR from index 1 to 3, we calculate: 3 ⊕ 4 ⊕ 8 = 7

The naive approach of recalculating XOR for each query can be very slow for large inputs. Can you find a more efficient solution using the mathematical properties of XOR?

Key XOR Property: a ⊕ a = 0 and a ⊕ 0 = a

Input & Output

example_1.py — Basic Range Queries

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

› Output: [2,7,14,8]

💡 Note: Query [0,1]: 1⊕3=2, Query [1,2]: 3⊕4=7, Query [0,3]: 1⊕3⊕4⊕8=14, Query [3,3]: 8=8

example_2.py — Single Element Queries

$ Input: arr = [4,8,2,10], queries = [[2,3],[1,3],[0,0],[0,3]]

› Output: [8,0,4,4]

💡 Note: Query [2,3]: 2⊕10=8, Query [1,3]: 8⊕2⊕10=0, Query [0,0]: 4=4, Query [0,3]: 4⊕8⊕2⊕10=4

example_3.py — Edge Case - Full Array

$ Input: arr = [1], queries = [[0,0]]

› Output: [1]

💡 Note: Single element array with single element query returns the element itself

Visualization

Tap to expand

Understanding the Visualization

Problem Setup

Array [1,3,4,8] with queries asking for XOR of different ranges

Brute Force Issue

Each query requires scanning the entire range - inefficient for multiple queries

Prefix XOR Magic

Build prefix array once: [0,1,2,6,14] where prefix[i] = XOR of elements 0 to i-1

O(1) Query Resolution

Any range [L,R] = prefix[R+1] ⊕ prefix[L] due to XOR cancellation property

Key Takeaway

🎯 Key Insight: XOR's self-cancelling property (a ⊕ a = 0) enables prefix optimization, transforming O(n×q) brute force into O(n+q) efficiency by preprocessing once and answering queries instantly.

Time & Space Complexity

Time Complexity

⏱️

O(n + q)

O(n) to build prefix array + O(1) per query for q queries

✓ Linear Growth

Space Complexity

O(n)

Need extra array to store prefix XOR values

⚡ Linearithmic Space

Constraints

1 ≤ arr.length, queries.length ≤ 3 × 10⁴
1 ≤ arr[i] ≤ 10⁹
queries[i].length == 2
0 ≤ left_i ≤ right_i < arr.length

Asked in

G Google 24 a Amazon 18 f Meta 12 ⊞ Microsoft 15

The optimal solution uses the prefix XOR technique to preprocess the array once in O(n) time, then answer each query in O(1) time. This leverages XOR's mathematical property that a ⊕ a = 0, allowing us to cancel out unwanted prefixes and extract exactly the range we need.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix XOR (Optimal)	O(n + q)	O(n)	Build prefix XOR array once, then answer queries in O(1) time using XOR properties
Brute Force (Nested Loops)	O(n × q)	O(1)	For each query, iterate through the range and calculate XOR step by step

Prefix XOR (Optimal) — Algorithm Steps

Create a prefix XOR array where prefix[i] = arr[0] ⊕ arr[1] ⊕ ... ⊕ arr[i]
For each query [left, right], use the formula: prefix[right] ⊕ prefix[left-1]
Handle the edge case when left = 0 (no prefix to subtract)
Return the results for all queries

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Array

prefix[i] = XOR of all elements from 0 to i-1

Query Processing

Range XOR = prefix[right+1] ⊕ prefix[left]

Magic of XOR

Common prefix cancels out, leaving only the desired range

Code -

solution.c — C

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

int* xorQueries(int* arr, int arrSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    *returnSize = queriesSize;
    
    // Build prefix XOR array
    int* prefix = (int*)calloc(arrSize + 1, sizeof(int));
    
    for (int i = 0; i < arrSize; i++) {
        prefix[i + 1] = prefix[i] ^ arr[i];
    }
    
    int* result = (int*)malloc(queriesSize * sizeof(int));
    for (int i = 0; i < queriesSize; i++) {
        int left = queries[i][0];
        int right = queries[i][1];
        // XOR of range [left, right] = prefix[right+1] ^ prefix[left]
        result[i] = prefix[right + 1] ^ prefix[left];
    }
    
    free(prefix);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + q)

O(n) to build prefix array + O(1) per query for q queries

✓ Linear Growth

Space Complexity

O(n)

Need extra array to store prefix XOR values

⚡ Linearithmic Space

Constraints

1 ≤ arr.length, queries.length ≤ 3 × 10⁴
1 ≤ arr[i] ≤ 10⁹
queries[i].length == 2
0 ≤ left_i ≤ right_i < arr.length

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Prefix XOR (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler