Maximum XOR After Operations - Practice Coding Problems

Maximum XOR After Operations - Problem

Maximum XOR After Operations

You have a magical array of integers where you can perform special bitwise transformations! Given a 0-indexed integer array nums, you can repeatedly apply the following operation:

📝 Operation: Select any non-negative integer x and any index i, then transform nums[i] to nums[i] AND (nums[i] XOR x)

🎯 Goal: Find the maximum possible XOR of all elements in the array after applying this operation any number of times.

Key Insight: This operation can only turn bits from 1 to 0, never from 0 to 1. So for maximum XOR, we want to keep as many different bit positions set across all numbers as possible!

Input & Output

example_1.py — Basic Case

$ Input: [3, 2, 4, 6]

› Output: 7

💡 Note: We can transform the array to achieve XOR of 7. The numbers in binary are: 3=0011, 2=0010, 4=0100, 6=0110. The OR of all numbers is 0111=7, which is the maximum possible XOR since operations can only turn bits OFF.

example_2.py — Single Element

$ Input: [1]

› Output: 1

💡 Note: With only one element, the XOR is just that element itself. No operations can increase this value since we can only turn bits OFF.

example_3.py — All Same Bits

$ Input: [7, 7, 7]

› Output: 7

💡 Note: All numbers have the same bits (0111). The maximum XOR we can achieve is 7, which happens when only one number keeps all its bits and others are reduced to 0.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁸
Each operation can be applied any number of times

Visualization

Tap to expand

Understanding the Visualization

Initial Houses

Each house has some lights on (set bits)

Operation Rules

You can only turn lights OFF, never ON

Optimal Strategy

Keep all unique light positions on across different houses

Maximum Illumination

OR of all houses gives maximum possible light combination

Key Takeaway

🎯 Key Insight: The operation can only reduce bits, so maximum XOR equals the OR of all numbers!

Asked in

G Google 42 ⊞ Microsoft 28 a Amazon 35 f Meta 19

The optimal solution uses bit manipulation insight: since the operation can only turn bits OFF (never ON), the maximum XOR is achieved by taking the bitwise OR of all numbers, which preserves all possible bit positions in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Operations)	O(2^(n×32))	O(n)	Recursively try all possible operations and track maximum XOR
Bit Manipulation Insight (Optimal)	O(n)	O(1)	Realize that operation can only turn bits OFF, so OR all numbers for maximum XOR

Brute Force (Try All Operations) — Algorithm Steps

Start with the original array
For each position i and possible x value, apply nums[i] = nums[i] & (nums[i] ^ x)
Recursively try more operations on the resulting array
Track the maximum XOR seen across all possibilities
Return the global maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original array [3,2,4,6]

Branch Operations

Try different operations on each element

Recursive Exploration

Recursively apply more operations

Track Maximum

Keep track of best XOR found

Code -

solution.c — C

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

int calculateXor(int* arr, int size) {
    int result = 0;
    for (int i = 0; i < size; i++) {
        result ^= arr[i];
    }
    return result;
}

int solve(int* arr, int size, int depth) {
    if (depth > 10) {
        return calculateXor(arr, size);
    }
    
    int maxXor = calculateXor(arr, size);
    
    for (int i = 0; i < size; i++) {
        for (int x = 0; x < 16; x++) {
            int newVal = arr[i] & (arr[i] ^ x);
            if (newVal != arr[i]) {
                int original = arr[i];
                arr[i] = newVal;
                int* newArr = (int*)malloc(size * sizeof(int));
                for (int j = 0; j < size; j++) newArr[j] = arr[j];
                int result = solve(newArr, size, depth + 1);
                if (result > maxXor) maxXor = result;
                free(newArr);
                arr[i] = original;
            }
        }
    }
    
    return maxXor;
}

int getMaximumXor(int* nums, int size) {
    int* copy = (int*)malloc(size * sizeof(int));
    for (int i = 0; i < size; i++) copy[i] = nums[i];
    int result = solve(copy, size, 0);
    free(copy);
    return result;
}

int main() {
    int nums[] = {3, 2, 4, 6};
    printf("%d\n", getMaximumXor(nums, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n×32))

Each number can have its bits modified in exponential ways

✓ Linear Growth

Space Complexity

O(n)

Recursion stack and array storage

⚡ Linearithmic Space

23.4K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Operations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler