Two's Complement (original) (raw)

Last Updated : 25 Apr, 2026

There are three common ways to represent signed integers: sign-bit representation, 1’s complement, and 2’s complement. Since data is stored in bits, we need a method to store both positive and negative values in memory. To understand this, we start with a simple approach and then gradually improve it to arrive at a more efficient and practical solution.

Signed bit

In this method, the leftmost bit is used to show the sign of the number. 0 means positive and 1 means negative. The remaining bits store the value.

For example, in a 4-bit system, 1 bit is for sign and 3 bits store the number.
In an 8-bit system, 1 bit is for sign and 7 bits store the number.

By using this approach, we are successfully able to represent signed integer. But when we analysis it more closely, we could observe following drawbacks:

1) Two representations of zero:

In sign-bit representation, the leftmost bit shows the sign and the remaining bits store the value. Because of this, zero can be represented in two ways:

• ****+0** : 0000 (sign bit = 0, value = 000)
• **-0 : 1000 (sign bit = 1, value = 000)

Both represent the same value (zero), but they have different bit patterns.

Why this is a problem:

• It wastes one possible value, so instead of 16 unique values (in 4-bit), we get only 15.
• The system must check for both +0 and -0, which makes operations more complex.

2) Signed extension doesn’t work for negative numbers:

As data size increases, we need to extend the number of bits (for example, from 32-bit to 64-bit). A good system should allow extension without changing the value.

• Positive numbers extend correctly by adding zeros.
• Negative numbers do not extend correctly in sign-bit representation.

3) Binary addition doesn’t work:

Let's try to add two binary numbers:

Binary addition does not work correctly in this representation because the sign bit is treated separately from the value bits. When we perform normal binary addition, the result becomes incorrect since the sign bit is not handled as part of the actual number. This makes arithmetic operations complex and unreliable.

**1’s Complement

In this method, negative numbers are arranged in reverse order compared to the signed-bit method. This improves how negative values are handled.

How 1’s Complement Works

• Positive numbers are stored as they are
• Negative numbers are formed by changing all 0s to 1s and 1s to 0s

**Example:
+2 : 0010
-2 : 1101

1) Two representations of zero:

This method still has two zeros:

+0 : 0000
-0 : 1111

This creates confusion and wastes one value.

2) Bit Extension Works Properly:

Extending bits keeps the value correct:

3) Binary addition works with modified rules:

Normal binary addition gives almost correct results, but one extra step is needed.

If there is a carry from the leftmost bit, add it back to the rightmost bit.

2’s Complement

2’s complement is obtained by removing -0 from the 1’s complement table and shifting negative values one step down.

How to get binary representation of an integer in 2’s complement method?

• Positive numbers are represented similar to signed integer method
• Negative numbers are represented by inverting every bit of corresponding positive number then adding 1 bit to it

1) One representation of zero:

Now we have only one representation of zero and it allows us to store **total 16 unique values (+0 to +7 and -1 to -8).

2) Signed extension works for negative numbers:

Signed extension works perfectly for negative numbers.

3) Binary addition:

4) First bit is a signed bit:

• Numbers starting with 0 : positive
• Numbers starting with 1 : negative

5) Memory overflow check:

Overflow occurs when:

• Carry into sign bit ≠ Carry out of sign bit