Number Systems

Computers use binary because their hardware is built from switches that are either ON (1) or OFF (0). Every piece of data, every instruction, every pixel is stored as binary internally.

Humans use denary (base 10) because we have ten fingers. It's natural for us to count 0-9 then start a new column.

Hexadecimal (base 16) sits between the two — a more compact way to write binary. Programmers use hex to display binary values without writing endless 1s and 0s.

Why hex? A single byte (8 bits) needs 8 binary digits but only 2 hex digits. Hex is dense and human-readable.

Denary	Binary	Hex
0	0000	0
1	0001	1
2	0010	2
5	0101	5
9	1001	9
10	1010	A
12	1100	C
15	1111	F

Where you see hex in real systems:

• Memory addresses (e.g., 0x7FFE3A04).
• Colour values in HTML/CSS (#FF6600 = vivid orange).
• MAC addresses (e.g., 00:1A:2B:3C:4D:5E).
• Error codes and debugging output.

Cambridge tip. "Why is hex used?" is a near-guaranteed exam question. Top answer: it's a compact, human-readable representation of binary — 1 hex digit = 4 binary bits, so a byte fits in 2 hex digits.

Denary → Binary. Use the place-value subtraction method.

Place values for 8 bits: 128 64 32 16 8 4 2 1. Subtract each from your number, largest first; write 1 if you can subtract, 0 if you can't.

Worked example. Convert 217:

• 217 − 128 = 89 → write 1
• 89 − 64 = 25 → write 1
• 25 − 32: can't → write 0
• 25 − 16 = 9 → write 1
• 9 − 8 = 1 → write 1
• 1 − 4: can't → write 0
• 1 − 2: can't → write 0
• 1 − 1 = 0 → write 1

Result: 11011001.

Binary → Denary. Add the place values where there's a 1.

Worked example. 11011001 = 128 + 64 + 16 + 8 + 1 = 217.

Binary → Hex. Group the bits into nibbles (4 at a time) FROM THE RIGHT, then convert each nibble.

Worked example. 11010110 → 1101 0110 → D 6 → D6.

Hex → Binary. Convert each hex digit to a 4-bit nibble.

Worked example. 4F → 4 = 0100, F = 1111 → 01001111.

Hex → Denary. Multiply each digit by its place value (16⁰, 16¹, 16², ...).

Worked example. 4F = 4 × 16 + 15 × 1 = 64 + 15 = 79.

Denary → Hex. Two methods:

1. Convert via binary (denary → binary → hex).
2. Direct: divide by 16 repeatedly, the remainders read bottom-up are the hex digits.

Cambridge tip. Mark schemes ALWAYS expect working shown. Even if you can convert mentally, write the place-value row, the subtractions, and the final answer. The method marks are awarded separately.

Binary addition rules:

Sum	Result
0 + 0	0
0 + 1	1
1 + 0	1
1 + 1	10 (write 0, carry 1)
1 + 1 + 1 (with carry)	11 (write 1, carry 1)

Add bit-by-bit from right to left, propagating carries.

Worked example. 01101100 + 00110101.

Aligning vertically:

   0 1 1 0 1 1 0 0
 + 0 0 1 1 0 1 0 1

Right to left, with carries shown:

• 0+1 = 1, no carry
• 0+0 = 0
• 1+1 = 10 (write 0, carry 1)
• 1+0+1 = 10 (write 0, carry 1)
• 0+1+1 = 10 (write 0, carry 1)
• 1+1+1 = 11 (write 1, carry 1)
• 1+0+1 = 10 (write 0, carry 1)
• 0+0+1 = 1, no carry

Result: 10100001 (= 161 in denary). Sanity check: 108 + 53 = 161 ✓.

Overflow. When the result needs MORE bits than you have available, the leftmost (overflow) bit is lost.

Worked example of overflow. Adding 11000000 + 11000000 in 8 bits:

• True sum = 110000000 (9 bits).
• 8-bit register can only hold 8 bits → MSB lost.
• Stored result: 10000000 (= 128 in denary, but the true sum was 384). Overflow has occurred.

Cambridge tip. The mark scheme typically awards: M1 for correct method, M1 for showing carries explicitly, A1 for the correct sum, B1 for noting overflow when relevant.

Computers need to store negative integers. The standard method is two's complement:

To represent −X in two's complement (n bits):

1. Write +X in n-bit binary.
2. Invert all bits (one's complement).
3. Add 1.

Worked example. Represent −37 in 8-bit two's complement.

1. +37 = 00100101.
2. Invert: 11011010.
3. Add 1: 11011011.

So −37 = 11011011 (8-bit two's complement).

Reading two's complement:

• If the MSB is 0: the number is positive, value computed as standard binary.
• If the MSB is 1: the number is negative, computed as: −2^(n−1) + (sum of remaining 1-bits' place values).

Worked example. What does 11011011 represent?

• MSB = 1, so negative.
• Place values: −128, 64, 32, 16, 8, 4, 2, 1.
• Bits: 1 1 0 1 1 0 1 1.
• Sum: −128 + 64 + 16 + 8 + 2 + 1 = −37. ✓

Range of n-bit two's complement. From −2^(n−1) to +(2^(n−1) − 1).

• 8 bits: −128 to +127.
• 16 bits: −32,768 to +32,767.

Why two's complement instead of just a 'sign bit'? Because two's complement makes addition and subtraction work with the same hardware adder — no special logic for negative numbers. It's elegant and efficient.

Cambridge tip. "Show how X is represented" questions ALWAYS want the three steps shown explicitly. M1 for converting +X, M1 for inverting, M1 for adding 1, A1 for the final answer. Skip a step, lose a mark.