Maximum XOR Score Subarray Queries - Practice Coding Problems

Maximum XOR Score Subarray Queries - Problem

Maximum XOR Score Subarray Queries

You are given an array nums of n integers and a 2D array queries where each query [li, ri] asks you to find the maximum XOR score among all subarrays within the range nums[li..ri].

The XOR score of an array is calculated through an iterative process:
1. Start with your array a
2. Create a new array by XORing adjacent elements: a[i] XOR a[i+1]
3. Remove the last element from the new array
4. Repeat until only one element remains - this is your XOR score

Example: Array [4, 2, 5] → [4⊕2, 2⊕5] = [6, 7] → [6⊕7] = [1] → Score = 1

Your task is to efficiently answer multiple queries, each asking for the maximum XOR score among all possible subarrays in a given range.

Input & Output

example_1.py — Basic XOR Score Calculation

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

› Output: [12, 44, 60]

💡 Note: For query [0,2] with subarray [2,8,4]: Round 1: [2⊕8, 8⊕4] = [10,12], Round 2: [10⊕12] = [6]. Among all subarrays in range [0,2], the maximum XOR score is 12 from subarray [8,4].

example_2.py — Single Element Query

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

› Output: [5]

💡 Note: Query [2,2] only contains one element nums[2] = 5. The XOR score of a single element is the element itself.

example_3.py — Full Array Query

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

› Output: [6]

💡 Note: For the full array [4,2]: XOR process gives [4⊕2] = [6]. Also check single elements: 4 and 2. Maximum is 6.

Constraints

1 ≤ n ≤ 2000
1 ≤ q ≤ 10⁵
1 ≤ nums[i] ≤ 2⁸
queries[i] = [l_i, r_i]
0 ≤ l_i ≤ r_i < n

Visualization

Tap to expand

Understanding the Visualization

Initial Players

Start with array elements as tournament participants

Round 1

Adjacent players compete using XOR operation

Advance Winners

Winners move to next round, losers eliminated

Final Champion

Last remaining player is the XOR score

Key Takeaway

🎯 Key Insight: The XOR elimination process creates a triangular pattern of values that can be precomputed using dynamic programming, enabling efficient query processing.

Asked in

G Google 35 f Meta 28 ⊞ Microsoft 22 a Amazon 18

The optimal approach uses dynamic programming to precompute all possible XOR scores in O(n²) time. The key insight is that the XOR elimination process follows a predictable pattern that can be stored in a triangular DP table. For each query, we find the maximum value in the relevant portion of this precomputed table, achieving efficient query processing.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n² + q*n²)	O(n²)	Precompute all possible XOR scores using 2D DP, then answer queries in O(1)

Dynamic Programming (Optimal) — Algorithm Steps

Create a 2D DP table where dp[i][j] stores XOR results
Initialize base case: dp[i][i] = nums[i] (single elements)
Fill table: dp[i][j] = dp[i][j-1] ^ dp[i+1][j] for larger subarrays
For each query, scan relevant DP entries to find maximum
Return the maximum value found in the query range

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Base

Fill diagonal with original array elements

Build DP Table

Compute XOR values for all subarrays

Query Processing

Find maximum in relevant DP region

Return Result

Output the maximum XOR score found

Code -

solution.c — C

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

int* maxXorQueries(int* nums, int numsSize, int** queries, int queriesSize, int* returnSize) {
    *returnSize = queriesSize;
    
    // Create DP table
    int** dp = malloc(numsSize * sizeof(int*));
    for (int i = 0; i < numsSize; i++) {
        dp[i] = calloc(numsSize, sizeof(int));
    }
    
    // Base case
    for (int i = 0; i < numsSize; i++) {
        dp[i][i] = nums[i];
    }
    
    // Fill DP table
    for (int length = 2; length <= numsSize; length++) {
        for (int i = 0; i <= numsSize - length; i++) {
            int j = i + length - 1;
            dp[i][j] = dp[i][j-1] ^ dp[i+1][j];
        }
    }
    
    int* result = malloc(queriesSize * sizeof(int));
    for (int q = 0; q < queriesSize; q++) {
        int l = queries[q][0], r = queries[q][1];
        int maxScore = 0;
        
        for (int i = l; i <= r; i++) {
            for (int j = i; j <= r; j++) {
                int tempI = i, tempJ = j;
                while (tempI <= tempJ) {
                    if (dp[tempI][tempJ] > maxScore) {
                        maxScore = dp[tempI][tempJ];
                    }
                    tempI++;
                    tempJ--;
                }
            }
        }
        result[q] = maxScore;
    }
    
    // Free memory
    for (int i = 0; i < numsSize; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² + q*n²)

O(n²) to build DP table, then O(n²) per query to find maximum in range

⚠ Quadratic Growth

Space Complexity

O(n²)

2D DP table to store all intermediate XOR results

⚠ Quadratic Space

21.2K Views

Medium Frequency

~25 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

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler