1's Complement

The 1’s complement of a binary number is the number with every bit inverted: every $0$ becomes $1$ and every $1$ becomes $0$. Used as one of three standard schemes for representing signed binary numbers.

To represent $-K$ in signed 1’s complement, take the binary representation of $+K$ and complement every bit (including the sign bit). For 8 bits:

• $+25=00011001$
• $-25=11100110$

In general, the 1’s complement of an $n$-bit number $N$ is $(2^n-1)-N$. That’s the diminished radix complement (see Radix Complement) — the radix is $2$ and the diminished radix is $2-1=1$.

Properties

• Negation is bitwise inversion. Cheap in hardware: just NOT every bit.
• Two representations of zero. $00000000$ is $+0$ and $11111111$ is $-0$. Both compare as zero in value, but their bit patterns differ.
• Range for $n$ bits: $-(2^{n-1}-1)$ to $+(2^{n-1}-1)$.

Addition with end-around carry

To add two 1’s complement numbers: add their bits including the sign positions. If there’s a carry out of the most significant bit, add it back into the least significant bit. That step is the end-around carry and is what makes 1’s complement arithmetic work.

Example for $+5+(-3)$:

  0 101  (+5)
+ 1 100  (-3 in 1's complement)
---------
1 0001   ← carry of 1 out of MSB

  0001
+ 0001   ← end-around carry
---------
  0010   ( = +2)

Without the end-around carry, the answer would be off by 1 — the wrap-around in the modular space of $2^n-1$ values is what the extra add corrects.

Why it lost to 2’s complement

Two reasons 2’s complement displaced 1’s complement:

1. Single zero. No ambiguity, simpler comparators.
2. No end-around carry. Standard binary addition just works; you discard the MSB carry. Cheaper, faster.

1’s complement still appears in some networking checksums (notably IPv4’s IP header checksum), where the end-around carry property is actually useful for catching certain bit errors. For general-purpose signed integers, 2’s complement is the standard.