How Does the XOR Swap Technique Work, and Should You Actually Use It?
Learn how the XOR swap trick works, why it fails under aliasing, and how to answer this bitwise interview question well.
Expected Interview Answer
The XOR swap swaps two integer variables without a temporary variable by applying a = a ^ b, then b = a ^ b, then a = a ^ b, exploiting that XOR-ing a value with itself cancels to zero and XOR-ing with zero returns the original value — but in practice modern compilers already optimize normal three-line swaps just as well, so XOR swap is mostly an interview curiosity, not production advice.
After a = a ^ b, the variable a holds the XOR of both original values. The second step, b = a ^ b, XORs that combined value with the original b, which cancels b out and leaves the original a in the b variable. The third step, a = a ^ b, XORs the combined value with the now-updated b (which holds original a), cancelling a out and leaving original b in the a variable. It only works correctly for integer types and fails or is undefined when the two variables alias the same memory location, since XOR-ing a value with itself always zeroes it out. Because modern compilers already generate optimal register swaps, and because XOR swap is harder to read and riskier with aliasing, most style guides recommend a plain temp-variable swap or tuple swap instead — XOR swap is a good "explain the mechanism" question, not a production pattern.
- Swaps two integers without allocating a temp variable
- Demonstrates that XOR is its own inverse (a ^ a = 0)
- Useful teaching example for bitwise identities
- Illustrates a real aliasing pitfall to watch for in code review
AI Mentor Explanation
Imagine two scorers holding placards with team totals, and instead of a runner fetching a blank third placard to hold one total temporarily, they use a chalk trick: scorer A writes the XOR-combination of both totals on their placard, so it now visually encodes both numbers at once. Scorer B then combines that placard with their own original total, which cancels their own number out and leaves scorer A’s original total written on scorer B’s placard. Scorer A then repeats the trick against scorer B’s now-updated placard, cancelling their own original number out and ending up holding scorer B’s original total. It is a clever no-third-placard trick, but if both scorers are secretly the same person holding one placard twice, the trick zeroes out the score entirely — the same aliasing bug integer XOR swap has.
Step-by-Step Explanation
Step 1
Combine a into a
a = a ^ b makes a hold the XOR of both original values.
Step 2
Recover original a into b
b = a ^ b cancels original b out, leaving original a in b.
Step 3
Recover original b into a
a = a ^ b cancels original a out, leaving original b in a — the swap is complete.
Step 4
Know the pitfall and the alternative
It fails if a and b alias the same memory; prefer a temp variable or tuple swap (a, b = b, a) in real code.
What Interviewer Expects
- Walk through all three XOR steps correctly, explaining why each cancels out
- State clearly that a ^ a = 0 and x ^ 0 = x are the identities that make it work
- Name the aliasing pitfall: swapping a variable with itself zeroes it out
- Recommend a normal temp-variable or tuple swap for real production code
Common Mistakes
- Not knowing why it breaks when the two variables are the same memory location
- Applying it to floating-point numbers, where it does not work correctly
- Presenting it as a performance win over a normal swap (it is not, on modern compilers)
- Forgetting the exact three-line order, swapping steps 2 and 3
Best Answer (HR Friendly)
“XOR swap is a trick for swapping two numbers without a temporary variable, using the fact that XOR-ing a number with itself gives zero. I can explain the three steps and why they work, but I would flag it as an interview trick rather than something I would ship, since it is less readable and can silently break if the two variables happen to be the same location in memory.”
Code Example
def xor_swap(a, b):
a = a ^ b
b = a ^ b # b becomes original a
a = a ^ b # a becomes original b
return a, b
x, y = 5, 9
print(xor_swap(x, y)) # (9, 5)
# Preferred in real Python code: no aliasing risk, works for any type
x, y = y, xFollow-up Questions
- Why does XOR swap fail if you call it with the same variable for both arguments?
- Does XOR swap work for floating-point numbers? Why or why not?
- How does Python’s tuple swap (a, b = b, a) avoid the aliasing problem entirely?
- Where else does the identity a ^ a = 0 show up in algorithm problems?
MCQ Practice
1. What identity makes XOR swap work?
XOR swap relies on a value XOR-ed with itself becoming zero, and any value XOR-ed with zero staying unchanged.
2. What happens if you XOR-swap a variable with itself (same memory location for both arguments)?
Since a ^ a = 0, the first step zeroes the single shared location, destroying the original value entirely.
3. Why do most style guides recommend against XOR swap in production code?
Modern compilers already optimize normal swaps efficiently, so XOR swap trades readability and aliasing safety for no real gain.
Flash Cards
What are the three lines of the XOR swap? — a = a ^ b; b = a ^ b; a = a ^ b
What identity underlies XOR swap? — a ^ a = 0 and a ^ 0 = a
When does XOR swap fail? — When both variables alias the same memory location, it zeroes the value out.
What is the recommended real-world alternative in Python? — a, b = b, a — a tuple swap with no aliasing risk.