Maximum XOR for Each Query

Maximum XOR for Each Query - Problem

You are given a sorted array nums of n non-negative integers and an integer maximumBit. You want to perform the following query n times:

Find a non-negative integer k < 2^maximumBit such that nums[0] XOR nums[1] XOR ... XOR nums[nums.length-1] XOR k is maximized. k is the answer to the i^th query.
Remove the last element from the current array nums.

Return an array answer, where answer[i] is the answer to the i^th query.

Input & Output

Example 1 — Basic Case

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

› Output: [0,3,2,3]

💡 Note: Query 1: XOR of [0,1,1,3] = 3, optimal k = 0 (3⊕0 = 3, maximum for 2 bits). Query 2: XOR of [0,1,1] = 0, optimal k = 3 (0⊕3 = 3). Query 3: XOR of [0,1] = 1, optimal k = 2 (1⊕2 = 3). Query 4: XOR of [0] = 0, optimal k = 3 (0⊕3 = 3).

Example 2 — Single Element

$ Input: nums = [2], maximumBit = 3

› Output: [5]

💡 Note: XOR of [2] = 2 (binary: 010). Maximum value with 3 bits is 7 (binary: 111). Optimal k = 2⊕7 = 5 (binary: 101), giving result 2⊕5 = 7.

Example 3 — Larger maximumBit

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

› Output: [4,3,6,4,6,7]

💡 Note: Each query finds k that maximizes XOR with current subarray. The maximum possible result is always 2^maximumBit - 1 = 7.

Constraints

nums.length == n
1 ≤ n ≤ 10⁵
1 ≤ maximumBit ≤ 20
0 ≤ nums[i] < 2^maximumBit
nums is sorted in ascending order

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15 f Meta 12

The key insight is that to maximize A XOR k, we need k to be the bitwise complement of A within the maximumBit range. The optimal approach maintains a running XOR and calculates k = totalXOR ^ ((1 << maximumBit) - 1) for each query. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force

⏱️ Time: O(n² × 2^maximumBit) Space: O(1)

For each query, calculate the current XOR of all elements, then try every possible k value from 0 to 2^maximumBit-1 to find which gives maximum XOR result.

Prefix XOR with Bit Manipulation

⏱️ Time: O(n²) Space: O(n)

Calculate prefix XOR for efficient range queries, then use the key insight that to maximize XOR result, we need k to be the bitwise complement of current XOR within the maximumBit range.

Single Pass Optimal Solution

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

The key insight is that to maximize A XOR k, we need k to be the bitwise complement of A within the maximumBit range. We can maintain a running XOR and calculate answers in a single pass from right to left.

Brute Force — Algorithm Steps

Calculate XOR of current array
Try all k values 0 to 2^maximumBit-1
Find k that maximizes currentXOR ^ k
Remove last element and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Array XOR

XOR all current elements

Try All K Values

Test k = 0, 1, 2, ... up to 2^maximumBit-1

Find Maximum

Select k that gives highest XOR result

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int maximumBit, int* returnSize) {
    int* result = (int*)malloc(numsSize * sizeof(int));
    int current_xor = 0;
    
    // Calculate initial XOR of all elements
    for (int i = 0; i < numsSize; i++) {
        current_xor ^= nums[i];
    }
    
    // Maximum possible value with maximumBit bits
    int max_val = (1 << maximumBit) - 1;
    
    // For each query
    for (int i = 0; i < numsSize; i++) {
        // Find k that maximizes current_xor ^ k
        // To get maximum result (max_val), we need k = current_xor ^ max_val
        int k = current_xor ^ max_val;
        result[i] = k;
        
        // Remove last element for next iteration
        current_xor ^= nums[numsSize - 1 - i];
    }
    
    *returnSize = numsSize;
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    parseArray(line, nums, &numsSize);
    
    int maximumBit;
    scanf("%d", &maximumBit);
    
    int returnSize;
    int* result = solution(nums, numsSize, maximumBit, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × 2^maximumBit)

For each of n queries, calculate XOR in O(n) and try 2^maximumBit values

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~15 min Avg. Time

850 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler