Find Xor-Beauty of Array - Practice Coding Problems

Find Xor-Beauty of Array - Problem

You are given a 0-indexed integer array nums. Your task is to find the XOR-beauty of this array through a fascinating bit manipulation process.

Here's how it works:

For any three indices i, j, and k, we define an effective value as: ((nums[i] | nums[j]) & nums[k])
The XOR-beauty is the XOR of all possible effective values from every triplet combination

Example: If nums = [1, 4], we need to consider all 8 possible triplets: (0,0,0), (0,0,1), (0,1,0), (0,1,1), (1,0,0), (1,0,1), (1,1,0), (1,1,1)

Goal: Return the XOR-beauty of the array efficiently. Can you find a pattern to avoid checking all O(n³) triplets?

Note: | represents bitwise OR, & represents bitwise AND

Input & Output

example_1.py — Simple Case

$ Input: nums = [1, 4]

› Output: 5

💡 Note: All possible triplets: (0,0,0)→1, (0,0,1)→0, (0,1,0)→1, (0,1,1)→4, (1,0,0)→1, (1,0,1)→0, (1,1,0)→1, (1,1,1)→4. XOR all: 1⊕0⊕1⊕4⊕1⊕0⊕1⊕4 = 5. Optimized: 1⊕4 = 5

example_2.py — Single Element

$ Input: nums = [15]

› Output: 15

💡 Note: Only one possible triplet (0,0,0): (15|15)&15 = 15&15 = 15. Optimized: just return 15

example_3.py — Zeros

$ Input: nums = [0, 0]

› Output: 0

💡 Note: All triplets result in 0: (0|0)&0 = 0. XOR of all zeros is 0. Optimized: 0⊕0 = 0

Visualization

Tap to expand

Understanding the Visualization

Generate All Triplets

Consider every possible combination of 3 indices (i,j,k)

Calculate Effective Values

For each triplet: (nums[i] | nums[j]) & nums[k]

XOR Cancellation Magic

Most values cancel out due to XOR properties

Elegant Result

Only the XOR of individual elements remains

Key Takeaway

🎯 Key Insight: XOR's magical self-canceling property (a ⊕ a = 0) eliminates the need to compute all n³ triplets. The mathematical beauty lies in recognizing that only the individual array elements matter in the final result!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array to XOR all elements

✓ Linear Growth

Space Complexity

O(1)

Only using one variable to accumulate result

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
Array elements can be zero
All operations fit within 32-bit integers

Asked in

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

The key insight is recognizing that XOR's self-canceling property eliminates most triplet contributions. Instead of checking all O(n³) combinations, we can simply XOR all array elements in O(n) time. This mathematical optimization transforms a computationally expensive problem into an elegant one-liner!

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Optimization (Optimal)	O(n)	O(1)	Use XOR properties to reduce O(n³) to O(n) by recognizing cancellation patterns
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check all possible triplets and XOR their effective values

Mathematical Optimization (Optimal) — Algorithm Steps

Recognize that XOR has self-canceling properties (a ⊕ a = 0)
Analyze the contribution pattern of each triplet
Observe that when i ≠ j ≠ k, contributions often cancel in pairs
Identify that only diagonal cases (i = j = k) survive the cancellation
Simplify to just XOR-ing all individual array elements

Visualization

Tap to expand

Step-by-Step Walkthrough

XOR Self-Cancellation

a ⊕ a = 0, so identical contributions cancel

Triplet Analysis

Most off-diagonal triplets appear in canceling pairs

Diagonal Dominance

Only (i,i,i) triplets survive: nums[i] & nums[i] = nums[i]

Final Simplification

Result = nums[0] ⊕ nums[1] ⊕ ... ⊕ nums[n-1]

Code -

solution.c — C

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

int xorBeauty(int* nums, int n) {
    // Mathematical insight: Due to XOR's self-canceling properties,
    // most triplet contributions cancel out, leaving only the XOR
    // of all individual elements
    
    int result = 0;
    for (int i = 0; i < n; i++) {
        result ^= nums[i];
    }
    
    return result;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    
    scanf("%c", &c); // skip '['
    if (scanf("%d", &nums[0]) == 1) {
        n = 1;
        while (scanf("%c", &c) == 1 && c == ',') {
            scanf("%d", &nums[n]);
            n++;
        }
    } else {
        scanf("%c", &c); // skip ']'
    }
    
    printf("%d\n", xorBeauty(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array to XOR all elements

✓ Linear Growth

Space Complexity

O(1)

Only using one variable to accumulate result

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
Array elements can be zero
All operations fit within 32-bit integers

32.4K Views

Medium Frequency

~15 min Avg. Time

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

Mathematical Optimization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler