XOR Operation in an Array - Practice Coding Problems

XOR Operation in an Array - Problem

You're tasked with performing a bitwise XOR operation on a specially constructed array. Given two integers n and start, you need to:

Create an array nums of length n where each element follows the pattern: nums[i] = start + 2 * i
Return the XOR of all elements in this array

Example: If n = 5 and start = 0, the array becomes [0, 2, 4, 6, 8], and the XOR result is 0 ⊕ 2 ⊕ 4 ⊕ 6 ⊕ 8 = 8.

This problem tests your understanding of bit manipulation and mathematical patterns in XOR operations. Can you find an efficient solution that goes beyond the obvious approach?

Input & Output

example_1.py — Basic Case

$ Input: n = 5, start = 0

› Output: 8

💡 Note: Array becomes [0, 2, 4, 6, 8]. XOR: 0 ⊕ 2 ⊕ 4 ⊕ 6 ⊕ 8 = 8

example_2.py — Small Array

$ Input: n = 4, start = 3

› Output: 8

💡 Note: Array becomes [3, 5, 7, 9]. XOR: 3 ⊕ 5 ⊕ 7 ⊕ 9 = 8

example_3.py — Single Element

$ Input: n = 1, start = 7

› Output: 7

💡 Note: Array has only one element [7], so XOR result is 7

Constraints

1 ≤ n ≤ 1000
0 ≤ start ≤ 1000
nums[i] = start + 2 * i for all valid indices i

Visualization

Tap to expand

Understanding the Visualization

Generate Sequence

Create arithmetic sequence: start, start+2, start+4, ...

XOR Accumulation

Pass each number through XOR gate with running result

Final Output

The last XOR result is our answer

Key Takeaway

🎯 Key Insight: XOR operations can be computed incrementally - we don't need to store the entire array, just accumulate the XOR result as we generate each element.

Asked in

a Amazon 25 ⊞ Microsoft 18 Apple 12 G Google 8

This problem can be solved by directly simulating the array construction and XOR operation. The key insight is that we don't actually need to store the array - we can compute each element start + 2*i and immediately XOR it with our running result. While mathematical optimizations exist for XOR operations on arithmetic sequences, the direct simulation approach is sufficient for the given constraints and provides a clear, understandable solution.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Simulation	O(n)	O(1)	Build the array and XOR all elements sequentially

Direct Simulation — Algorithm Steps

Initialize result as 0 (XOR identity element)
For each index i from 0 to n-1, compute nums[i] = start + 2*i
XOR the current element with our running result
Return the final XOR result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with result = 0, the XOR identity element

Compute Elements

For each i, calculate start + 2*i and XOR with result

Running XOR

Accumulate XOR: result = result ⊕ (start + 2*i)

Final Result

Return the accumulated XOR value

Code -

solution.c — C

#include <stdio.h>

int xorOperation(int n, int start) {
    int result = 0;
    for (int i = 0; i < n; i++) {
        result ^= start + 2 * i;
    }
    return result;
}

int main() {
    int n, start;
    scanf("%d %d", &n, &start);
    printf("%d\n", xorOperation(n, start));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through n elements once to compute the XOR

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for the result variable

✓ Linear Space

28.5K Views

Medium Frequency

~8 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

Direct Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler