Introduction

Yes, you can flip between 0 and 1 with arithmetic operators, and there are a few common formulas for it. The important constraint is that the input must already be guaranteed to be either 0 or 1, because these tricks stop making sense once other values are allowed.

The simplest arithmetic form: 1 - x

If x is always 0 or 1, then 1 - x flips it:

for x in [0, 1]:
    print(x, "->", 1 - x)

Output:

0 -> 1
1 -> 0

This is often the clearest arithmetic expression because it reads almost like English: subtract the current bit from 1.

Using addition and modulus

Another valid arithmetic form is:

flipped = (x + 1) % 2

Example:

for x in [0, 1]:
    print(x, "->", (x + 1) % 2)

This also works because:

• if x is 0, the result is 1
• if x is 1, the result is 0

It is correct, but usually a little less direct than 1 - x.

Bitwise XOR is common too

Strictly speaking, XOR is not an arithmetic operator, but it is one of the most common ways to toggle a bit:

for x in [0, 1]:
    print(x, "->", x ^ 1)

This is widely used in low-level code and bit manipulation because toggling with XOR generalizes well to real bitmasks.

What happens with invalid inputs

These expressions assume the value is binary. If the input can be something else, the result may be meaningless:

1values = [0, 1, 2, -1]
2
3for x in values:
4    print(x, 1 - x, (x + 1) % 2)

For x = 2, 1 - x gives -1, which is clearly not a flipped bit. The modulus version maps extra values back into 0 or 1, but that may hide bad input rather than fixing it.

So the real design question is often whether you are working with:

• a guaranteed binary state
• a Boolean value
• an integer that merely happens to be 0 or 1 most of the time

Prefer booleans when the value is logical

In many languages, a Boolean is clearer than encoding truth as 0 and 1. For example, in Python:

flag = True
flag = not flag
print(flag)

If the state is conceptually on or off, enabled or disabled, or true or false, Boolean operations are usually easier to read than arithmetic tricks.

Choosing the best expression

If you truly need integer 0 and 1, 1 - x is usually the clearest arithmetic toggle. It is short, easy to explain, and free from the slightly heavier mental load of modulus.

Use XOR when you are already doing bitwise work. Use Boolean logic when the domain is really Boolean. Pick the expression that best communicates the intent of the code, not just the one that looks clever.

Common Pitfalls

• Using these formulas when the input is not guaranteed to be 0 or 1.
• Choosing a bitwise trick when the code would be clearer with bool and not.
• Using (x + 1) % 2 in performance-critical code without any evidence that it is better than simpler alternatives.
• Hiding bad upstream data by forcing values through modulus arithmetic.
• Forgetting that XOR is bitwise, not arithmetic, even though it solves the same toggle problem.

Summary

• Yes, arithmetic can flip 0 and 1.
• '1 - x is the clearest arithmetic form when x is binary.'
• '(x + 1) % 2 also works, but it is usually less direct.'
• 'x ^ 1 is a common bitwise toggle when working with bits.'
• These techniques are only valid when the input is guaranteed to be binary.