Information representation
Number bases, prefixes and BCD
What you need to be able to do
- 1.1Explain the difference between binary prefixes (kibi, mebi, gibi, tebi: powers of 1024) and decimal prefixes (kilo, mega, giga, tera: powers of 1000) and convert between them.
- 1.1Use the binary, denary and hexadecimal number bases and Binary Coded Decimal (BCD).
- 1.1Convert an integer from any of these to any other, showing working when asked.
- 1.1Work out how many values n bits can hold and the fewest bits a value needs.
- 1.1Describe practical uses of BCD and hexadecimal, with a reason for each.
Nothing before this: it is the first page of the course. Next: Negative numbers and binary arithmetic, which adds one's and two's complement.
Binary and decimal prefixes
A computer stores everything as bits (binary digits, 0 or 1). Eight bits make a byte. Large amounts are written with a prefix, and there are two families of prefix because memory is built in powers of 2 while everyday measurement uses powers of 10.
| Decimal (denary) prefix | Value | Binary prefix | Value |
|---|---|---|---|
| kilobyte (kB) | \(10^3=1000\) bytes | kibibyte (KiB) | \(2^{10}=1024\) bytes |
| megabyte (MB) | \(10^6=1000\) kB | mebibyte (MiB) | \(2^{20}=1024\) KiB |
| gigabyte (GB) | \(10^9=1000\) MB | gibibyte (GiB) | \(2^{30}=1024\) MiB |
| terabyte (TB) | \(10^{12}=1000\) GB | tebibyte (TiB) | \(2^{40}=1024\) GiB |
The rule in one line
Each step up the decimal ladder multiplies by 1000; each step up the binary ladder multiplies by 1024. The two ladders never mix: a tebibyte is 1024 gibibytes, not 1024 gigabytes.
How to spot which is which
The binary prefixes all contain “bi” (kibi, mebi, gibi, tebi) and their symbols an i (KiB, MiB). No “bi” = decimal.
Bits or bytes?
1 byte = 8 bits, so 1 kilobyte = 8000 bits and 1 kibibyte = 8 × 1024 = 8192 bits. Say “bytes” when you mean bytes: “a kilobyte is 1000 bits” was marked wrong.
The binary one is bigger
Same number, binary prefix = more bytes: 1 KiB (1024) > 1 kB (1000); 1 MiB = 1 048 576 bytes > 1 MB = 1 000 000 bytes. The gap grows at every step (1 TiB is about 10% more than 1 TB).
How to convert between prefixes
- Write the amount in bytes first: multiply by 1000 for each decimal step, or 1024 for each binary step.
- Then divide by 1000s or 1024s to reach the unit the question asks for.
- To compare amounts in different prefixes ("which file is largest?"), convert them all to bytes and compare.
1 Binary prefix to bytes
How many bytes are 5 KiB?
AskedbytesKnow1 KiB = 1024 BRoute× 1024
- 5 × 1024 = 5120 bytes
2 Decimal prefix down a step
How many gigabytes are 3 TB?
AskedGBKnow1 TB = 1000 GBRoute× 1000
- 3 × 1000 = 3000 GB
3 Binary prefix two steps down
How many kibibytes are 2 GiB?
AskedKiBKnowGiB → MiB → KiBRoute× 1024 twice
- 2 × 1024 = 2048 MiB
- 2048 × 1024 = 2 097 152 KiB
4 Which is larger?
Which is larger: 2 MiB or 2100 kB?
AskedcompareKnowboth to bytesRouteconvert then compare
- 2 MiB = 2 × 1024 × 1024 = 2 097 152 bytes
- 2100 kB = 2100 × 1000 = 2 100 000 bytes
- 2100 kB is (just) larger
Never compare the numbers in front of the prefixes. Convert both to bytes.
5 Bits to a binary prefix
How many KiB are 81 920 bits?
AskedKiBKnow8 bits = 1 byte, 1024 bytes = 1 KiBRoute÷ 8 then ÷ 1024
- 81 920 ÷ 8 = 10 240 bytes
- 10 240 ÷ 1024 = 10 KiB
Number bases and place value
A number base is how many different digits a system uses. Every system works the same way: each column is worth the base times the column to its right.
| Base | Digits used | Column values (right to left) | Written as |
|---|---|---|---|
| Denary (base 10) | 0-9 | 1, 10, 100, 1000 … | 45 |
| Binary (base 2) | 0, 1 | 1, 2, 4, 8, 16, 32, 64, 128 … | 101101 |
| Hexadecimal (base 16) | 0-9 and A-F (A = 10 … F = 15) | 1, 16, 256, 4096 … | 2D (or &2D in assembly code) |
The same value, 45, in all three:
| 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | |||
|---|---|---|---|---|---|---|---|---|---|---|
| Binary | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 1 |
How many values do n bits hold?
Number of different values
n bits can make \(2^n\) different patterns. 8 bits: \(2^8=256\) values; 16 bits: \(2^{16}=65\,536\).
Largest unsigned value
The patterns start at 0, so the largest is \(2^n-1\). 8 bits: 0 to 255; 12 bits: 0 to 4095.
Fewest bits for a value
Find the smallest n with \(2^n\) greater than the value (or at least the number of different values needed). 200 needs 8 bits (\(2^7=128\) is too few); 256 different colours need exactly 8 bits.
Values vs largest value
“How many values can 16 bits represent?” = 65 536. “Largest value in 16 bits?” = 65 535. Mixing these up was a common error.
Binary and denary
Binary to denary
- Write the place values (1, 2, 4, 8 …) above the bits, starting with 1 at the right.
- Add up the place values that have a 1 under them.
- Check: an odd number ends in 1; the answer can't be more than \(2^n-1\).
| 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | |||
|---|---|---|---|---|---|---|---|---|---|---|
| Bits | 1 | 0 | 0 | 1 | 1 | 1 | 0 | 0 |
Denary to binary: two methods, same example (156)
Method A: subtract the biggest place value that fits
- List the place values up to the one just above your number: 128, 64, 32, 16, 8, 4, 2, 1.
- Does 128 fit into 156? Yes: write 1, and 156 − 128 = 28 is left.
- 64? No: 0. 32? No (28 < 32): 0. 16? Yes: 1, 28 − 16 = 12 left.
- 8? Yes: 1, 4 left. 4? Yes: 1, 0 left. 2 and 1: 0, 0.
- Read the bits left to right: 1001 1100.
Method B: keep dividing by 2, read the remainders upwards
| Divide | Answer | Remainder |
|---|---|---|
| 156 ÷ 2 | 78 | 0 |
| 78 ÷ 2 | 39 | 0 |
| 39 ÷ 2 | 19 | 1 |
| 19 ÷ 2 | 9 | 1 |
| 9 ÷ 2 | 4 | 1 |
| 4 ÷ 2 | 2 | 0 |
| 2 ÷ 2 | 1 | 0 |
| 1 ÷ 2 | 0 | 1 |
- Divide by 2 and write the remainder (0 or 1) each time, until the answer is 0.
- The first remainder is the rightmost bit, so read the remainders from the bottom up: 1001 1100.
- Pad with 0s on the left to the number of bits asked for (8-bit, 12-bit …).
Hexadecimal
Hexadecimal (hex) has 16 digits, 0-9 then A-F. The reason it is used in computing: one hex digit is exactly four bits (a nibble), because \(16=2^4\). So a byte is always two hex digits, and converting is just grouping.
| Denary | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Hex | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
| Binary | 0000 | 0001 | 0010 | 0011 | 0100 | 0101 | 0110 | 0111 | 1000 | 1001 | 1010 | 1011 | 1100 | 1101 | 1110 | 1111 |
Binary to hex
- Split the bits into groups of four from the right. If the left group is short, pad it with 0s.
- Turn each group into one hex digit (8 4 2 1 place values, 10-15 become A-F).
- Write the digits in the same order.
| 8 | 4 | 2 | 1 | 8 | 4 | 2 | 1 | 8 | 4 | 2 | 1 | ||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Binary | 1 | 0 | 1 | 1 | 0 | 0 | 1 | 1 | 1 | 0 | 1 | 0 | |||
| Hex | B | 3 | A |
Hex to binary
Reverse it: write every hex digit as exactly four bits, zeros included. A04 = 1010 0000 0100. Dropping the middle 0000 (giving 1010 0100 = 164) was a common mistake in June 2023.
Hex to denary: two methods, same example (C0F)
Method A: multiply by the hex place values
- Hex place values from the right: 1, 16, 256 (\(16^2\)), 4096 (\(16^3\)).
- C0F: C = 12 in the 256s, 0 in the 16s, F = 15 in the 1s.
- \(12\times256+0\times16+15\times1=3072+0+15=\)3087.
Method B: go through binary
- C0F → 1100 0000 1111 (each digit four bits).
- Add the place values of the 1s: 2048 + 1024 + 8 + 4 + 2 + 1 = 3087.
Denary to hex: two methods, same example (251)
Method A: convert to binary, then group in fours
- 251 = 128 + 64 + 32 + 16 + 8 + 2 + 1 = 1111 1011.
- Split into nibbles: 1111 | 1011.
- 1111 = F, 1011 = B, so 251 = FB.
Method B: divide by 16 and use the remainder
- 251 ÷ 16 = 15 remainder 11 (15 × 16 = 240, 251 − 240 = 11).
- 15 = F is the left digit; the remainder 11 = B is the right digit: FB.
- For numbers ≥ 256, divide the answer by 16 again and keep going; read the remainders from the bottom up.
Binary Coded Decimal (BCD)
BCD does not convert the whole number into binary. It converts each digit. Compare 87 both ways:
| 87 in BCD | 1 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | ||
| 87 in binary | 0 | 1 | 0 | 1 | 0 | 1 | 1 | 1 |
Denary to BCD
Write each digit as 4 bits, keeping every digit: 108 → 0001 0000 1000 (the 0 still needs its own nibble).
BCD to denary
Split into nibbles from the left, turn each into one digit: 0101 0111 0011 → 5, 7, 3 → 573. Write 573, not “5, 7, 3” (no separators).
Unsigned binary to BCD
Two steps: binary → denary first, then each digit to 4 bits. 1001 0101 = 149 → 0001 0100 1001.
Not valid BCD
A nibble above 1001 (9) cannot be BCD: 1010 to 1111 (10-15) never appear, because one denary digit only goes up to 9.
Where hexadecimal and BCD are used
| Representation | Used for | Why (the justification the scheme credits) |
|---|---|---|
| Hexadecimal | memory addresses and memory dumps when debugging; assembly code (&4A); MAC addresses; colour codes in web pages (#FC238A); error codes; IPv6 addresses | shorter and easier for people to read and remember than binary; fewer errors when copying; each hex digit is exactly 4 bits, so it converts straight to and from binary |
| BCD | financial / banking calculations | money uses two decimal places and must be exact: decimal fractions like 0.1 can't be stored exactly in normal binary, so binary sums build up rounding errors; BCD keeps every digit exact |
| BCD | electronic displays: calculators, digital clocks, meters | the display shows individual digits, and each nibble drives one digit, so conversion between denary and BCD is straightforward |
| BCD | the date and time held in a PC's BIOS (real-time clock); barcode systems | conversion between denary and BCD is simple and exact |
Benefits of BCD to quote (November 2022): straightforward to convert to and from denary, so less complex to encode and decode; easy for digital equipment to display; monetary values are represented exactly. Its drawback: it wastes bits (4 bits hold only 10 of the 16 possible patterns), so it needs more storage than plain binary.
Mark-scheme focus
“State one difference between a tebibyte and a gigabyte” (1 mark)
![(a) State one difference between a tebibyte and a gigabyte. [1]](/notes-content/9618/information-representation/img/9618_w24_11_q01_a.png)
- A tebibyte = 1024 gibibytes (\(2^{40}\) bytes) whereas a gigabyte = 1000 megabytes (\(10^9\) bytes)
- Tebi is a binary prefix, giga is a denary (decimal) prefix
- “A tebibyte is bigger than a gigabyte” (true, but not a difference in what they are)
- “A tebibyte is 1024 gigabytes” (must be gibibytes)
- “a kilobyte is 1000 bits”-style slips: bits instead of bytes
The mark is for the base each prefix counts in (1024 vs 1000, or binary vs denary). A comparison of size alone does not show you know why they differ.
Any correct pair of values with both units right, e.g. kibibyte = 1024 bytes and megabyte = 1 000 000 bytes.
From: 9618/11/O/N/24 Q1(a)
“Give one application where BCD is used and justify its use” (2 marks)
![(c) Give one application where Binary Coded Decimal (BCD) is used and justify its use. Application … Justification … [2]](/notes-content/9618/information-representation/img/9618_s25_12_q02_c.png)
- Application: an application performing financial / banking calculations B1
- Justification: values must be exact, no accumulating / rounding errors; it is difficult to represent decimal fractions exactly in normal binary B1
- or: electronic displays B1 because displays only need to show individual digits / conversion is straightforward B1
- “Calculators” with “because it is easier” (easier than what? for which part?)
- A justification that doesn't match the application (e.g. banking … because it shows digits)
The second mark is a corresponding justification: it has to explain why BCD suits that application.
Date and time in the BIOS (conversion with denary is easier); barcode systems.
From: 9618/12/M/J/25 Q2(c)
“State why the value in the register cannot be a BCD value” (1 mark)
![A register stores 1100 1101. (d) State why the value in the register cannot be interpreted as a Binary Coded Decimal (BCD). [1]](/notes-content/9618/information-representation/img/9618_w21_12_q04_d.png)
- The denary value in each nibble / group of 4 bits is greater than 9 (1100 = 12, 1101 = 13)
- “The register holds a value greater than 9” (the whole register, not each nibble)
BCD is judged nibble by nibble: each 4-bit group must be one denary digit 0-9. The report noted many answers talked about the whole register.
From: 9618/12/O/N/21 Q4(d)
“State the number of unique binary values that can be represented in 16 bits” (1 mark)
![Data in a computer is stored in binary form. (a) State the number of unique binary values that can be represented in 16 bits. [1]](/notes-content/9618/information-representation/img/9618_s23_12_q04_a.png)
- \(2^{16}\) or 65 536
- 65 535 (that is \(2^{16}-1\), the largest value, not the number of values)
Zero is one of the values. 16 bits run from 0 to 65 535, which is 65 536 different values.
From: 9618/12/M/J/23 Q4(a)
- Conversions: in nearly every paper, 1 mark each (binary ↔ denary ↔ hex, BCD both ways). With “show your working”: 1 for working, 1 for the answer.
- Prefixes: a 1-mark difference, a fill-in (4 marks) or a line-matching question (5 marks).
- BCD: an application + justification (2 marks) or two benefits (2 marks).
- Lost marks: answering in the wrong base (binary when denary was asked), dropping zero nibbles, converting to binary instead of BCD.
Worked examples
Example 1 · Matching binary values to prefixes (Paper 1, 5 marks) ★ Easy
![(a) Draw one line from each binary value to its equivalent (same) value on the right. Left: 8 bits, 8000 bits, 1000 kilobytes, 1024 mebibytes, 8192 bits. Right: 1 kibibyte, 1 gigabyte, 1 byte, 1 kilobyte, 1 gibibyte, 1 megabyte, 1 mebibyte. [5]](/notes-content/9618/information-representation/img/9618_w21_11_q01_a.png)
Five amounts on the left, seven on the right: two right-hand boxes are spare. Each left box equals exactly one right box.
- one line from each5 lines, one per left box; two right boxes stay empty
- equivalent (same)exactly equal, so kilo vs kibi matters
- (a)five correct lines
- 8 bits
- 8000 bits
- 1000 kilobytes
- 1024 mebibytes
- 8192 bits
- 1 byte = 8 bits
- decimal steps × 1000, binary steps × 1024
- Matcheach left box
- Bits÷ 8 to get bytes first
- Prefix1000 → decimal, 1024 → binary
8000 bits is how many bytes?
1000 bytes = 1 kilobyte.
8192 bits?
1024 bytes = 1 kibibyte.
5 Now solve it have a go on paper first, then open the worked solution
- 8 bits → 1 byte B1
- 8000 bits = 1000 bytes → 1 kilobyte B1
- 1000 kilobytes → 1 megabyte B1
- 1024 mebibytes → 1 gibibyte B1
- 8192 bits = 1024 bytes → 1 kibibyte B1
1 gigabyte and 1 mebibyte are the unused distractors: neither equals any left box. A decimal amount (1000) always went to a decimal prefix and 1024 to a binary one ✓.
Example 2 · Largest file size, then hex to denary (Paper 1, 3 marks) ★ Easy
![A computer stores binary data. (a) Tick one box only to identify the largest file size: 3300 kibibytes, 0.3 megabytes, 3 mebibytes, 3300 kilobytes. [1] (c) Convert the hexadecimal number C0F into denary. Show your working. [2]](/notes-content/9618/information-representation/img/9618_s24_12_q07_ac.png)
(a) mixes binary and decimal prefixes, so the numbers in front can't be compared directly. (c) wants hex place values, with working.
- tick one box onlytwo ticks scores nothing
- show your workinga working mark: write the place-value sum
- (a)the largest
- (c)C0F in denary
- 3300 KiB, 0.3 MB, 3 MiB, 3300 kB(a)
- C0F(c)
- C = 12, F = 15
- hex place values 256, 16, 1
- (a)largest
- Bytesconvert all four
- (c)denary
- Place values12 × 256 + 0 × 16 + 15
3300 KiB vs 3300 kB?
Same number, binary prefix bigger: 3300 KiB wins over 3300 kB.
Is 3 MiB bigger than 3300 KiB?
3 MiB = 3072 KiB, so no.
5 Now solve it have a go on paper first, then open the worked solution
- (a) 3300 KiB = 3 379 200 B; 0.3 MB = 300 000 B; 3 MiB = 3 145 728 B; 3300 kB = 3 300 000 B
- Largest: 3300 kibibytes B1
- (c) \(C0F=12\times16^2+0\times16+15\) M1
- \(=3072+15=\)3087 A1
Also accepted for the working mark: 1100 0000 1111 // 2048 + 1024 + 8 + 4 + 2 + 1.
3087 is less than 4096 = 16³, as a 3-digit hex number must be ✓.
Example 3 · Five conversions in one table (Paper 1, 5 marks) ★★ Medium
![(b) Complete the table: the hexadecimal value 11 represented in denary; the smallest denary number that can be represented by an unsigned 8-bit binary integer; the denary number 87 represented in BCD; the denary number 240 represented in hexadecimal; the denary number −20 represented in 8-bit two's complement binary. [5]](/notes-content/9618/information-representation/img/9618_s22_13_q01_b.png)
Five separate 1-mark conversions. Read each row's target carefully: two of the reported errors were answering in the wrong form.
- represented in denaryanswer in base 10
- unsignedno negatives: starts at 0
- BCDdigit by digit, not plain binary
- two's complementnegative numbers: see the next page
- Row 111 hex → denary
- Row 2smallest unsigned 8-bit
- Row 387 → BCD
- Row 4240 → hex
- Row 5−20 → 8-bit two's complement
- hex 11
- unsigned 8-bit
- 87
- 240
- −20
- Row 117?
- Place values1 × 16 + 1
- Row 3BCD
- Trap0101 0111 is plain binary
- Row 5−20
- +200001 0100, flip, add 1
Smallest unsigned 8-bit: write it as?
The question says “denary number”: write 0, not 00000000.
240 as hex?
240 = 15 × 16 + 0 → F0.
5 Now solve it have a go on paper first, then open the worked solution
- Hex 11 = 1 × 16 + 1 = 17 B1
- Smallest unsigned 8-bit integer = 0 (in denary, as asked) B1
- 87 in BCD = 8 → 1000, 7 → 0111 = 1000 0111 B1
- 240 = 15 × 16 → F0 B1
- −20: +20 = 0001 0100 → flip 1110 1011 → add 1 = 1110 1100 B1 (how this works is on the next page)
Row 3 starts with 1000 because the first digit is 8 - in plain binary 87 would start 0101. Row 5 is negative, so its first bit is 1 ✓.
Example 4 · Hex, then the BCD trap (Paper 1, 3 marks) ★★★ Hard
![(ii) Convert the unsigned binary integer 10010110 into hexadecimal. [1] (iii) Convert the unsigned binary integer 10010101 into Binary Coded Decimal (BCD). Show your working. [2]](/notes-content/9618/information-representation/img/9618_w22_12_q02_aiiaiii.png)
Why it is hard: the input looks like BCD. Only reading the stem (“unsigned binary integer”) stops you converting it the wrong way.
Both inputs are unsigned binary. (ii) is pure grouping. (iii) looks like BCD already (1001 0101 reads as “9 5”) but it isn't: it is a binary number.
- unsigned binary integera normal positive binary number
- into BCDdenary digits first, then 4 bits each
- show your workingthe denary value is the working mark
- (a)(ii)hex
- (a)(iii)BCD
- 1001 0110(ii)
- 1001 0101(iii)
- (iii)BCD
- Denary128 + 16 + 4 + 1
- Theneach digit to 4 bits
- Trapanswering 95
What does 1001 0101 mean as BCD?
95 - but the question told you it is binary, not BCD.
How many nibbles will 149 need?
Three: one per digit.
5 Now solve it have a go on paper first, then open the worked solution
- (ii) 1001 | 0110 → 9 | 6 → 96 B1
- (iii) 1001 0101 = 128 + 16 + 4 + 1 = 149, the working mark B1
- 1 → 0001, 4 → 0100, 9 → 1001: 0001 0100 1001 B1
In (ii), converting to denary first and then to hex is allowed, but the report says it introduced errors: group the bits directly.
BCD of a 3-digit number has 12 bits, and every nibble is ≤ 1001 ✓. The report: “a very common incorrect response was 95”.
Summary
- Decimal prefixes (kilo, mega, giga, tera) go up in 1000s; binary prefixes (kibi, mebi, gibi, tebi) in 1024s.
- n bits: \(2^n\) values, largest unsigned \(2^n-1\).
- Hex digit = 4 bits: group binary in fours from the right; write every hex digit as four bits.
- BCD: each denary digit as its own nibble (0000-1001). Plain binary → BCD goes through denary.
- Hex: short, readable, maps to binary. BCD: exact decimal values, easy display.
| If you see… | do this |
|---|---|
| two different prefixes to compare | convert everything to bytes |
| “into hexadecimal” from binary | nibbles from the right, pad the left group |
| “into hexadecimal” from denary | go through binary, then group |
| “into BCD” from denary | each digit → 4 bits, keep zero digits |
| “into BCD” from binary | binary → denary first, then each digit → 4 bits |
| “how many values in n bits” | \(2^n\) (not \(2^n-1\)) |
| “show your working” | write the place-value sum or the nibbles, then the labelled answer |
Can I do this?
- I can explain the difference between binary and decimal prefixes using 1024 and 1000.
- I can convert and compare amounts given with different prefixes, via bytes.
- I know n bits give \(2^n\) values, the largest unsigned value is \(2^n-1\), and I can find the fewest bits needed.
- I can convert binary ↔ denary by both methods.
- I can convert between hex and binary (nibbles) and between hex and denary.
- I can convert to and from BCD, including plain binary → BCD, and say why a byte isn't valid BCD.
- I can give uses of hex and of BCD, each with a matching justification.
Anything unticked: revise that section first. All ticked: take the quiz.
Quiz
The multiple-choice and guided questions need JavaScript. The concept checks and exam practice below work without it.
Concept checks
Answer each one in your head first, then open it.
1Why do binary prefixes exist at all, when we already had kilo and mega?Show answer
Memory is addressed in powers of 2, so its sizes are naturally 1024, 1 048 576 … Using “kilo” for 1024 made “kilobyte” mean two different things. The binary prefixes give the power-of-2 sizes their own names.
2Why does one hex digit always match exactly four bits?Show answer
Because \(16=2^4\): four bits make exactly 16 patterns, 0000 to 1111, one for each hex digit 0 to F.
3Why does BCD need more bits than plain binary for the same number?Show answer
Each nibble only uses 10 of its 16 patterns. 99 needs 8 bits in BCD (1001 1001) but only 7 bits in binary (110 0011).
4Can 1000 0111 be both BCD and a binary number? What is it worth each way?Show answer
Yes, the bit pattern means whatever we say it means: as BCD it is 87, as unsigned binary it is 128 + 7 = 135. That is why questions always say which representation they mean.
Exam-style practice
New questions, not used above. Do them on paper, then mark your work against the official mark scheme.
![(a) Complete the description: A kibibyte has a … prefix. Three kibibytes is the same as … bytes. A megabyte has a … prefix. Two terabytes is the same as … gigabytes. [4] (b) Convert the denary number 241 to hexadecimal. [1]](/notes-content/9618/information-representation/img/9618_s24_13_q01_ab.png)
Show the mark scheme
| Part | Answer / working | Marks | Guidance |
|---|---|---|---|
| (a) | binary | B1 | |
| 3072 | B1 | 3 × 1024 | |
| denary // decimal | B1 | ||
| 2000 | B1 | 2 × 1000 | |
| (b) | F1 | B1 | 241 = 1111 0001 |
| Total: 5 marks | |||
Examiner tip Write the prefix family by name (“binary”, “decimal / denary”), not “big” or “small”.
![(a)(i) Convert the binary number 101100111010 into hexadecimal. [1] (ii) Convert the denary number 108 into Binary Coded Decimal (BCD). [1]](/notes-content/9618/information-representation/img/9618_w25_11_q01_aiaii.png)
Show the mark scheme
| Part | Answer / working | Marks | Guidance |
|---|---|---|---|
| (a)(i) | B3A | B1 | 1011 | 0011 | 1010 |
| (a)(ii) | 0001 0000 1000 | B1 | the 0 digit keeps its nibble |
| Total: 2 marks | |||
![(a)(i) Convert the unsigned binary value 10010011 into hexadecimal. [1] (ii) Convert the unsigned binary value 10010011 into denary. [1] (b) State two benefits of using Binary Coded Decimal (BCD) to represent values. [2]](/notes-content/9618/information-representation/img/9618_w22_13_q09.png)
Show the mark scheme
| Part | Answer / working | Marks | Guidance |
|---|---|---|---|
| (a)(i) | 93 | B1 | |
| (a)(ii) | 147 | B1 | 128 + 16 + 2 + 1 |
| (b) | Straightforward to convert to / from BCD and denary … so less complex to encode and decode for programmers | B1 | |
| Easier for digital equipment to display output // can represent monetary values exactly | B1 | max 2 | |
| Total: 4 marks | |||
Examiner tip The report: most candidates gave one benefit (easy conversion); a second, different benefit was harder. Learn two.
![(a) State one difference between a kibibyte and a megabyte. [1] (b)(ii) Convert the BCD 100001100101 into denary. [1] (iii) Convert the unsigned binary integer 000111010110 into denary. [1] (c) Identify one practical application of BCD and justify why BCD is used in this application. [2]](/notes-content/9618/information-representation/img/9618_w23_12_q03_abiibiiic.png)
Show the mark scheme
| Part | Answer / working | Marks | Guidance |
|---|---|---|---|
| (a) | kibibyte = 1024 bytes and megabyte = 1 000 000 bytes // kibi is a binary prefix and mega is a denary prefix | B1 | |
| (b)(ii) | 865 | B1 | 1000 | 0110 | 0101 |
| (b)(iii) | 470 | B1 | 256 + 128 + 64 + 16 + 4 + 2 |
| (c) | e.g. financial / banking calculations | B1 | |
| … because decimal values must be exact with no accumulating rounding errors (hard to represent exactly in normal binary) | B1 | must match the application | |
| Total: 5 marks | |||
Your progress on this note is saved when JavaScript is on.