Why is "Giving a binary answer with too few bits, e.g. writing 1001101 when 8 bits were asked for." a common mistake in Data Representation?

Why it happens: Students drop the leading zero(s) because they 'don't change the value', forgetting the question fixed the number of bits. How to avoid it: Always pad to the exact number of bits requested. Count your bits before writing the final answer. Source: Examiner reports repeatedly note lost marks from answers not given to the stated bit length.

Why is "Confusing BCD with a normal binary conversion — e.g. storing 49 as 00110001 (pure binary) instead of 0100 1001 (BCD)." a common mistake in Data Representation?

Why it happens: Both look like binary, so students convert the whole number rather than each digit separately. How to avoid it: In BCD, split the number into its decimal digits first, then convert EACH digit to 4 bits. 4→0100, 9→1001.

Why is "Stating the 8-bit two's complement range as −127 to +127 (symmetric)." a common mistake in Data Representation?

Why it happens: Students assume the negative and positive ranges are equal, mirroring sign-and-magnitude. How to avoid it: Remember zero counts as a positive value, so the negative side reaches one further: the range is −128 to +127. Source: A frequently penalised slip in two's complement questions.

Why is "Describing overflow vaguely as 'the number is too big' without mentioning the bits or the carry." a common mistake in Data Representation?

Why it happens: Students know the idea but don't use the precise, mark-scheme language. How to avoid it: Use the exact definition: overflow = a carry out of the most significant bit / the result will not fit in the available number of bits.

Why is "Writing hex values 10–15 as numbers (e.g. '1314') instead of letters A–F ('DE')." a common mistake in Data Representation?

Why it happens: Students convert each nibble to denary but forget to substitute the letter symbols. How to avoid it: Memorise A=10, B=11, C=12, D=13, E=14, F=15 and always replace any nibble value of 10–15 with its letter.

Why is "Reporting overflow in a two's complement subtraction just because a carry came out of the sign column." a common mistake in Data Representation?

Why it happens: Students apply the unsigned 'carry = overflow' rule to signed two's complement arithmetic. How to avoid it: In two's complement the final carry is simply discarded. Overflow is only present if the SIGN of the answer is wrong for the operands (e.g. positive + positive giving a negative result).

Cambridge International A Levels Computer Science (9618)

Data Representation

0% Complete

Detailed Study Notes

Detailed notes on Information representation for Cambridge International A Levels Computer Science, covering key concepts, explanations, examples, and exam-focused revision points.

Data Representation — Cambridge AS & A Level Computer Science 9618 Study Notes (2027-2029)

How computers store numbers and text using binary, hexadecimal and BCD; how to convert between number bases; how to add and subtract (including negatives in two's complement); what overflow is; and how characters are encoded with ASCII and Unicode. Everything here is done by hand — calculators are not allowed in Paper 1.

At a glance

Computers store everything as binary (base 2) — patterns of 0s and 1s.
Hexadecimal (base 16) is a shorthand for binary: 1 hex digit = 4 bits (1 nibble).
BCD stores each decimal digit in its own 4 bits (49 → 0100 1001).
Convert denary→binary using place values (128 64 32 16 8 4 2 1).
Two's complement stores negatives: flip the bits, add 1; MSB is the sign bit.
Overflow = a carry out of the most significant bit → the result won't fit and is wrong.
Subtraction = add the negative (two's complement); the final carry is discarded.
Text is stored with a character set: ASCII (7-bit/128, extended 8-bit/256) and Unicode (many more).
Binary prefixes (kibi 2^10, mebi 2^20, gibi 2^30, tebi 2^40) ≠ decimal prefixes (kilo 10^3, mega 10^6, …).

What you’ll learn

Mapped to the Cambridge International A Level 9618 syllabus (2027-2029).

1.1 — Show understanding of binary magnitudes and the difference between binary prefixes (kibi, mebi, gibi, tebi) and decimal prefixes (kilo, mega, giga, tera).
1.1 — Show understanding of binary, denary, hexadecimal and BCD, and one's and two's complement representation.
1.1 — Convert an integer value from one number base/representation to another.
1.1 — Perform binary addition and subtraction using positive and negative integers, and show understanding of how overflow can occur.
1.1 — Describe practical applications where BCD and hexadecimal are used.
1.1 — Represent character data in binary using ASCII, extended ASCII and Unicode (no codes need be memorised).

Why computers use binary

Two stable electronic states make binary the natural language of hardware.

A computer is built from millions of tiny switches (transistors) that are either on or off. These two states map perfectly onto the two binary digits:

off → 0
on → 1

Because there are only two states, signals are reliable (it is easy to tell 'on' from 'off', even with electrical noise). Every piece of data — numbers, text, images, sound — is ultimately stored as a pattern of these 0s and 1s called bits (binary digits).

Term	Meaning
Bit	a single 0 or 1
Nibble	4 bits
Byte	8 bits

Other number systems (denary, hexadecimal) are just convenient ways for humans to read and write those underlying binary patterns.

Transistors have two states → binary (0/1) is the natural fit.
Two states = reliable signals.
1 bit, 4 bits = nibble, 8 bits = byte.
Denary and hex are for humans; the machine works in binary.

Number bases: denary, binary, hexadecimal

Each base uses place values that are powers of its base.

Every number system gives each column a place value.

Denary (base 10) — columns are powers of 10: … 1000, 100, 10, 1.

Binary (base 2) — columns are powers of 2:

128	64	32	16	8	4	2	1

Hexadecimal (base 16) — columns are powers of 16 (… 256, 16, 1) and the sixteen symbols are 0–9 then A–F:

Hex	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F
Denary	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15

Why hexadecimal matters: one hex digit = exactly four bits (a nibble). That makes hex a short, readable shorthand for long binary strings — which is why it is everywhere (see §6).

Binary place values: 128 64 32 16 8 4 2 1.
Hex uses 0–9 and A–F (A=10 … F=15).
1 hex digit ⇄ 4 binary bits — convert in nibbles.

Converting between bases

Denary↔binary via place values; binary↔hex via nibbles.

Denary → binary (place-value method). Write the place values, then work left to right: at each column, if the value 'fits' into what's left, put 1 and subtract; otherwise put 0.

Example: 77. 128 no (0); 64 yes → 13 left (1); 32 no (0); 16 no (0); 8 yes → 5 left (1); 4 yes → 1 left (1); 2 no (0); 1 yes (1). 77 = 01001101.

Binary → denary. Add up the place values wherever there is a 1. 01001101 = 64+8+4+1 = 77.

Binary ⇄ hexadecimal (nibble method). Split the binary into groups of 4 from the right, then convert each nibble:

Hex → binary is the reverse: write each hex digit as its 4-bit pattern (D=1101, E=1110 → 11011110).

Hex → denary. Multiply each digit by its place value: 2F = (2×16) + (15×1) = 47.

Denary→binary: subtract place values left to right.
Binary→denary: add the place values where bits = 1.
Binary↔hex: work in nibbles (groups of 4 from the right).
Hex→denary: digit × place value (… 256, 16, 1).

See the full worked example for data representation →

Binary Coded Decimal (BCD)

Each decimal digit is stored in its own 4 bits.

BCD stores each decimal digit separately in 4 bits. This is different from converting the whole number to pure binary.

Example — store 49:

digit 4 → 0100
digit 9 → 1001
49 in BCD = 0100 1001 (compare with pure binary 00110001 — they are not the same).

Why use BCD?

Each digit maps directly to a display (e.g. a 7-segment display on a calculator, clock or till).
It avoids the rounding errors that happen when decimal fractions are converted to pure binary — useful for money values.

The trade-off: BCD wastes storage. With 4 bits you can make 16 patterns, but BCD only uses 0000–1001 (0–9); the six patterns 1010–1111 are never used. Pure binary represents the same range in fewer bits.

BCD = 4 bits per decimal digit.
Used in calculators, digital clocks, tills (direct display, exact money).
Patterns 1010–1111 are unused → less storage-efficient than pure binary.

See the full worked example for data representation →

Binary addition and overflow

Add column by column with carries; a carry out of the MSB means overflow.

Binary addition uses the same column method as denary, but you carry whenever a column reaches 2:

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

Example: 10110011 + 01010101 produces a 9-bit result 1 00001000. Only 8 bits are available, so the leading 1 is a carry out of the most significant bit.

Overflow happens when the result is too large to fit in the available number of bits — shown by a carry out of the most significant bit. The stored value is then incorrect.

For unsigned 8-bit numbers the largest value is 255, so any sum above 255 overflows.

Carry when a column totals 2 or 3.
Overflow = carry out of the most significant bit.
8-bit unsigned max = 255; sums above this overflow.
An overflowed result is wrong and must be flagged.

See the full worked example for data representation →

Negative numbers: two's complement

Flip the bits and add 1; subtraction becomes addition.

To store negative integers, 9618 uses two's complement. The leftmost bit becomes the sign bit (1 = negative, 0 = positive), and it carries a negative place value.

For 8 bits the place values are:

−128	64	32	16	8	4	2	1

To find a negative number — 'flip and add 1':

Write the positive value in binary.
One's complement: flip every bit.
Two's complement: add 1.

Example — −45: +45 = 00101101 → flip → 11010010 → +1 → 11010011.

Range (8-bit): −128 to +127. (It is asymmetric because 0 is counted as positive, so the negative side reaches one further.)

Subtraction = adding the negative. To compute A − B, find −B in two's complement and add it to A. Any final carry out of the sign column is simply discarded (this is not overflow as long as the result is in range).

Two's complement: flip the bits, add 1.
MSB is the sign bit with place value −128 (8-bit).
8-bit range = −128 to +127 (asymmetric).
Subtract by adding the negative; discard the final carry.

See the full worked example for data representation →

Representing characters: ASCII and Unicode

A character set maps each symbol to a unique binary code.

Text is stored using a character set — an agreed table that gives every character a unique binary code.

ASCII (American Standard Code for Information Interchange)

Uses 7 bits → 128 codes (letters, digits, punctuation, control characters).
Extended ASCII uses 8 bits → 256 codes (adds accented letters and symbols).
Useful fact: ASCII codes are ordered, so 'B' is one more than 'A', and the digits '0'–'9' are consecutive — handy for conversions.

Unicode

Uses more bits per character, giving room for the symbols of (almost) all the world's writing systems, plus emoji.
Every character has a unique code point, so documents in different languages can be stored and exchanged consistently.

Trade-off: Unicode can represent far more characters but generally needs more storage per character than ASCII.

(You are not required to memorise any specific codes — only how the systems work and why they differ.)

Character set = table mapping each symbol → unique binary code.
ASCII: 7-bit/128 codes; extended ASCII: 8-bit/256 codes.
Unicode: more bits → all writing systems + emoji.
Unicode needs more storage per character than ASCII.

Binary prefixes vs decimal prefixes

Memory uses powers of 2 (kibi…); storage marketing uses powers of 10 (kilo…).

Two different sets of prefixes describe quantities of bytes:

Decimal (SI) prefix	Value	Binary prefix	Value
kilo (kB)	10^3	kibi (KiB)	2^10 = 1,024
mega (MB)	10^6	mebi (MiB)	2^20
giga (GB)	10^9	gibi (GiB)	2^30
tera (TB)	10^12	tebi (TiB)	2^40

Why this matters in real life: a drive sold as 500 GB uses the decimal prefix (500 × 10^9 bytes). An operating system may report it using GiB (powers of 2). Since 2^30 is larger than 10^9, the same number of bytes is a smaller figure in GiB (≈ 465 GiB) — the capacity hasn't changed, only the unit.

Decimal prefixes = powers of 10 (kilo, mega, giga, tera).
Binary prefixes = powers of 2 (kibi 2^10, mebi 2^20, gibi 2^30, tebi 2^40).
Same byte count → fewer GiB than GB (2^30 > 10^9).

Quick recap

Binary is base 2; hex is base 16 with one hex digit = 4 bits (a nibble).
Convert denary→binary by subtracting place values; binary↔hex in nibbles.
BCD = 4 bits per decimal digit (49 → 0100 1001), wasting patterns 1010–1111.
Two's complement negatives: flip the bits and add 1; 8-bit range −128 to +127.
Overflow = a carry out of the most significant bit; the stored result is wrong.
Subtraction = add the negative; discard the final carry.
Characters use a character set: ASCII (7/8-bit) vs Unicode (many more, more storage).

Memorise this

Verbatim phrases and definitions Cambridge mark schemes credit.

Binary place values: 128 64 32 16 8 4 2 1.
Two's complement: flip the bits, then add 1.
Overflow = carry out of the most significant bit.
8-bit two's complement range = −128 to +127.
1 hex digit = 4 bits; A=10, B=11, C=12, D=13, E=14, F=15.
BCD = 4 bits per decimal digit.
Binary prefixes: kibi 2^10, mebi 2^20, gibi 2^30, tebi 2^40.

How it’s examined

Section 1.1 is assessed in Paper 1 (Theory Fundamentals, 1 h 30 min, 75 marks) — written, externally assessed, no calculator. Expect short structured questions: a 2–3 mark conversion (show working), a two's-complement representation, a binary addition with an overflow judgement, and 'state and explain' questions on BCD/hex applications and binary vs decimal prefixes. Always show working — method marks are available even when the final figure is wrong.

Sources: Cambridge International AS & A Level Computer Science 9618 syllabus (2027-2029), section 1.1. Last reviewed 2026-06-21.

Take this whole topic with you

Step-by-step worked examples — Data Representation

Step-by-step solutions to past-paper-style questions on data representation, written exactly the way a tutor would explain them at the board.

Question type:

1Convert denary 77 to 8-bit binary
Getting startedDirect calculation• 9618 Paper 1 style• binary, conversion, AO2
Question
Convert the denary number 77 to an 8-bit binary number. Show your working. (2 marks)
Step-by-step solution
1. Step 1
  Write the 8 place values (powers of 2) from left to right:
  $128 \;\; 64 \;\; 32 \;\; 16 \;\; 8 \;\; 4 \;\; 2 \;\; 1$
2. Step 2
  Work left to right. 128 > 77 → put 0. 64 ≤ 77 → put 1, remainder 77−64 = 13. 32 > 13 → 0. 16 > 13 → 0. 8 ≤ 13 → 1, remainder 5. 4 ≤ 5 → 1, remainder 1. 2 > 1 → 0. 1 ≤ 1 → 1, remainder 0.
3. Step 3
  Read the bits off: 0 1 0 0 1 1 0 1.
Answer
77 = 01001101
Examiner tip
1 mark for the correct method/working, 1 mark for the correct answer. Always pad to the number of bits asked for — a bare '1001101' may lose the answer mark when 8 bits were requested.
2Convert binary to hexadecimal (and to denary)
Getting startedDirect calculation• 9618 Paper 1 style• hexadecimal, conversion, AO2
Question
Convert the binary number 11011110 to hexadecimal, then to denary. (3 marks)
Step-by-step solution
1. Step 1
  Split the 8 bits into two nibbles (groups of 4) from the right: 1101 | 1110.
2. Step 2
  Convert each nibble. 1101 = 8+4+1 = 13 = D. 1110 = 8+4+2 = 14 = E. So the hex value is DE.
3. Step 3
  For denary, use place values 16 and 1: D=13 in the 16s column, E=14 in the 1s column.
  $(13 \times 16) + (14 \times 1) = 208 + 14 = 222$
Answer
11011110 = DE (hex) = 222 (denary)
Examiner tip
Grouping into nibbles is far safer than converting the whole number at once. Letters A–F are required — writing '1314' instead of 'DE' scores zero.
3Represent −45 in 8-bit two's complement
Building confidenceMulti-step problem• 9618 Paper 1 style• two's complement, negative numbers, AO2
Question
Show how the denary value −45 is represented as an 8-bit two's complement binary number. (3 marks)
Step-by-step solution
1. Step 1
  Write +45 in 8-bit binary first.
  $45 = 00101101$
2. Step 2
  Flip every bit (one's complement): 0→1 and 1→0.
  $00101101 \rightarrow 11010010$
3. Step 3
  Add 1 to get the two's complement.
  $11010010 + 1 = 11010011$
Answer
−45 = 11010011
Examiner tip
The reliable method is 'flip the bits, add 1'. Check: the leftmost (sign) bit is 1, confirming a negative number. A quick verification — 11010011 has value −128+64+16+2+1 = −45.
4Binary addition and detecting overflow
Building confidenceMulti-step problem• 9618 Paper 1 style• binary addition, overflow, AO2
Question
Add the 8-bit unsigned binary numbers 10110011 and 01010101. State whether overflow occurs and explain. (4 marks)
Step-by-step solution
1. Step 1
  Add column by column from the right, carrying where a column totals 2 or 3.
  $10110011 + 01010101$
2. Step 2
  Working right to left: 1+1=10 (write 0 carry 1); 1+0+1=10 (0 c1); 0+1+1=10 (0 c1); 0+0+1=1; 1+1=10 (0 c1); 1+0+1=10 (0 c1); 0+1+1=10 (0 c1); 1+0+1=10 (0 c1).
3. Step 3
  The sum needs 9 bits: 1 00001000. Only 8 bits are available, so the leading 1 is a carry out of the most significant bit.
4. Step 4
  A carry out of the most significant bit means the answer is too large to fit in 8 bits → overflow has occurred.
Answer
Result (9 bits) = 100001000; in 8 bits only 00001000 is kept. Overflow occurs because there is a carry out of the most significant bit.
Examiner tip
State the rule examiners want: overflow = a carry out of the most significant bit (the result will not fit in the available bits). Don't just say 'the number is too big' — name the carry.
5Binary subtraction using two's complement
StretchMulti-step problem• 9618 Paper 1 style• subtraction, two's complement, AO2
Question
Using 8-bit two's complement, calculate 01100100 − 00011001 (denary 100 − 25). Show your method. (4 marks)
Step-by-step solution
1. Step 1
  Subtraction is done by adding the negative: 100 − 25 = 100 + (−25). First find −25 in two's complement.
2. Step 2
  +25 = 00011001. Flip the bits → 11100110. Add 1 → 11100111 = −25.
  $00011001 \rightarrow 11100110 + 1 = 11100111$
3. Step 3
  Add 100 and −25.
  $01100100 + 11100111 = 1\,01001011$
4. Step 4
  There are 9 bits. In two's complement subtraction the carry out of the sign column is discarded, leaving 01001011 = 75. ✓ (100 − 25 = 75).
Answer
01100100 − 00011001 = 01001011 = 75 (denary). The final carry is discarded.
Examiner tip
Key A* discriminator: in two's complement, the carry out is simply ignored (it is NOT overflow here because the result is in range). Overflow would only be flagged if the sign of the result were wrong for the operands.
6Character encoding: ASCII codes and Unicode
StretchWord problem• 9618 Paper 1 style• character set, ASCII, Unicode, AO1, AO2
Question
(a) The ASCII code for the character 'A' is denary 65. State the ASCII code, in 8-bit binary, for the character 'C'. (b) Explain why a text file written using Unicode is typically larger than the same text written using ASCII. (4 marks)
Step-by-step solution
1. Step 1
  ASCII gives each character a unique code, and the codes for letters are consecutive. 'A' = 65, so 'B' = 66 and 'C' = 67.
2. Step 2
  Convert 67 to 8-bit binary using place values 64 32 16 8 4 2 1: 64 ≤ 67 → 1 (rem 3); 32,16,8,4 → 0; 2 ≤ 3 → 1 (rem 1); 1 ≤ 1 → 1. So 67 = 01000011.
  $67 = 64 + 2 + 1 = 0100\,0011$
3. Step 3
  ASCII stores each character in a single byte (7 bits, padded to 8). Unicode allocates more bits per character (e.g. 16 or more) so it can give a unique code to every character in (almost) all the world's writing systems.
4. Step 4
  Because each character occupies more bits in Unicode than in ASCII, storing the same number of characters needs more bytes — so the Unicode file is larger. (In return, Unicode can represent characters ASCII cannot.)
Answer
(a) 'C' = ASCII 67 = 01000011. (b) ASCII uses one byte per character, whereas Unicode uses more bits per character (e.g. 16+), so the same text needs more bytes of storage — the trade-off being that Unicode can represent far more characters (all writing systems, emoji, etc.).
Examiner tip
(a) 1 mark: 'C' = 67 → 01000011 (allow follow-through if they show 'C' = 'A' + 2). (b) up to 3 marks: ASCII = 1 byte/char (1); Unicode uses more bits per char (1); therefore more storage for the same text (1). The key AO2 point examiners reward is linking 'more bits per character' to 'larger file'.

Model Answers — Data Representation

High-scoring sample answers for data representation on the Cambridge IGCSE paper, with examiner-style notes mapping each response to the mark scheme and assessment objectives.

Question 1
9618 Paper 1 style2 marks
Convert the hexadecimal number 2F to denary. Show your working. (2 marks)
Model answer
2F has the digit 2 in the 16s column and F (=15) in the 1s column.

Working: (2 × 16) + (15 × 1) = 32 + 15 = 47.
Why this scores
1 mark for correct method (showing the place values 16 and 1, and F = 15), 1 mark for the answer 47. Working must be shown — a correct final number with no method can still earn full marks, but a wrong answer with no working earns zero.
Question 2
9618 Paper 1 style4 marks
Compare the ASCII character set with the Unicode character set. Your answer should make at least two comparison points. (4 marks)
Model answer
Number of characters: ASCII represents 128 characters (7-bit) or 256 with extended ASCII (8-bit), whereas Unicode can represent over a hundred thousand characters — enough for (almost) every writing system in the world.

Bits/storage per character: ASCII uses fewer bits per character (1 byte), whereas Unicode uses more bits per character (e.g. 16 bits or more), so Unicode text takes more storage for the same message.

Coverage of languages: ASCII covers mainly English letters, digits and common symbols, whereas Unicode includes non-Latin alphabets, accented characters and emoji.

(Any two clear A-does-X-whereas-B-does-Y comparison points earn full marks.)
Why this scores
Mark as comparison points (1 mark each, max 4) — each point MUST contrast both sets, e.g. 'ASCII uses 7/8 bits per character whereas Unicode uses 16+'. A one-sided statement ('ASCII is small') scores nothing without the contrasting half. Two well-developed contrasts (character count, bits per character) reach 4.
Question 3
9618 Paper 1 style4 marks
Explain what is meant by overflow when two binary integers are added, and state one consequence of overflow for a running program. (4 marks)
Model answer
What overflow is: Overflow occurs when the result of a binary addition is too large to be stored in the fixed number of bits available; specifically, a carry is generated out of the most significant bit. The extra bit cannot be stored, so the value that remains is incorrect.

Why it happens: A register or memory location holds a fixed number of bits (e.g. 8). The largest unsigned value in 8 bits is 255, so any sum greater than 255 cannot be represented.

Consequence for a program: The stored result will be wrong (often appearing as a much smaller value), which can produce incorrect calculations, corrupted output, or — if the value controls program flow — a crash or unexpected behaviour.
Why this scores
Marks for: (1) result too large for the available bits; (2) carry out of the most significant bit; (3) the kept value is therefore incorrect; (4) a sensible consequence. The phrase 'carry out of the most significant bit' is the high-value point that weaker answers miss.
Question 4
9618 Paper 1 style5 marks
A computer uses 8-bit two's complement to store integers. (a) Show how −18 is represented. (b) State the range of integers that can be stored in 8-bit two's complement. (5 marks)
Model answer
(a) Start with +18 in 8 bits: 18 = 00010010. Flip all the bits (one's complement): 11101101. Add 1: 11101101 + 1 = 11101110. So −18 = 11101110. (Check: −128 + 64 + 32 + 8 + 4 + 2 = −18 ✓)

(b) The most significant bit is the sign bit. The range is from −128 (10000000) to +127 (01111111), i.e. −128 to +127.
Why this scores
(a) 3 marks: +18 in binary (1), flip the bits (1), add 1 / correct final answer (1). (b) 2 marks: −128 (1) and +127 (1). A very common error is giving the range as −127 to +127 — two's complement is asymmetric because zero is positive, so the negative end reaches one further.
Question 5
9618 Paper 1 style6 marks
(a) Add the two 8-bit unsigned binary numbers 11001110 and 01100110. (b) State, with a reason, whether the 8-bit result is valid. (6 marks)
Model answer
(a) Adding column by column from the right:

11001110 (206) + 01100110 (102) ----------- 100110100

The full sum is 1 00110100 (9 bits), denary 308.

(b) The result is not valid in 8 bits. There is a carry out of the most significant bit (the leading 1), so overflow has occurred. The true answer 308 is greater than 255, the largest value 8 bits can hold; only the lower 8 bits 00110100 (=52) would be stored, which is incorrect.
Why this scores
(a) up to 3 marks for the correct addition/working (allow follow-through). (b) up to 3 marks: states not valid (1), identifies carry out of MSB / overflow (1), explains 308 > 255 so result won't fit / stored value wrong (1). Showing the denary check (206+102=308) is an efficient way to prove overflow under no-calculator conditions.
Question 6
9618 Paper 1 style6 marks
A supermarket till displays prices such as $12.95 on a 7-segment display and stores them using Binary Coded Decimal (BCD). (a) Explain one advantage of using BCD rather than pure binary for this application. (b) Explain one disadvantage of BCD compared with pure binary. (6 marks)
Model answer
(a) Advantage of BCD here: Each decimal digit is stored separately in its own 4 bits, so each digit maps directly to one symbol on the 7-segment display. This makes converting the stored value to the display very simple and fast, and it avoids the rounding errors that occur when decimal fractions (like .95) are converted to pure binary — important for accurate money values.

(b) Disadvantage of BCD: BCD is less efficient in its use of storage. With 4 bits per digit, six combinations (1010–1111) are never used, so BCD wastes storage space compared with pure binary, which can represent the same range of values in fewer bits. Arithmetic on BCD values is also more complex/slower for the processor than pure binary arithmetic.
Why this scores
Each side worth up to 3 marks (point + development + link to context). Strong answers tie the advantage to the application (display mapping / exact decimal money) and the disadvantage to wasted codes (1010–1111 unused) → storage inefficiency. Generic 'BCD is easier' without development caps the marks.

Key Definitions and Keywords — Data Representation

Definitions to memorise and the exact keywords mark schemes credit for data representation answers — sharpened from recent examiner reports for the 2026 Cambridge IGCSE sitting.

Binary (base 2)
Examiner keyword
A number system using only the digits 0 and 1, where each column is a power of 2. It is the system computers use internally because each digit maps to one of two electronic states.
Hexadecimal (base 16)
Examiner keyword
A number system using sixteen symbols 0–9 and A–F, where each hex digit represents exactly four binary bits (one nibble). Used as a compact, human-readable way of writing binary.
Example
Binary 1111 1010 = hex FA.
Binary Coded Decimal (BCD)
Examiner keyword
A representation in which each decimal digit is stored separately in 4 bits. For example, 49 is stored as 0100 1001 rather than as the pure binary 00110001.
Two's complement
Examiner keyword
A method of representing signed integers in binary. A negative number is formed by flipping all the bits of the positive value and adding 1; the most significant bit acts as the sign bit.
One's complement
A representation of a negative number formed by flipping (inverting) every bit of the positive value. Adding 1 to the one's complement gives the two's complement.
Overflow
Examiner keyword
The condition when the result of a calculation is too large to be stored in the available number of bits, shown by a carry out of the most significant bit. The stored result is then incorrect.
Most significant bit (MSB)
The leftmost bit of a binary number — the bit with the highest place value. In two's complement it is also the sign bit (1 = negative, 0 = positive).
Nibble
A group of 4 bits. One nibble corresponds to exactly one hexadecimal digit, which is why binary↔hex conversion is done in groups of four.
ASCII
Examiner keyword
American Standard Code for Information Interchange — a 7-bit character set giving a unique binary code to each letter, digit and symbol (128 codes). Extended ASCII uses 8 bits for 256 codes.
Unicode
Examiner keyword
A character set that uses more bits per character than ASCII so it can represent the characters of (almost) all the world's writing systems, including emoji, with a unique code for each.
Decimal (SI) prefix
A prefix based on powers of 10: kilo = 10^3, mega = 10^6, giga = 10^9, tera = 10^12. Used by storage manufacturers.
Binary prefix
Examiner keyword
A prefix based on powers of 2: kibi = 2^10, mebi = 2^20, gibi = 2^30, tebi = 2^40. Used to describe memory sizes exactly.

Common Mistakes and Misconceptions — Data Representation

The traps other students keep falling into on data representation questions — taken from recent Cambridge IGCSE examiner reports and mark schemes — and how to avoid them.

✕Giving a binary answer with too few bits, e.g. writing 1001101 when 8 bits were asked for.
Examiner reports repeatedly note lost marks from answers not given to the stated bit length.
Why it happens
Students drop the leading zero(s) because they 'don't change the value', forgetting the question fixed the number of bits.
How to avoid it
Always pad to the exact number of bits requested. Count your bits before writing the final answer.
✕Confusing BCD with a normal binary conversion — e.g. storing 49 as 00110001 (pure binary) instead of 0100 1001 (BCD).
Why it happens
Both look like binary, so students convert the whole number rather than each digit separately.
How to avoid it
In BCD, split the number into its decimal digits first, then convert EACH digit to 4 bits. 4→0100, 9→1001.
✕Stating the 8-bit two's complement range as −127 to +127 (symmetric).
A frequently penalised slip in two's complement questions.
Why it happens
Students assume the negative and positive ranges are equal, mirroring sign-and-magnitude.
How to avoid it
Remember zero counts as a positive value, so the negative side reaches one further: the range is −128 to +127.
✕Describing overflow vaguely as 'the number is too big' without mentioning the bits or the carry.
Why it happens
Students know the idea but don't use the precise, mark-scheme language.
How to avoid it
Use the exact definition: overflow = a carry out of the most significant bit / the result will not fit in the available number of bits.
✕Writing hex values 10–15 as numbers (e.g. '1314') instead of letters A–F ('DE').
Why it happens
Students convert each nibble to denary but forget to substitute the letter symbols.
How to avoid it
Memorise A=10, B=11, C=12, D=13, E=14, F=15 and always replace any nibble value of 10–15 with its letter.
✕Reporting overflow in a two's complement subtraction just because a carry came out of the sign column.
Why it happens
Students apply the unsigned 'carry = overflow' rule to signed two's complement arithmetic.
How to avoid it
In two's complement the final carry is simply discarded. Overflow is only present if the SIGN of the answer is wrong for the operands (e.g. positive + positive giving a negative result).

Data Representation

Detailed Study Notes

At a glance

What you’ll learn

Quick recap

Memorise this

How it’s examined

Take this whole topic with you

1Convert denary 77 to 8-bit binary

2Convert binary to hexadecimal (and to denary)

3Represent −45 in 8-bit two's complement

4Binary addition and detecting overflow

5Binary subtraction using two's complement

6Character encoding: ASCII codes and Unicode

Binary (base 2)

Hexadecimal (base 16)

Binary Coded Decimal (BCD)

Two's complement

One's complement

Overflow

Most significant bit (MSB)

Nibble

ASCII

Unicode

Decimal (SI) prefix

Binary prefix

✕Giving a binary answer with too few bits, e.g. writing 1001101 when 8 bits were asked for.

✕Confusing BCD with a normal binary conversion — e.g. storing 49 as 00110001 (pure binary) instead of 0100 1001 (BCD).

✕Stating the 8-bit two's complement range as −127 to +127 (symmetric).

✕Describing overflow vaguely as 'the number is too big' without mentioning the bits or the carry.

✕Writing hex values 10–15 as numbers (e.g. '1314') instead of letters A–F ('DE').

✕Reporting overflow in a two's complement subtraction just because a carry came out of the sign column.