Maximum XOR Score Subarray Queries

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

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

✓ Dynamic Programming (Optimal)

⏱️ Time: O(n² + q*n²) Space: O(n²)

We use dynamic programming to precompute all possible XOR scores. The key insight is that dp[i][j] represents the XOR score when we start with subarray from index i to j and perform one round of XOR operations. We build this table bottom-up, then for each query, we scan the precomputed values to find the maximum.

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 getXorScore(int* arr, int arr_size) {
    if (arr_size == 1) {
        return arr[0];
    }
    
    int* current = malloc(arr_size * sizeof(int));
    for (int i = 0; i < arr_size; i++) {
        current[i] = arr[i];
    }
    int current_size = arr_size;
    
    while (current_size > 1) {
        int* next_level = malloc((current_size - 1) * sizeof(int));
        
        for (int i = 0; i < current_size - 1; i++) {
            next_level[i] = current[i] ^ current[i + 1];
        }
        
        free(current);
        current = next_level;
        current_size = current_size - 1;
    }
    
    int final_score = current[0];
    free(current);
    return final_score;
}

int getMaxXorInRange(int* nums, int l, int r) {
    int max_score = 0;
    for (int i = l; i <= r; i++) {
        for (int j = i; j <= r; j++) {
            int subarray_size = j - i + 1;
            int* subarray = malloc(subarray_size * sizeof(int));
            for (int k = 0; k < subarray_size; k++) {
                subarray[k] = nums[i + k];
            }
            int score = getXorScore(subarray, subarray_size);
            if (score > max_score) max_score = score;
            free(subarray);
        }
    }
    return max_score;
}

int* maxXorQueries(int* nums, int numsSize, int** queries, int queriesSize, int* returnSize) {
    *returnSize = queriesSize;
    int* result = malloc(queriesSize * sizeof(int));
    
    for (int q = 0; q < queriesSize; q++) {
        int l = queries[q][0], r = queries[q][1];
        result[q] = getMaxXorInRange(nums, l, r);
    }
    
    return result;
}

int main() {
    static char input1[10000], input2[10000];
    fgets(input1, sizeof(input1), stdin);
    fgets(input2, sizeof(input2), stdin);
    
    input1[strcspn(input1, "\n")] = 0;
    input2[strcspn(input2, "\n")] = 0;
    
    // Strip brackets from nums input
    char* p = input1;
    while (*p == '[' || *p == ' ') p++;
    char* end = p + strlen(p) - 1;
    while (end > p && (*end == ']' || *end == ' ')) { *end = '\0'; end--; }
    
    static int nums[2000];
    int nums_size = 0;
    char* input1_copy = malloc(strlen(p) + 1);
    strcpy(input1_copy, p);
    char* token = strtok(input1_copy, ",");
    while (token != NULL) {
        while (*token == ' ') token++;
        nums[nums_size++] = atoi(token);
        token = strtok(NULL, ",");
    }
    free(input1_copy);
    
    // Parse queries
    static int* queries[100000];
    int queries_size = 0;
    int len = strlen(input2);
    int i = 0;
    int depth = 0;
    while (i < len) {
        if (input2[i] == '[') {
            depth++;
            if (depth == 2) {
                int j = i + 1;
                while (j < len && input2[j] != ']') j++;
                char pair_str[100];
                strncpy(pair_str, input2 + i + 1, j - i - 1);
                pair_str[j - i - 1] = '\0';
                
                queries[queries_size] = malloc(2 * sizeof(int));
                char* comma = strchr(pair_str, ',');
                if (comma) {
                    *comma = '\0';
                    queries[queries_size][0] = atoi(pair_str);
                    queries[queries_size][1] = atoi(comma + 1);
                    queries_size++;
                }
                i = j + 1;
                depth--;
            } else {
                i++;
            }
        } else {
            if (input2[i] == ']') depth--;
            i++;
        }
    }
    
    int returnSize;
    int* result = maxXorQueries(nums, nums_size, queries, queries_size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]");
    
    free(result);
    for (int i = 0; i < queries_size; i++) {
        free(queries[i]);
    }
    
    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