Number Systems, Bases and Units of Information

Everything a computer stores — a photograph, a sentence, an exam mark, a network packet — is ultimately a pattern of bits. Before we can represent images, sound, text or signed integers, we need the foundations: what kinds of numbers exist, how the same value can be written in denary (base 10), binary (base 2) and hexadecimal (base 16), and how we measure quantities of information using bits, bytes and their prefixes. This lesson builds that foundation rigorously, with many worked two-way conversions, because every later topic in data representation depends on being fluent here.

Spec Mapping

This lesson covers the opening sections of the AQA A-Level Computer Science (7517) Fundamentals of data representation area:

Number types — classifying numbers as natural, integer, rational, irrational and real, and distinguishing ordinal use from cardinal/counting use.
Number bases — denary, binary and hexadecimal, including two-way conversions and the binary ↔ hexadecimal shortcut.
Units of information — the bit and the byte, multiples of the byte, and the distinction between the decimal (SI) prefixes kB/MB/GB/TB and the binary (IEC) prefixes kibibyte/mebibyte/gibibyte/tebibyte.

These ideas are assumed knowledge throughout the rest of the data-representation topic and reappear whenever capacities, address ranges or file sizes are calculated.

Number Types

A-Level expects you to classify numbers precisely. The standard sets, nested inside one another, are:

Set	Symbol	Members	Example values
Natural	$\mathbb{N}$	The counting numbers (AQA treats these as starting at 0)	0, 1, 2, 3, …
Integer	$\mathbb{Z}$	Natural numbers plus their negatives	…, −2, −1, 0, 1, 2, …
Rational	$\mathbb{Q}$	Any number expressible as a fraction $\frac{a}{b}$ with $a, b \in \mathbb{Z}$ and $b \neq 0$	$\frac{3}{4}$ , −5, 0.25, $0.\overline{3}$
Irrational	—	Real numbers that cannot be written as a fraction of integers	$\pi$ , $\sqrt{2}$ , $e$
Real	$\mathbb{R}$	Every rational and every irrational number — the whole continuous number line	all of the above

The nesting is one-directional: $\mathbb{N} \subset \mathbb{Z} \subset \mathbb{Q} \subset \mathbb{R}$ . Every natural number is an integer; every integer is rational (write $5$ as $\frac{5}{1}$ ); but not every rational is an integer, and irrationals sit inside the reals while lying outside the rationals.

A subtle exam point: a terminating or recurring decimal is always rational. $0.25 = \frac{1}{4}$ and $0.\overline{3} = \frac{1}{3}$ are both rational despite being written as decimals. Irrational numbers have decimal expansions that neither terminate nor repeat.

Ordinal versus cardinal use

The same numeral can be used in two distinct ways:

Cardinal (counting / measurement) — the number answers "how many?" or "how much?". There are 7 items in the basket.
Ordinal — the number answers "which position?" in an ordered sequence. She came 7th in the race.

In computing this distinction matters constantly. Array indices are ordinal (the element at position 3), whereas the length of the array is cardinal (it holds 10 elements). Confusing the two is the root cause of many off-by-one errors, which is exactly why AQA wants you to be conscious of the difference.

A second, related distinction is between counting and measurement. Counting is inherently discrete — you count whole items (3 files, 7 users), so the natural numbers suffice. Measurement is inherently continuous — height, time, temperature can take any value in a range, so the reals are needed. Computers, however, are finite and discrete: they cannot store a true continuum, so every "measured" real value must be approximated by a finite binary pattern. This single fact is the root of the precision limits explored in the floating-point lesson — a measured quantity such as $\sqrt{2}$ or $\tfrac13$ can only ever be stored as a nearby rational approximation.

Worked classification

Classify each value into the smallest standard set it belongs to:

Value	Smallest set	Reasoning
$42$	Natural ( $\mathbb{N}$ )	a non-negative whole number
$-17$	Integer ( $\mathbb{Z}$ )	whole but negative, so not natural
$\tfrac{7}{8}$	Rational ( $\mathbb{Q}$ )	a ratio of integers, not whole
$0.625$	Rational ( $\mathbb{Q}$ )	terminating decimal $= \tfrac58$
$\sqrt{2}$	Irrational	non-terminating, non-repeating; cannot be written as $\tfrac{a}{b}$
$\pi$	Irrational	likewise

Each value also belongs to every larger set ( $42$ is also an integer, rational and real), but the smallest set is the precise classification AQA rewards.

Exam Tip: When asked to classify a value, give the smallest set it belongs to as well as acknowledging the larger ones. $-7$ is "an integer (and therefore also rational and real)". Saying merely "real" is true but throws away marks. Remember the litmus test for rationality: any terminating or recurring decimal is rational; only never-ending, never-repeating expansions are irrational.

Number Bases

A positional number system assigns each digit a value determined by its position. In any base $b$ , the place values are successive powers of $b$ , and the value of a number is the weighted sum of its digits:

$N = \sum_{i} d_i \times b^{\,i}$

where $d_i$ is the digit in position $i$ (counting from 0 at the right-hand, least-significant end).

Denary (base 10)

Denary uses ten digits, 0–9. The number $4072$ means:

$(4 \times 10^3) + (0 \times 10^2) + (7 \times 10^1) + (2 \times 10^0) = 4000 + 0 + 70 + 2$

This is so familiar we never think about it — but the mechanism is identical in every base.

Binary (base 2)

Binary uses two digits, 0 and 1, and place values that are powers of 2. For an 8-bit number the columns are:

$\begin{array}{cccccccc} 2^7 & 2^6 & 2^5 & 2^4 & 2^3 & 2^2 & 2^1 & 2^0 \\ 128 & 64 & 32 & 16 & 8 & 4 & 2 & 1 \end{array}$

The leftmost bit is the most significant bit (MSB) and the rightmost the least significant bit (LSB).

Hexadecimal (base 16)

Hexadecimal uses sixteen digits. Since denary runs out at 9, the letters A–F stand for 10–15:

Hex	A	B	C	D	E	F
Denary	10	11	12	13	14	15

The hex place values are powers of 16:

$\begin{array}{cccc} 16^3 & 16^2 & 16^1 & 16^0 \\ 4096 & 256 & 16 & 1 \end{array}$

To avoid ambiguity we use subscripts ( $101_2$ versus $101_{10}$ ) or, in programming, a prefix such as 0b for binary and 0x for hex. So 0xFF is hexadecimal FF, not the denary number 255 written out — though of course they are equal.

Worked Conversions

Binary → Denary

Add the place values wherever a 1 appears. Convert $\texttt{10110101}_2$ :

Bit	1	0	1	1	0	1	0	1
Place value	128	64	32	16	8	4	2	1
Contributes	128	—	32	16	—	4	—	1

$128 + 32 + 16 + 4 + 1 = \mathbf{181_{10}}$

Denary → Binary (subtraction method)

To convert $181_{10}$ back, repeatedly subtract the largest place value that fits, writing a 1 in that column and 0 where a value does not fit:

$181 - 128 = 53 \quad (1 \text{ under } 128)$ $53 - 32 = 21 \quad (1 \text{ under } 32)$ $21 - 16 = 5 \quad (1 \text{ under } 16)$ $5 - 4 = 1 \quad (1 \text{ under } 4)$ $1 - 1 = 0 \quad (1 \text{ under } 1)$

Every other column gets a 0, giving $\mathbf{181_{10} = 10110101_2}$ — which matches our forward conversion. Always sanity-check by converting back.

Denary → Binary (repeated division)

An equivalent algorithm divides repeatedly by 2 and reads the remainders bottom-to-top. For $181$ :

Division	Quotient	Remainder
$181 \div 2$	90	1
$90 \div 2$	45	0
$45 \div 2$	22	1
$22 \div 2$	11	0
$11 \div 2$	5	1
$5 \div 2$	2	1
$2 \div 2$	1	0
$1 \div 2$	0	1

Reading the remainders from bottom to top: $10110101_2$ . Identical answer, different method — use whichever you find more reliable under exam pressure.

def denary_to_binary(n: int) -> str:
    if n == 0:
        return "0"
    bits = ""
    while n > 0:
        bits = str(n % 2) + bits   # prepend the remainder
        n = n // 2                 # integer-divide by 2
    return bits

print(denary_to_binary(181))   # 10110101

Denary → Hexadecimal (repeated division by 16)

Convert $700_{10}$ to hex by repeated division by 16, reading remainders bottom-to-top:

$700 \div 16 = 43 \ \text{remainder}\ 12 \ (\text{C})$ $43 \div 16 = 2 \ \text{remainder}\ 11 \ (\text{B})$ $2 \div 16 = 0 \ \text{remainder}\ 2$

Reading upward: $\mathbf{700_{10} = 2BC_{16}}$ .

Hexadecimal → Denary

Multiply each digit by its place value. For $2BC_{16}$ , recall $B = 11$ and $C = 12$ :

$(2 \times 256) + (11 \times 16) + (12 \times 1) = 512 + 176 + 12 = \mathbf{700_{10}}$

The round trip confirms the answer.

The Binary ↔ Hexadecimal Shortcut

Because $16 = 2^4$ , one hexadecimal digit corresponds to exactly four binary digits (one nibble). This makes conversion between binary and hex almost instant — no denary detour required.

Binary → Hex

Group the bits into nibbles from the right, padding the leftmost group with leading zeros if necessary, then translate each nibble:

Convert $\texttt{1101011010}_2$ . Grouping from the right gives $11\,0101\,1010$ ; pad the left group to $0011$ :

$\underbrace{0011}_{\text{3}} \ \underbrace{0101}_{\text{5}} \ \underbrace{1010}_{\text{A}}$

$\mathbf{1101011010_2 = 35A_{16}}$

Hex → Binary

Expand each hex digit to its 4-bit nibble. Convert $\texttt{C9}_{16}$ :

$C \rightarrow 1100, \qquad 9 \rightarrow 1001$ $\mathbf{C9_{16} = 11001001_2}$

This is why hexadecimal is the preferred shorthand for memory dumps, machine code, MAC addresses and colour codes — a byte is exactly two hex digits, so eight 1s and 0s collapse to two readable characters with no loss of information.

Exam Tip: When grouping binary into nibbles, always start from the right-hand (least-significant) end. Grouping from the left is a classic error that corrupts every digit if the bit-count is not a multiple of four.

Conversion Practice and Useful Patterns

Fluency comes from recognising patterns rather than grinding every conversion from first principles. A few worth internalising:

The "all ones" and "single one" patterns

An $n$ -bit value of all ones is always $2^n - 1$ . So $\texttt{1111}_2 = 15$ , $\texttt{11111111}_2 = 255$ , and $\texttt{1111}_{16}$ expanded — i.e. $\texttt{FFFF}_{16}$ — is $2^{16} - 1 = 65{,}535$ . Conversely a single 1 in position $k$ is exactly $2^k$ : $\texttt{00010000}_2 = 2^4 = 16$ . Spotting these lets you check answers instantly.

Powers of two you should know on sight

$2^n$	Value	$2^n$	Value
$2^0$	1	$2^8$	256
$2^1$	2	$2^9$	512
$2^2$	4	$2^{10}$	1024
$2^3$	8	$2^{16}$	65 536
$2^4$	16	$2^{20}$	1 048 576
$2^5$	32	$2^{24}$	16 777 216
$2^6$	64	$2^{30}$	1 073 741 824
$2^7$	128	$2^{32}$	4 294 967 296

Knowing $2^{10} = 1024$ , $2^{20} \approx 1$ million and $2^{30} \approx 1$ billion makes capacity and addressing questions almost instant.

A fully worked three-way conversion

Take the denary value $429$ and express it in binary and hex, then cross-check using the nibble shortcut.

Denary → binary (subtraction method): the largest power of two not exceeding 429 is $256 = 2^8$ .

$429 - 256 = 173 \ (1 \text{ at } 2^8)$ $173 - 128 = 45 \ (1 \text{ at } 2^7)$ $45 - 32 = 13 \ (1 \text{ at } 2^5)$ $13 - 8 = 5 \ (1 \text{ at } 2^3)$ $5 - 4 = 1 \ (1 \text{ at } 2^2)$ $1 - 1 = 0 \ (1 \text{ at } 2^0)$

Filling zeros elsewhere gives a 9-bit number $\texttt{1}\,\texttt{1010}\,\texttt{1101}_2$ , i.e. $\texttt{110101101}_2$ .

Binary → hex (nibble shortcut): group from the right and pad the left group to four bits — $0001\,1010\,1101$ :

$\underbrace{0001}_{\text{1}} \ \underbrace{1010}_{\text{A}} \ \underbrace{1101}_{\text{D}}$

So $429_{10} = \texttt{1AD}_{16}$ .

Cross-check, hex → denary: $(1 \times 256) + (10 \times 16) + (13 \times 1) = 256 + 160 + 13 = 429$ ✓. Three representations of one value, each verifying the others — this is exactly the discipline that protects marks in the exam.

Why these three bases?

Denary is the human everyday base; binary is what the hardware physically stores (two stable voltage states are cheap and reliable to build); and hexadecimal is the human-friendly shorthand for binary because of the clean four-bits-per-digit relationship. Octal (base 8, three bits per digit) exists for the same shorthand reason but is far less common in modern systems. There is nothing "natural" about base 10 to a computer — we use it only because people have ten fingers.

To see the shorthand idea once more in a different base, consider octal: because $8 = 2^3$ , one octal digit maps to exactly three binary bits. So $\texttt{11010110}_2$ , grouped into threes from the right ( $11\,010\,110$ , padding the left group to $011$ ), becomes $011\,010\,110 = 3\,2\,6$ , i.e. $\texttt{326}_8$ . Checking back to denary: $(3 \times 64) + (2 \times 8) + (6 \times 1) = 192 + 16 + 6 = 214$ , and $\texttt{11010110}_2 = 128+64+16+4+2 = 214$ ✓. The same grouping principle that gives hex its four-bit nibbles gives octal its three-bit groups — the size of the group is just $\log_2$ of the base. This is the single unifying idea behind every binary-to-power-of-two-base conversion.

Exam Tip: If a conversion looks long, look for a shortcut: convert via hex (using nibbles) rather than doing a 16-step binary subtraction, or spot an "all ones" / "power of two" pattern. Showing a sensible method earns method marks even if the final arithmetic slips.

Units of Information

Bit, nibble, byte

A bit (binary digit) is the smallest unit of information — a single 0 or 1.
A nibble is 4 bits (one hex digit).
A byte is 8 bits. A byte can represent $2^8 = 256$ distinct values (0–255 unsigned). The byte is the fundamental addressable unit of memory on virtually all modern machines.

With $n$ bits you can represent $2^n$ distinct patterns. This single formula underpins capacity, range and addressing calculations throughout the course:

$\text{distinct patterns from } n \text{ bits} = 2^n$

The reason a shared, standardised set of units matters cannot be overstated. If one manufacturer measured storage in groups of seven bits and another in groups of nine, files and devices simply would not interoperate. The byte (8 bits) became the universal unit early in computing history because eight bits is enough to hold one character in extended ASCII, is a convenient power of two, and divides cleanly into nibbles for hex notation. Almost every modern architecture is therefore byte-addressable — the smallest chunk of memory the processor can read or write individually is one byte — which is exactly why capacities, file sizes and memory are all quoted in bytes and their multiples rather than in raw bits. When a quantity is given in bits (network speeds, for example, are quoted in bits per second), the lower-case 'b' versus upper-case 'B' distinction becomes critical: 100 Mb/s is one-eighth of 100 MB/s, a factor-of-eight error that trips up the unwary.

Multiples of the byte: decimal vs binary prefixes

Here is one of the most examined — and most misunderstood — points in the whole topic. There are two families of multiplier prefixes, and they are not equal.

Decimal (SI) prefixes use powers of 1000 ( $10^3$ ). These are the prefixes used by storage manufacturers and by formal SI:

Prefix	Name	Bytes
kB	kilobyte	$10^3 = 1{,}000$
MB	megabyte	$10^6 = 1{,}000{,}000$
GB	gigabyte	$10^9 = 1{,}000{,}000{,}000$
TB	terabyte	$10^{12} = 1{,}000{,}000{,}000{,}000$

Binary (IEC) prefixes use powers of 1024 ( $2^{10}$ ). These were introduced precisely to remove the historical ambiguity, and are the values an operating system typically reports:

Prefix	Name	Bytes
KiB	kibibyte	$2^{10} = 1{,}024$
MiB	mebibyte	$2^{20} = 1{,}048{,}576$
GiB	gibibyte	$2^{30} = 1{,}073{,}741{,}824$
TiB	tebibyte	$2^{40} \approx 1.0995 \times 10^{12}$

Notice $2^{10} = 1024$ is close to but larger than $10^3 = 1000$ , and the gap widens with each step. By the terabyte/tebibyte level a "TB" and a "TiB" differ by nearly 10%.

This is exactly why a hard drive sold as "1 TB" shows up in the operating system as roughly 931 GiB: the manufacturer counts $10^{12}$ bytes, while the OS divides by $1024$ three times.

$\frac{10^{12}}{2^{40}} = \frac{1{,}000{,}000{,}000{,}000}{1{,}099{,}511{,}627{,}776} \approx 0.909 \Rightarrow 1\,\text{TB} \approx 931\,\text{GiB}$

Exam Tip: If a question uses the kibi/mebi/gibi names or explicitly says "binary prefixes", use 1024. If it uses plain "kilobyte/megabyte" you may be expected to use 1000 — but read the question: many AQA legacy questions still treat 1 kB as 1024 bytes. Where the intended convention is stated, follow it exactly and state your assumption if it is ambiguous.

Worked capacity calculations

Capacity questions reward laying the arithmetic out in clear steps with units at every stage. Two worked examples:

(1) How many bytes in 4 MiB? Using binary prefixes, $1 \text{ MiB} = 2^{20}$ bytes:

$4 \text{ MiB} = 4 \times 2^{20} = 2^2 \times 2^{20} = 2^{22} = 4{,}194{,}304 \text{ bytes}$

Keeping it in index form ( $2^{22}$ ) is both quicker and less error-prone than multiplying out — a good habit the examiner rewards.

(2) How many 8-bit characters fit in 16 KiB? A character here is one byte, and $16 \text{ KiB} = 16 \times 1024 = 16{,}384$ bytes:

$\frac{16 \times 2^{10} \text{ bytes}}{1 \text{ byte/char}} = 2^4 \times 2^{10} = 2^{14} = 16{,}384 \text{ characters}$

Bits, bytes and memory addressing

The $2^n$ pattern-count formula also governs how much memory a processor can address. If an address bus is $n$ bits wide, it can specify $2^n$ distinct addresses; if each address holds one byte, the maximum directly addressable memory is $2^n$ bytes. For example:

Address bus width	Addressable locations	Capacity (byte-addressed)
16-bit	$2^{16} = 65{,}536$	64 KiB
20-bit	$2^{20}$	1 MiB
32-bit	$2^{32}$	4 GiB
64-bit	$2^{64}$	16 EiB (effectively unlimited today)

This is the historical reason 32-bit operating systems were capped at 4 GiB of usable RAM — $2^{32}$ byte-addresses is the hard ceiling of a 32-bit address bus — and why the move to 64-bit addressing was necessary. It is also why memory addresses are quoted in hexadecimal: a 32-bit address is exactly 8 hex digits (e.g. 0x7FFFFFFF), neatly two per byte, looping us right back to the binary-hex nibble shortcut. Bits, bytes, bases and units are one connected system, which is precisely the synoptic understanding this lesson is building toward.

Synoptic Links

Two's complement & unsigned arithmetic (§4.5.4) — the $2^n$ pattern-count formula derived here fixes the ranges of signed and unsigned $n$ -bit integers in the next lesson.
Hexadecimal & memory addressing (§4.6 / §4.7.3 internal hardware, registers & buses) — addresses, machine-code instructions and the contents of registers are conventionally shown in hex precisely because of the one-digit-per-nibble shortcut.
Hexadecimal & colour codes (§4.5.6 representing images) — a 24-bit RGB colour is written as six hex digits (e.g. #FF8800), two per channel.
File-size & capacity calculations (§4.5.6 images & sound, §4.4 networking) — every bitmap size, sample-rate and bandwidth calculation rests on the units of information defined here.
Number types & data types in programming (§4.1 / §4.2.7) — the natural/integer/real distinction maps directly onto the integer, real/float and boolean data types you declare in code.

Common Misconceptions

"1 kB always equals 1000 bytes." Not in computing contexts. It depends on whether decimal (1000) or binary (1024) prefixes are intended. The kibibyte (KiB) was created specifically to mean 1024 unambiguously.
"A byte is 8 bits, so a nibble must be 2 bits." A nibble is 4 bits — half a byte and exactly one hex digit.
"Hex is a completely different way of storing data inside the machine." Hex is only a human-readable notation for binary. The computer stores bits; hex is how we write those bits down compactly.
"Decimals like 0.5 are irrational." No — $0.5 = \frac{1}{2}$ is rational. Irrational numbers (like $\pi$ and $\sqrt{2}$ ) have non-terminating, non-repeating expansions.
"Grouping binary into nibbles from the left is fine." It corrupts the value whenever the number of bits is not a multiple of four. Always group from the right and pad the left.
" $2^n$ is the largest number you can store in $n$ bits." It is the number of patterns; the largest unsigned value is $2^n - 1$ because one pattern represents zero.

Specimen Question

A games console stores a 24-bit colour as three 8-bit channels (red, green, blue). A texture file is described as being 512 KiB in size. (Total: 9 marks)

(a) Convert the hexadecimal colour value 2F to (i) binary and (ii) denary, showing your working. [3]

(b) Convert the bit pattern 11100110 to hexadecimal. [2]

(c) State how many distinct colours can be represented using 24 bits, giving your answer as a power of 2 and as an approximate decimal value. [2]

(d) Express 512 KiB exactly in bytes, and explain why this differs from "512 kB" interpreted with decimal prefixes. [2]

AO breakdown:

Mark	AO	Awarded for
1	AO2	(a)(i) Correct nibble expansion 2 → 0010, F → 1111
2	AO1	(a)(ii) Correct hex place values (16 and 1) used
3	AO2	(a)(ii) Correct denary value 47
4	AO2	(b) Correct grouping into 1110 and 0110
5	AO2	(b) Correct hex digits giving E6
6	AO1	(c) Stating $2^{24}$ distinct colours
7	AO2	(c) Approximate decimal value ≈ 16.7 million
8	AO2	(d) 512 KiB = 524 288 bytes
9	AO3	(d) Explaining the binary-prefix reason (×1024 not ×1000)

AO split: AO1 = 2, AO2 = 6, AO3 = 1.

Mid-band response

(a)(i) 2 is 0010 and F is 1111, so 2F is 00101111. (ii) F is 15 and 2 is in the 16s column. $2 \times 16 = 32$ and $15 \times 1 = 15$ , so $32 + 15 = 47$ . (b) Split 11100110 into 1110 and 0110. 1110 is E and 0110 is 6, so it is E6. (c) 24 bits gives $2^{24}$ colours, which is about 16 million. (d) 512 KiB is $512 \times 1024 = 524288$ bytes. It is bigger than 512 kB because KiB uses 1024.

Examiner-style commentary: Marks 1–6 and mark 8 are all secured, and the candidate reaches the $2^{24}$ statement for mark 6. Mark 7 is borderline — "about 16 million" is close but imprecise; a stronger answer pins it to ≈16.7 million. Mark 9 is not awarded: the candidate states KiB uses 1024 but never contrasts it with the decimal interpretation (×1000 → 512 000 bytes), so the explanation of the difference is incomplete. Around 7/9.

Stronger response

(a)(i) Expanding each hex digit: 2 → 0010, F → 1111, so $\texttt{2F}_{16} = 00101111_2$ . (ii) Place values $16^1$ and $16^0$ : $(2 \times 16) + (15 \times 1) = 32 + 15 = 47_{10}$ . (b) Grouping from the right: $1110\,0110$ ; $1110 = \text{E}$ , $0110 = 6$ , so $\texttt{11100110}_2 = \texttt{E6}_{16}$ . (c) $2^{24} = 16{,}777{,}216$ distinct colours (≈16.7 million). (d) $512 \text{ KiB} = 512 \times 2^{10} = 524{,}288$ bytes. Interpreted as decimal "512 kB" it would be $512 \times 1000 = 512{,}000$ bytes, so the binary figure is 12 288 bytes larger.

Examiner-style commentary: All nine marks are within reach. The conversions are flawless and the candidate gives the exact $2^{24}$ value rather than a vague "16 million". The decimal contrast for mark 9 is present but stated arithmetically rather than explained in principle — a top-band answer would add why the two prefix systems exist.

Top-band response

(a)(i) Each hex digit maps to one nibble: $2 \rightarrow 0010$ , $F \rightarrow 1111$ , hence $\texttt{2F}_{16} = 00101111_2$ . (ii) Using hex place values: $(2 \times 16^1) + (15 \times 16^0) = 32 + 15 = 47_{10}$ ; a back-check from the binary gives $32 + 8 + 4 + 2 + 1 = 47$ . (b) Grouping the byte from the right into nibbles gives $1110\,0110$ ; since $1110 = 14 = \text{E}$ and $0110 = 6$ , we have $\texttt{11100110}_2 = \texttt{E6}_{16}$ . (c) With 24 bits there are $2^{24} = 16{,}777{,}216$ distinct patterns, so ≈16.7 million colours — this is why 24-bit colour is called "true colour", being beyond the discriminating power of the human eye. (d) A kibibyte is $2^{10} = 1024$ bytes, so $512 \text{ KiB} = 512 \times 1024 = 524{,}288$ bytes exactly. The decimal kilobyte uses $10^3 = 1000$ , giving $512{,}000$ bytes for "512 kB" — a difference of 12 288 bytes (≈2.4%). The two systems coexist because storage manufacturers adopted the SI powers of ten while memory and operating systems naturally count in powers of two (addresses are binary); the IEC kibi/mebi prefixes were introduced precisely to remove this ambiguity.

Examiner-style commentary: Full marks. The discriminators are the exact $2^{24}$ value (mark 7), the explicit decimal-vs-binary byte counts and the principled reason for the two prefix families (marks 8–9, including AO3 evaluation), and the disciplined back-check in (a)(ii). The candidate demonstrates that hex, binary and units of information are one connected system rather than isolated tricks.

Going Further

Other bases in computing. Octal (base 8, three bits per digit) appears in Unix file-permission notation (e.g. chmod 755). Base-64 encoding packs binary data into printable ASCII for email attachments and data URIs — investigate how 3 bytes (24 bits) map to 4 base-64 characters.
Why $2^{10} \approx 10^3$ . This near-coincidence ( $1024$ vs $1000$ ) is the historical reason the prefixes were ever conflated. Explore how the error compounds: the discrepancy is ~2.4% at kilo but grows to ~10% by tera.
BCD (Binary-Coded Decimal). Some systems store each denary digit in its own nibble rather than converting the whole number to pure binary — common in financial and display hardware where exact decimal behaviour matters. Compare its storage efficiency against pure binary.
Floating-point preview. The natural/integer/real classification you met here foreshadows why representing real numbers in a finite number of bits is fundamentally lossy — the subject of the floating-point lesson later in this course.

This content is aligned with the AQA A-Level Computer Science (7517) specification.

Number Systems, Bases and Units of Information

Number Systems, Bases and Units of Information

Spec Mapping

Number Types

Ordinal versus cardinal use

Worked classification

Number Bases

Denary (base 10)

Binary (base 2)

Hexadecimal (base 16)

Worked Conversions

Binary → Denary

Denary → Binary (subtraction method)

Denary → Binary (repeated division)

Denary → Hexadecimal (repeated division by 16)

Hexadecimal → Denary

The Binary ↔ Hexadecimal Shortcut

Binary → Hex

Hex → Binary

Conversion Practice and Useful Patterns

The "all ones" and "single one" patterns

Powers of two you should know on sight

A fully worked three-way conversion

Why these three bases?

Units of Information

Bit, nibble, byte

Multiples of the byte: decimal vs binary prefixes

Worked capacity calculations

Bits, bytes and memory addressing

Synoptic Links

Common Misconceptions

Specimen Question

Mid-band response

Stronger response

Top-band response

Going Further

More in Computer Science