Neighboring Bitwise XOR - Practice Coding Problems

Neighboring Bitwise XOR - Problem

Reverse Engineering Binary Array from XOR Operations

Imagine you have a secret binary array (containing only 0's and 1's) that has been transformed using a specific XOR pattern. Your task is to determine if a given derived array could have been created from some valid binary array using this transformation.

The transformation rule is: For each position i in the original array:

If i is the last position, then derived[i] = original[i] ⊕ original[0] (XOR with first element)
Otherwise, derived[i] = original[i] ⊕ original[i + 1] (XOR with next element)

Goal: Given a derived array, return true if there exists a valid binary array that could have produced it, false otherwise.

Example: If derived = [1, 1, 0], we need to check if there's a binary array [a, b, c] such that [a⊕b, b⊕c, c⊕a] = [1, 1, 0]

Input & Output

example_1.py — Valid Array Exists

$ Input: [1, 1, 0]

› Output: true

💡 Note: We can find original = [1, 0, 1] which produces derived = [1⊕0, 0⊕1, 1⊕1] = [1, 1, 0]. XOR sum: 1⊕1⊕0 = 0 ✓

example_2.py — No Valid Array

$ Input: [1, 1, 1]

› Output: false

💡 Note: XOR sum: 1⊕1⊕1 = 1 ≠ 0, so no valid original array exists. Each element would need to appear twice but sum to 1.

example_3.py — Single Element

$ Input: [0]

› Output: true

💡 Note: For n=1, derived[0] = original[0] ⊕ original[0] = 0. Since derived[0] = 0, original = [0] works. XOR sum: 0 = 0 ✓

Visualization

Tap to expand

Understanding the Visualization

Original Array Setup

We have an unknown binary array [a, b, c, ...]

XOR Transformation

Each element XORs with its neighbor (last wraps to first)

Mathematical Analysis

When we XOR all derived values, each original appears exactly twice

Key Insight

Since x⊕x = 0, the total XOR sum must be 0 for valid arrays

Key Takeaway

🎯 Key Insight: The circular XOR pattern ensures each original element appears exactly twice in the sum, making the total XOR equal to 0 for any valid array.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to compute XOR sum, plus optional O(n) to construct solution

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for XOR computation

✓ Linear Space

Constraints

1 ≤ derived.length ≤ 10⁵
derived[i] is either 0 or 1
All values are binary (0 or 1)

Asked in

B ByteDance 15 ⊞ Microsoft 12 a Amazon 8 G Google 6

The optimal solution uses a mathematical XOR property: when we XOR all elements in the derived array, each original element appears exactly twice. Since x ⊕ x = 0, the total must equal 0 for valid arrays. This gives us an O(n) time, O(1) space solution.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical XOR Property (Optimal)	O(n)	O(1)	Use the mathematical insight that XOR sum must be 0 for valid arrays
Brute Force (Try All Combinations)	O(n * 2^n)	O(n)	Try all 2^n possible binary arrays and check if any produces the given derived array

Mathematical XOR Property (Optimal) — Algorithm Steps

Calculate XOR of all elements in derived array
If XOR sum is not 0, return false (no valid array exists)
If XOR sum is 0, construct any valid original array by setting original[0] = 0
Use the constraint equations to determine remaining elements
Return true

Visualization

Tap to expand

Step-by-Step Walkthrough

XOR Chain Analysis

Each original element appears exactly twice in derived calculations

Mathematical Property

Since x ⊕ x = 0, total XOR sum must be 0

Quick Verification

Check if XOR of all derived elements equals 0

Code -

solution.c — C

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

int doesValidArrayExist(int* derived, int n) {
    // Key insight: XOR all derived elements
    // Each original element appears exactly twice in the XOR chain
    // So total XOR = 0 if and only if valid array exists
    
    int xorSum = 0;
    for (int i = 0; i < n; i++) {
        xorSum ^= derived[i];
    }
    
    // If XOR sum is 0, valid array exists
    return xorSum == 0;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse input array
    int derived[100];
    int n = 0;
    char* token = strtok(line, "[], \n");
    while (token != NULL) {
        derived[n++] = atoi(token);
        token = strtok(NULL, "[], \n");
    }
    
    printf("%s\n", doesValidArrayExist(derived, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to compute XOR sum, plus optional O(n) to construct solution

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for XOR computation

✓ Linear Space

Constraints

1 ≤ derived.length ≤ 10⁵
derived[i] is either 0 or 1
All values are binary (0 or 1)

23.5K Views

Medium Frequency

~12 min Avg. Time

847 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 XOR Property (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler