Find The Original Array of Prefix Xor - Practice Coding Problems

Find The Original Array of Prefix Xor - Problem

Find The Original Array of Prefix XOR

You're given an integer array pref of size n that represents the prefix XOR of some unknown original array. Your task is to reverse-engineer and find the original array arr.

The relationship between the arrays is defined as:
pref[i] = arr[0] ⊕ arr[1] ⊕ ... ⊕ arr[i]

Where ⊕ denotes the bitwise XOR operation. This means each element in pref is the XOR of all elements in the original array from index 0 up to index i.

Example: If original array is [5, 2, 0, 3], then prefix XOR array would be [5, 7, 7, 4] because:
• pref[0] = 5
• pref[1] = 5 ⊕ 2 = 7
• pref[2] = 5 ⊕ 2 ⊕ 0 = 7
• pref[3] = 5 ⊕ 2 ⊕ 0 ⊕ 3 = 4

It can be proven that the answer is unique.

Input & Output

example_1.py — Basic Case

$ Input: pref = [5, 2, 0, 3, 1]

› Output: [5, 7, 2, 3, 2]

💡 Note: Starting with pref[0] = 5, we get arr[0] = 5. Then arr[1] = pref[1] ⊕ pref[0] = 2 ⊕ 5 = 7. Continuing: arr[2] = 0 ⊕ 2 = 2, arr[3] = 3 ⊕ 0 = 3, arr[4] = 1 ⊕ 3 = 2.

example_2.py — Single Element

$ Input: pref = [13]

› Output: [13]

💡 Note: With only one element, the original array is identical to the prefix array since arr[0] = pref[0].

example_3.py — Zeros and Large Numbers

$ Input: pref = [0, 1000000, 0]

› Output: [0, 1000000, 1000000]

💡 Note: arr[0] = 0, arr[1] = 1000000 ⊕ 0 = 1000000, arr[2] = 0 ⊕ 1000000 = 1000000. Note how XOR with 0 doesn't change the value.

Constraints

1 ≤ pref.length ≤ 10⁵
0 ≤ pref[i] ≤ 10⁶
The answer is guaranteed to be unique

Visualization

Tap to expand

Understanding the Visualization

Understanding the Lock

Each pref[i] is like a locked box containing the XOR of all elements from 0 to i

Finding the Key

The key insight: pref[i] ⊕ pref[i-1] = arr[i] because XOR cancels out common elements

Unlocking Step by Step

Start with arr[0] = pref[0], then unlock each subsequent element using adjacent pref values

Complete Reconstruction

In just one pass, we've reconstructed the entire original array!

Key Takeaway

🎯 Key Insight: XOR's self-inverse property (A ⊕ A = 0) allows us to isolate individual array elements by canceling out common prefixes, turning an O(n²) problem into an elegant O(n) solution!

Asked in

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

The optimal solution uses the key XOR property that arr[i] = pref[i] ⊕ pref[i-1] to find each element in O(1) time. This eliminates the need for redundant calculations, achieving O(n) time complexity with a simple single-pass approach.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Optimal (XOR Properties)	O(n)	O(1)	Use XOR properties to find each element in O(1) time per element
Brute Force (Nested Loops)	O(n²)	O(1)	For each position, recalculate XOR from scratch using nested loops

One-Pass Optimal (XOR Properties) — Algorithm Steps

Set arr[0] = pref[0] (base case)
For i from 1 to n-1, calculate arr[i] = pref[i] ⊕ pref[i-1]
This works because pref[i-1] ⊕ arr[i] = pref[i], so arr[i] = pref[i] ⊕ pref[i-1]
Return the reconstructed array

Visualization

Tap to expand

Step-by-Step Walkthrough

Key Insight

If pref[i] = pref[i-1] ⊕ arr[i], then arr[i] = pref[i] ⊕ pref[i-1]

Base Case

arr[0] = pref[0] = 5

Direct Calculation

Each arr[i] computed in O(1) using adjacent pref values

Complete Solution

Single pass through array gives optimal O(n) solution

Code -

solution.c — C

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

int* findArray(int* pref, int n, int* returnSize) {
    *returnSize = n;
    int* arr = (int*)malloc(n * sizeof(int));
    arr[0] = pref[0];  // Base case
    
    // Use XOR property: arr[i] = pref[i] ⊕ pref[i-1]
    for (int i = 1; i < n; i++) {
        arr[i] = pref[i] ^ pref[i-1];
    }
    
    return arr;
}

int main() {
    int n;
    scanf("%d", &n);
    int* pref = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &pref[i]);
    }
    
    int returnSize;
    int* result = findArray(pref, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize-1) printf(",");
    }
    printf("]\n");
    
    free(pref);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element computed in O(1) time

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables, output array doesn't count

✓ Linear Space

42.3K Views

Medium Frequency

~12 min Avg. Time

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

One-Pass Optimal (XOR Properties) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler