Why is "Writing `1 + 1 = 2` in a binary addition." a common mistake in Binary arithmetic?

Why it happens: Decimal arithmetic is completely automatic, so the answer appears before the base has been consciously registered — especially under time pressure. How to avoid it: There is **no digit 2 in binary**. `1 + 1` is `10` — write **0** and **carry 1**, exactly as 5 + 5 = 10 in decimal is written as 0 carry 1. Learn the two carry rules as a pair: **1+1 = 0 carry 1** and **1+1+1 = 1 carry 1**. Source: AQA 8525 specification 3.3.4 limits a column to three 1s precisely so that the carry never exceeds 1.

Why is "Performing a binary addition without writing down the carry row." a common mistake in Binary arithmetic?

Why it happens: The carries are held mentally to save time, and the working looks tidier without them — until a single column is misremembered and the whole answer is wrong. How to avoid it: Mark schemes award marks for **correct carries** independently of the final answer, so showing them protects marks even when the arithmetic slips. Write the carry row above the sum and always finish with a **decimal check**. Source: Binary addition mark schemes credit correct carries as a separate method mark.

Why is "Shifting the bits but leaving the vacated positions empty, giving an answer with fewer than 8 bits." a common mistake in Binary arithmetic?

Why it happens: The bits are physically moved along on paper and the gap at one end is easy to overlook, since the value 'looks' complete. How to avoid it: A logical shift always **fills the vacated positions with zeros**, and the answer must still be **8 bits** long. After shifting, count the digits — if there are not eight, zeros are missing. Source: AQA 8525 specification 3.3.4 specifies logical shifts using a maximum of 8 bits.

Why is "Confusing which shift direction multiplies and which divides." a common mistake in Binary arithmetic?

Why it happens: Both operations look identical on the page — every bit simply moves along — so the association with multiplication or division has to be recalled rather than seen. How to avoid it: Anchor it to place values: moving **left** puts each bit into a column worth **double**, so left **multiplies**. Moving **right** halves each place value, so right **divides**. Confirm with a small example — `0001` (1) shifted left becomes `0010` (2). Source: Shift questions require both the resulting bit pattern and the effect on the value, so the direction must be correct for both marks.

Why is "Assuming a right shift always gives exactly half the original value." a common mistake in Binary arithmetic?

Why it happens: It is exactly half for every even number, which covers most classroom examples — the truncation only appears when an odd number is shifted. How to avoid it: Bits shifted off the right are **lost**, so any remainder is **discarded**: 11 shifted right by 1 gives **5**, not 5.5. The operation is **integer division** (`DIV`), and the specification excludes fractional representations, which is exactly why the remainder cannot be kept. Source: AQA 8525 specification 3.3.4 states that students will not need to understand or use fractional representations.

Why is "Assuming a shift can multiply or divide by any value, such as 10 or 3." a common mistake in Binary arithmetic?

Why it happens: Shifting is presented as a fast alternative to multiplication, so it is easy to over-generalise into a substitute for multiplication in general. How to avoid it: A shift changes each place value by a factor of two, so it can **only** multiply or divide by **powers of 2** — 2, 4, 8, 16, 32. Multiplying by 10 or 3 requires a genuine multiplication instruction, and stating that limitation is often worth a mark. Source: AQA 8525 specification 3.3.4 states that binary shifts can be used to perform simple multiplication and division by powers of 2.

AQA GCSE Computer Science (8525)

Binary arithmetic

0% Complete

Detailed Study Notes

Detailed notes on Fundamentals of Data Representation for AQA GCSE Computer Science, covering key concepts, explanations, examples, and exam-focused revision points.

Binary Arithmetic — AQA GCSE Computer Science 8525 (3.3.4)

Two skills, both with generous limits set by the specification. Binary addition of up to three numbers, maximum 8 bits each, with at most three 1s in a single column and no carrying beyond the 8th bit. And binary shifts — logical shifts only, maximum 8 bits, no fractional representations — plus the ability to describe where shifts are used, which is multiplication and division by powers of 2. Four addition rules and one shift rule cover everything.

At a glance

Binary addition rules: 0+0=0 · 0+1=1 · 1+1 = 0 carry 1 · 1+1+1 = 1 carry 1.
Add up to three binary numbers, maximum 8 bits each.
At most three 1s in a single column — so you never need a carry larger than 1.
Answers are a maximum of 8 bits with no carrying beyond the 8th bit.
Always work from RIGHT to LEFT, exactly as in decimal addition.
A logical shift LEFT by n places multiplies by 2ⁿ.
A logical shift RIGHT by n places divides by 2ⁿ.
Shifting in always introduces zeros; bits shifted out are lost.
Only logical shifts are required — no fractional representations.
Bits shifted out are lost permanently, so a right shift can lose precision and a left shift can overflow.

What you’ll learn

Mapped to the AQA GCSE 8525 syllabus (2027-2029).

Be able to add together up to three binary numbers, using a maximum of 8 bits per number, adding a maximum of three 1s in a single column, with answers a maximum of 8 bits and no carrying beyond the 8th bit.
Be able to apply a binary shift to a binary number, using a maximum of 8 bits and understanding and using only a logical binary shift (fractional representations are not required).
Describe situations where binary shifts can be used, knowing that they can perform simple multiplication and division by powers of 2.

Binary addition — the four rules

0+0=0, 0+1=1, 1+1=0 carry 1, 1+1+1=1 carry 1. Work right to left.

Binary addition works exactly like decimal addition — you add column by column from the right, carrying when a column overflows. The only difference is that binary overflows at 2 rather than at 10.

The four rules

Sum	Result	Carry
0 + 0	0	—
0 + 1	1	—
1 + 1	0	carry 1
1 + 1 + 1	1	carry 1

Learn the last two properly. They are where every error comes from.

1 + 1 = 10 in binary — that is two, written as "0 with 1 carried", exactly as 5 + 5 = 10 in decimal is "0 carry 1".
1 + 1 + 1 = 11 in binary — that is three, written as "1 with 1 carried".

Why does the specification cap you at three 1s per column? Because that is the largest sum that still produces a carry of only 1. Four 1s would give 100 (four), needing a carry of 2 into the next column — which is why AQA excludes it.

Worked addition of two numbers

Add 01011010 + 00110110:

      0 1 0 1 1 0 1 0
   +  0 0 1 1 0 1 1 0
      ---------------
carry   1 1 1 1  1
      ---------------
      1 0 0 1 0 0 0 0

Working right to left, column by column:

Column	Sum	Write	Carry out
1s	0 + 0	0	—
2s	1 + 1	0	1
4s	0 + 1 + carry 1	0	1
8s	1 + 0 + carry 1	0	1
16s	1 + 1 + carry 1	1	1
32s	0 + 1 + carry 1	0	1
64s	1 + 0 + carry 1	0	1
128s	0 + 0 + carry 1	1	—

Answer: 10010000

Check in decimal: 90 + 54 = 144, and 10010000 = 128 + 16 = 144 ✓

Adding three numbers

The method is identical — just add three digits plus any carry:

      0 0 1 0 1 1 0 1        45
      0 0 0 1 0 1 1 0        22
   +  0 0 0 0 1 1 0 1        13
      ---------------
      0 1 0 1 0 0 0 0        80

Check: 45 + 22 + 13 = 80, and 01010000 = 64 + 16 = 80 ✓

AQA tip. Always check your answer in decimal. Convert each input, add them normally, then convert your binary answer back. It takes twenty seconds and catches every arithmetic slip. Mark schemes award method marks for correct carries, so show the carry row.

Four rules: 0+0=0, 0+1=1, 1+1=0 carry 1, 1+1+1=1 carry 1.
Work right to left, exactly as in decimal addition.
Show the carry row — method marks are awarded for correct carries.
A maximum of three 1s per column means the carry is never more than 1.
Always check by converting to decimal, adding, and converting back.

See the full worked example for binary arithmetic →

The 8-bit limit and overflow

Answers are capped at 8 bits. A carry out of the 8th bit is overflow — but AQA avoids it.

The specification is precise about the boundaries:

"Answers will be a maximum of 8 bits in length and will not involve carrying beyond the 8th bit."

So in an AQA question, the sum will always fit into 8 bits. You will not be asked to handle a result that spills over.

What overflow is

Overflow occurs when the result of a calculation is too large to be stored in the available number of bits.

With 8 bits the largest storable value is 255. If an addition produces 256 or more, the carry out of the 128s column has nowhere to go:

      1 1 1 1 1 1 1 1        255
   +  0 0 0 0 0 0 0 1          1
      ---------------
    1 0 0 0 0 0 0 0 0        256 — needs 9 bits!
    ↑
    this carry has nowhere to go in an 8-bit register

The 9th bit cannot be stored, so the result appears as 00000000 — zero. The value has "wrapped around".

Why it matters

Overflow causes real, serious bugs: a counter resetting unexpectedly, a total becoming wrong, or a system behaving unpredictably. The processor normally sets an overflow flag to signal it, though flag registers are not required knowledge here.

AQA will not set an addition that overflows, but you should be able to explain what overflow is and why it happens, since it is a natural extension of the 8-bit limit.

The useful check

Before adding, convert both numbers to decimal and check the total is ≤ 255. If a question's numbers would exceed 255, re-read it — you have probably misread a bit.

AQA tip. If asked to explain overflow, define it as the result being too large for the number of bits available, and give the consequence — the extra bit is lost, so the stored answer is incorrect.

AQA answers are a maximum of 8 bits with no carrying beyond the 8th bit.
Overflow = the result is too large for the available number of bits.
With 8 bits the maximum is 255; 255 + 1 overflows and appears as 0.
The lost carry makes the stored result incorrect.
Check before adding that the decimal total is ≤ 255.

See the full worked example for binary arithmetic →

Logical binary shifts

Move every bit left or right. Zeros come in; bits shifted out are lost.

A logical binary shift moves every bit in a number a given number of places left or right. Vacated positions are filled with zeros, and bits pushed off the end are lost.

The specification requires only logical shifts and states that fractional representations are not required — so you never need to worry about what happens to bits after a "decimal point".

Shift LEFT — multiplies

Shift 00001011 (11) left by 1:

before:  0 0 0 0 1 0 1 1     = 11
          ← every bit moves one place left
after:   0 0 0 1 0 1 1 0     = 22
                        ↑
                    a 0 comes in

11 × 2 = 22 ✓

Shift left by 2 places:

before:  0 0 0 0 1 0 1 1     = 11
after:   0 0 1 0 1 1 0 0     = 44

11 × 4 = 44 ✓

$\text{shift left by } n \text{ places} \;=\; \times\, 2^n$

Shift RIGHT — divides

Shift 00011000 (24) right by 1:

before:  0 0 0 1 1 0 0 0     = 24
          every bit moves one place right →
after:   0 0 0 0 1 1 0 0     = 12
         ↑
     a 0 comes in

24 ÷ 2 = 12 ✓

$\text{shift right by } n \text{ places} \;=\; \div\, 2^n$

Each place a bit moves changes its place value by a factor of two — which is why shifting is multiplication and division by powers of 2.

Why shifting works

Every binary place value is double the one to its right. Moving a bit one place left therefore doubles its contribution; moving it one place right halves it. Since every bit moves together, the whole number is doubled or halved.

AQA tip. State the direction and the number of places precisely — "shift left by 3 places" — and always give the multiplier: left by 3 is × 2³ = × 8.

A logical shift moves every bit; zeros fill the vacated positions.
Shift LEFT by n places = multiply by 2ⁿ.
Shift RIGHT by n places = divide by 2ⁿ.
Bits shifted off the end are lost permanently.
It works because each place value is double the one to its right.

See the full worked example for binary arithmetic →

What happens to bits that are shifted out

They are lost permanently. Right shifts lose precision; left shifts can overflow.

Bits pushed off either end are lost and cannot be recovered. This has two distinct consequences.

Right shift — loss of precision

Shift 00001011 (11) right by 1:

before:  0 0 0 0 1 0 1 1     = 11
after:   0 0 0 0 0 1 0 1     = 5
                        ↑
                  the 1 is lost

11 ÷ 2 = 5.5, but the result is 5. The remainder has been discarded.

This is exactly integer division — the same truncation as DIV in 3.2.3. A right shift performs n DIV 2, not true division, because the fractional part cannot be represented (and the specification states fractional representations are not required).

Shifting right is only exact when the number is even.

Left shift — possible overflow

Shift 10000001 (129) left by 1:

before:  1 0 0 0 0 0 0 1     = 129
after:   0 0 0 0 0 0 1 0     = 2
         ↑
    the leading 1 is lost

129 × 2 = 258, which needs 9 bits. The most significant bit is pushed out and lost, so the stored answer of 2 is completely wrong.

A left shift only gives the correct answer if the result still fits in 8 bits — that is, if the original value is 127 or less.

Summary of the risks

Shift	Risk	When it is safe
Right	Loses the remainder (rounds down)	When the number divides exactly by 2ⁿ
Left	Can overflow, losing the answer entirely	When the result is ≤ 255

AQA tip. If asked what happens to a bit shifted out, the answer is that it is lost — and you should name the consequence: for a right shift, loss of precision (the value is rounded down); for a left shift, overflow producing an incorrect result.

Bits shifted off either end are lost permanently.
A right shift discards the remainder — it performs integer division (DIV).
11 shifted right by 1 gives 5, not 5.5.
A left shift can push the most significant bit out, causing overflow.
Left shifts are only correct when the result still fits in 8 bits.

See the full worked example for binary arithmetic →

Where binary shifts are used

Multiplication and division by powers of 2 — and they are far faster than the alternatives.

The specification requires you to describe situations where binary shifts can be used, noting that they perform simple multiplication and division by powers of 2.

The powers of 2

Places shifted	Left = multiply by	Right = divide by
1	2	2
2	4	4
3	8	8
4	16	16

Only powers of 2 are possible. A shift cannot multiply by 3, 5 or 10 — those need genuine multiplication.

Why processors use shifts

A shift is far faster than a multiplication or division. Multiplying requires a comparatively complex circuit and several clock cycles; shifting simply moves bits along wires and typically completes in a single cycle. Compilers therefore replace multiplication by a power of 2 with a shift automatically wherever they can.

Genuine applications

Situation	Shift used
Doubling or halving a value quickly	Left or right by 1
Scaling an image by a power of 2	Left or right by n
Adjusting audio volume by a factor of 2	Left or right by 1
Extracting parts of a colour code	Right by 8 or 16
Converting between units that differ by a power of 2	Shift by the appropriate n
Fast calculation in embedded systems with limited processing power	Shift instead of multiply

A worked application

"A program needs to divide a value by 8 as quickly as possible."

8 = 2³, so shift right by 3 places.

01011000  (88)
   shift right 3
00001011  (11)

88 ÷ 8 = 11 ✓ — exact, because 88 divides evenly by 8.

AQA tip. When asked to describe where shifts are used, give the general purpose — multiplication and division by powers of 2 — plus the reason they are chosen: they are much faster than performing a full multiplication or division. Both halves earn marks.

Shifts perform simple multiplication and division by powers of 2.
Only powers of 2 are possible — you cannot shift to multiply by 3 or 10.
Shifts are much faster than multiplication or division circuits.
Used for scaling images, adjusting volume, and fast arithmetic on limited hardware.
State the purpose AND the speed advantage for full marks.

See the full worked example for binary arithmetic →

Quick recap

Binary addition rules: 0+0=0, 0+1=1, 1+1=0 carry 1, 1+1+1=1 carry 1.
Add up to three numbers, maximum 8 bits each, at most three 1s per column.
Answers are a maximum of 8 bits with no carrying beyond the 8th bit.
Work right to left and show the carry row — method marks are awarded for it.
Overflow occurs when a result is too large for the available bits; with 8 bits the maximum is 255.
A logical shift left by n places multiplies by 2ⁿ; a shift right by n places divides by 2ⁿ.
Zeros fill the vacated positions and bits shifted out are lost permanently.
A right shift discards the remainder, performing integer division.
Shifts are used for fast multiplication and division by powers of 2.

Memorise this

Verbatim phrases and definitions Cambridge mark schemes credit.

0+0=0 · 0+1=1 · 1+1=0 carry 1 · 1+1+1=1 carry 1.
Work RIGHT to LEFT and show the carry row.
Maximum: 3 numbers, 8 bits each, 3 ones per column, answer 8 bits.
Shift LEFT by n = multiply by 2ⁿ. Shift RIGHT by n = divide by 2ⁿ.
Zeros fill the vacated positions; bits shifted out are LOST.
A right shift discards the remainder — it is integer division.
Only LOGICAL shifts are required. No fractional representations.
Overflow = the result is too large for the number of bits available.

How it’s examined

3.3.4 is assessed on Paper 2 and is one of the most dependable calculation topics on the paper, because the specification caps the difficulty precisely. Four shapes recur. (1) Binary addition, 2–4 marks: add two or three 8-bit numbers, where marks are awarded for the carries as well as the final answer, so the carry row must be shown (AO2). (2) Apply a shift, 2–3 marks: shift a given number left or right by a stated number of places and give the result, remembering to fill vacated positions with zeros and keep the answer 8 bits long (AO2). (3) State the effect of a shift, 1–2 marks: identify that a left shift by n multiplies by 2ⁿ and a right shift divides by 2ⁿ (AO1). (4) Describe uses, 2–4 marks: explain where shifts are used — multiplication and division by powers of 2 — and why, which is that they are much faster than full multiplication or division (AO1/AO2). Two boundaries are worth banking: only logical shifts are required and fractional representations are excluded, so a right shift always rounds down; and AQA will never set an addition that carries beyond the 8th bit, though you should still be able to explain what overflow is. Checking every answer by converting to decimal is the single most effective habit here.

Sources: AQA GCSE Computer Science 8525 specification (v1.3, 16 June 2025) — 3.3.4 Binary arithmetic; AQA GCSE Computer Science Paper 2 past papers, mark schemes and examiner reports. Last reviewed 2026-07-29.

Take this whole topic with you

Step-by-step worked examples — Binary arithmetic

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

Question type:

1Apply the four binary addition rules (3 marks)
Getting startedDirect calculation• Paper 2 style — 3 marks (AO1/AO2)• addition, rules, carry
Question
State the result of each of the following binary additions, including any carry.

(a) 1 + 1 (b) 1 + 1 + 1 (c) 0 + 1 (3 marks)
Step-by-step solution
1. Step 1
  (a) In binary there is no digit 2, so 1 + 1 gives 10 — write 0 and carry 1.
2. Step 2
  (b) 1 + 1 + 1 is three, which in binary is 11 — write 1 and carry 1.
3. Step 3
  (c) 0 + 1 = 1, with no carry. This is the same as in decimal.
Answer
(a) 1 + 1 = 0 carry 1 (1) (b) 1 + 1 + 1 = 1 carry 1 (1) (c) 0 + 1 = 1, no carry (1) (3)
Examiner tip
There is no digit 2 in binary — writing '1 + 1 = 2' is the single most common error here. Note also why the specification caps a column at three 1s: four would give 100, requiring a carry of 2, which AQA deliberately excludes.
2Add two 8-bit binary numbers (4 marks)
Getting startedDirect calculation• Paper 2 style — 4 marks (AO2)• addition, 8-bit, carry
Question
Add the binary numbers 00101101 and 00010110. Show your working, including any carries, and check your answer in decimal. (4 marks)
Step-by-step solution
1. Step 1
  Work right to left. 1s column: 1 + 0 = 1. 2s: 0 + 1 = 1. 4s: 1 + 1 = 0 carry 1.
2. Step 2
  8s column: 1 + 0 + carry 1 = 0 carry 1. 16s: 0 + 1 + carry 1 = 0 carry 1.
3. Step 3
  32s column: 1 + 0 + carry 1 = 0 carry 1. 64s: 0 + 0 + carry 1 = 1. 128s: 0 + 0 = 0.
4. Step 4
  Check in decimal. 00101101 = 45 and 00010110 = 22, so the total should be 67. The answer 01000011 = 64 + 2 + 1 = 67 ✓
  $45 + 22 = 67$
Answer
0 0 1 0 1 1 0 1 45 + 0 0 0 1 0 1 1 0 22 --------------- carry 1 1 1 1 --------------- 0 1 0 0 0 0 1 1 67

Answer: 01000011

Marks: correct carries shown (2); correct 8-bit answer (1); decimal check 45 + 22 = 67 and 01000011 = 67 ✓ (1). (4)
Examiner tip
The carry row must be shown — mark schemes award marks for correct carries independently of the final answer, so working saves marks even if a column slips. The decimal check takes twenty seconds and catches every arithmetic error.
3Apply a logical shift left (3 marks)
Getting startedDirect calculation• Paper 2 style — 3 marks (AO2)• shift, left, multiply
Question
The binary number 00001011 is shifted left by 2 places.

(a) Give the resulting 8-bit binary number. (b) State the decimal values before and after the shift. (c) State the effect the shift has had on the value. (3 marks)
Step-by-step solution
1. Step 1
  (a) Move every bit two places left, filling the two vacated positions on the right with zeros: 00101100.
2. Step 2
  (b) Before: 00001011 = 8 + 2 + 1 = 11. After: 00101100 = 32 + 8 + 4 = 44.
3. Step 3
  (c) 11 → 44 is multiplication by 4, which is 2² — matching a shift of 2 places left.
  $11 \times 2^2 = 44$
Answer
(a) 00101100 (1) (b) Before = 11, after = 44 (1) (c) The value has been multiplied by 4, because a shift left by n places multiplies by 2ⁿ, and here n = 2 so the multiplier is 2² = 4 (1) (3)
Examiner tip
The vacated positions must be filled with zeros so the answer remains 8 bits — writing 101100 would lose the accuracy mark. Note the answer states the multiplier as 2ⁿ rather than just 'it got bigger', which is what the mark requires.
4Add three binary numbers (5 marks)
Building confidenceDirect calculation• Paper 2 style — 5 marks (AO2)• addition, three-numbers, carry
Question
Add the three binary numbers 00101101, 00010110 and 00001101. Show your working and check your answer in decimal. (5 marks)
Step-by-step solution
1. Step 1
  The method is identical to adding two numbers — add all three digits in a column, plus any carry, working right to left.
2. Step 2
  1s column: 1 + 0 + 1 = 0 carry 1. 2s: 0 + 1 + 0 + carry 1 = 0 carry 1.
3. Step 3
  4s column: 1 + 1 + 1 + carry 1 = 4, which is 100 — but AQA caps a column at three 1s, so recheck: 1 + 1 + 1 = 1 carry 1, then adding the incoming carry gives 0 carry 1 for this column with the extra carry propagating.
4. Step 4
  Continue right to left, then verify by decimal conversion rather than relying on the column work alone.
5. Step 5
  Decimal check: 45 + 22 + 13 = 80, and 01010000 = 64 + 16 = 80 ✓
  $45 + 22 + 13 = 80$
Answer
0 0 1 0 1 1 0 1 45 0 0 0 1 0 1 1 0 22 + 0 0 0 0 1 1 0 1 13 --------------- 0 1 0 1 0 0 0 0 80

Answer: 01010000

Decimal check: 45 + 22 + 13 = 80, and 01010000 = 64 + 16 = 80 ✓

Marks: correct method adding three digits plus carry per column (1); correct carries (2); correct 8-bit answer (1); decimal check shown (1). (5)
Examiner tip
With three numbers the safest approach is to convert to decimal, add, and convert back — then use the column method to confirm. The specification guarantees at most three 1s in a single column, so the carry into the next column is never more than 1, and the total will always fit in 8 bits.
5Explain what happens to bits shifted out (5 marks)
Building confidenceMulti-step problem• Paper 2 style — 5 marks (AO2/AO3)• shift, right, precision, lost-bits
Question
The binary number 00001011 (11) is shifted right by 1 place.

(a) Give the resulting binary number and its decimal value. (b) State what has happened to the bit that was shifted out. (c) Explain why the result is not exactly half of the original value. (d) State the arithmetic operation this is equivalent to. (5 marks)
Step-by-step solution
1. Step 1
  (a) Every bit moves one place right and a zero enters from the left: 00000101 = 4 + 1 = 5.
2. Step 2
  (b) The rightmost bit, a 1, is pushed off the end and is lost permanently — it cannot be recovered.
3. Step 3
  (c) 11 ÷ 2 = 5.5, but there is no way to store the 0.5 because that would require a fractional representation, which is not used here.
4. Step 4
  So the remainder is discarded and the value is effectively rounded down to 5.
5. Step 5
  (d) Discarding the remainder is exactly integer division — the same as 11 DIV 2 = 5 from 3.2.3.
Answer
(a) 00000101, which is 5 in decimal (1)

(b) The bit shifted out — a 1 — is lost permanently and cannot be recovered (1)

(c) 11 ÷ 2 = 5.5, but the 0.5 cannot be stored because that would require a fractional representation, which is not used here (1). The remainder is therefore discarded and the value is rounded down to 5 (1)

(d) It is equivalent to integer division — the same as 11 DIV 2 = 5 (1) (5)
Examiner tip
The link to DIV from 3.2.3 is exact rather than approximate: integer division by a power of 2 is a right shift, which is why compilers substitute one for the other. Note that a right shift is only exact when the number divides evenly — shifting an even number loses nothing.
6Explain overflow in an 8-bit addition (4 marks)
Building confidenceWord problem• Paper 2 style — 4 marks (AO2/AO3)• overflow, 8-bit, explain
Question
A computer adds the 8-bit binary numbers 11111111 and 00000001.

(a) State the decimal values being added and the correct decimal answer. (b) Explain why this causes a problem in an 8-bit register. (c) State the term for this problem and its consequence. (4 marks)
Step-by-step solution
1. Step 1
  (a) 11111111 = 255 and 00000001 = 1, so the correct answer is 256.
2. Step 2
  (b) The largest value 8 bits can store is 255, so 256 requires 9 bits — 100000000.
3. Step 3
  The carry out of the 128s column has nowhere to go, so the 9th bit cannot be stored and is lost.
4. Step 4
  (c) This is overflow, and the stored result appears as 00000000 — zero — which is completely incorrect.
Answer
(a) 11111111 = 255 and 00000001 = 1, so the correct answer is 256 (1)

(b) The largest value that 8 bits can store is 255, so 256 would require 9 bits (100000000) (1). The carry out of the 128s column has nowhere to be stored, so that bit is lost (1)

(c) This is called overflow, and its consequence is that the stored result is incorrect — here it would appear as 00000000, or zero (1) (4)
Examiner tip
AQA states that exam additions will not carry beyond the 8th bit, so you will not be asked to compute an overflowing sum — but you should be able to explain what overflow is. The definition to give is that the result is too large for the number of bits available, and the consequence is that the answer stored is wrong.
7Describe where binary shifts are used (6 marks)
StretchWord problem• Paper 2 style — 6 marks (AO1/AO2)• shift, uses, multiplication, speed
Question
(a) Describe the situations in which binary shifts can be used. (b) A program must divide a value by 8 as quickly as possible. State the shift required and demonstrate it on the binary number 01011000. (c) Explain why a processor might use a shift rather than a division instruction. (6 marks)
Step-by-step solution
1. Step 1
  (a) Binary shifts perform simple multiplication and division by powers of 2 — a shift left by n multiplies by 2ⁿ and a shift right by n divides by 2ⁿ.
2. Step 2
  Note the limitation. Only powers of 2 are possible — a shift cannot multiply by 3, 5 or 10.
3. Step 3
  (b) 8 = 2³, so the operation is a shift right by 3 places.
4. Step 4
  Apply it: 01011000 (88) shifted right 3 gives 00001011 = 11, and 88 ÷ 8 = 11 ✓ — exact, since 88 divides evenly by 8.
  $88 \div 2^3 = 11$
5. Step 5
  (c) A shift is much faster than a multiplication or division, because it simply moves bits along wires and typically completes in a single clock cycle.
6. Step 6
  By contrast, a full multiplication or division requires a more complex circuit and several clock cycles — so compilers automatically replace multiplication by a power of 2 with a shift.
Answer
(a) Binary shifts are used to perform simple multiplication and division by powers of 2 (1). A logical shift left by n places multiplies the value by 2ⁿ, and a shift right by n places divides it by 2ⁿ (1). Only powers of 2 are possible — a shift cannot multiply by 3 or 10, which would need a genuine multiplication (1).

(b) Since 8 = 2³, the operation required is a shift right by 3 places (1):

01011000 = 88 shift right 3 00001011 = 11

88 ÷ 8 = 11 ✓ (1)

(c) A shift is much faster than a division instruction, because it simply moves bits one place along and typically completes in a single clock cycle, whereas a full division requires a more complex circuit and several cycles. For this reason compilers automatically replace division by a power of 2 with a shift wherever they can, and shifts are especially valuable in embedded systems with limited processing power (1).
Examiner tip
Part (c) is the point most often omitted: the specification asks students to describe situations where binary shifts can be used, and the speed advantage is what explains why they are chosen over the arithmetic instructions. Note the result here is exact because 88 divides evenly by 8 — had it been 90, the remainder would have been discarded.
8Analyse a left shift that overflows (6 marks)
StretchMulti-step problem• Paper 2 style — 6 marks (AO3)• shift, left, overflow, analyse
Question
The binary number 10000001 is shifted left by 1 place in an 8-bit register.

(a) State the decimal value before the shift and the value it should become. (b) Give the 8-bit result actually stored, and its decimal value. (c) Explain what has gone wrong. (d) State the largest value that can safely be shifted left by 1 in 8 bits. (6 marks)
Step-by-step solution
1. Step 1
  (a) 10000001 = 128 + 1 = 129. Shifting left by 1 should multiply by 2, giving 258.
2. Step 2
  (b) Every bit moves one place left. The leading 1 is pushed off the end and lost, and a zero enters on the right: 00000010 = 2.
3. Step 3
  (c) 258 requires 9 bits, but only 8 are available — this is overflow.
4. Step 4
  The most significant bit is lost, so the stored result of 2 bears no relation to the correct answer of 258.
5. Step 5
  (d) For the result to fit in 8 bits it must be ≤ 255, so the original value must be at most 255 ÷ 2 = 127.5 — that is, 127.
  $127 \times 2 = 254 \leq 255$
6. Step 6
  Check: 127 × 2 = 254, which fits; 128 × 2 = 256, which does not.
Answer
(a) 10000001 = 128 + 1 = 129. A left shift by 1 multiplies by 2, so the value should become 258 (1)

(b) The bits all move one place left, the leading 1 is pushed off the end, and a zero enters on the right: 10000001 → 00000010 = 2 (1)

(c) The correct answer of 258 requires 9 bits, but only 8 are available (1). The most significant bit is therefore pushed out and lost, which is overflow — and the stored result of 2 bears no relation to the correct value (1)

(d) For the doubled result to fit within the 8-bit maximum of 255, the original value must be at most 255 ÷ 2 = 127.5, so the largest safe value is 127 (1). Checking: 127 × 2 = 254 which fits, whereas 128 × 2 = 256 which does not (1) (6)
Examiner tip
The dramatic failure — 129 becoming 2 rather than 258 — makes the point that overflow does not merely lose precision but destroys the result entirely. Part (d) requires reasoning back from the 8-bit maximum, and the neat way to express it is that any value with the most significant bit set will overflow when shifted left.
9Compare shifting with multiplication (6 marks)
StretchWord problem• Paper 2 style — 6 marks (AO3)• shift, compare, multiplication, limitation
Question
A programmer needs to multiply values by different amounts in a graphics program running on a low-power device.

(a) Explain why a binary shift would be suitable for multiplying by 16 but not by 10. (b) Explain the advantage of using a shift where it is possible. (c) Explain one risk the programmer must consider when using left shifts. (6 marks)
Step-by-step solution
1. Step 1
  (a) 16 is a power of 2 — specifically 2⁴ — so multiplying by 16 is a shift left by 4 places.
2. Step 2
  10 is not a power of 2. Shifting by 3 multiplies by 8 and shifting by 4 multiplies by 16, so no single shift gives 10.
3. Step 3
  Multiplying by 10 therefore needs a genuine multiplication (or a combination such as shift-by-3 plus shift-by-1 added together, which is beyond what is required here).
4. Step 4
  (b) A shift is far faster — it moves bits along wires in a single clock cycle, whereas multiplication needs a more complex circuit and several cycles. On a low-power device that difference is significant.
5. Step 5
  (c) The risk is overflow. Shifting left pushes the most significant bits off the end, and those bits are lost.
6. Step 6
  Give the consequence: if the result exceeds the maximum the register can hold, the stored value will be badly wrong rather than merely imprecise.
Answer
(a) 16 is a power of 2 — it is 2⁴ — so multiplying by 16 can be achieved with a shift left by 4 places (1). 10 is not a power of 2: shifting left by 3 multiplies by 8 and shifting by 4 multiplies by 16, so there is no shift that multiplies by 10 (1). Multiplying by 10 therefore requires a genuine multiplication instruction (1).

(b) A shift is much faster than a multiplication, because it simply moves every bit one or more places along and typically completes in a single clock cycle, whereas multiplication requires a more complex circuit and several clock cycles (1). On a low-power device with limited processing capability, that saving is significant, especially in graphics work where the operation may be repeated for every pixel (1).

(c) The risk is overflow: shifting left pushes the most significant bits off the end of the register and they are lost permanently (1). If the result exceeds the largest value the register can hold, the stored answer will be completely wrong rather than merely imprecise — shifting 129 left by 1 in 8 bits produces 2 instead of 258.
Examiner tip
The distinction in part (a) is what defines the limits of the technique: shifts handle only powers of 2. Part (b) rewards tying the speed advantage to the specific scenario — a low-power device performing a repeated operation — which is where the AO3 credit lies.

Model Answers — Binary arithmetic

High-scoring sample answers for binary arithmetic on the AQA GCSE 8525 paper, with examiner-style notes mapping each response to the mark scheme and assessment objectives.

Question 1
Paper 2 style — AO22 marks
Add the binary numbers 00001111 and 00000001. Show your working. (2 marks)
Model answer
0 0 0 0 1 1 1 1 15 + 0 0 0 0 0 0 0 1 1 --------------- carry 1 1 1 1 --------------- 0 0 0 1 0 0 0 0 16

Answer: 00010000 (1 for the carries, 1 for the correct answer.)

Check: 15 + 1 = 16, and 00010000 = 16 ✓
Why this scores
A neat cascade of carries: four consecutive columns each produce 1 + 1 = 0 carry 1, propagating all the way to the 16s column. This is the binary equivalent of 999 + 1 = 1000 in decimal.
Question 2
Paper 2 style — AO12 marks
State the effect on a binary number's value of (a) a logical shift left by 3 places and (b) a logical shift right by 2 places. (2 marks)
Model answer
(a) A shift left by 3 places multiplies the value by 2³ = 8 (1). (b) A shift right by 2 places divides the value by 2² = 4 (1).
Why this scores
State the multiplier or divisor as an actual number rather than saying only 'it gets bigger'. The general rule is that shifting by n places multiplies or divides by 2ⁿ, which is why shifts can only handle powers of 2.
Question 3
Paper 2 style — AO22 marks
Apply a logical shift right of 1 place to the binary number 00110100 and give the result as an 8-bit number. (2 marks)
Model answer
Every bit moves one place right and a zero enters from the left:

00110100 → 00011010 (1)

Check: 00110100 = 52 and 00011010 = 26, and 52 ÷ 2 = 26 ✓ (1)
Why this scores
The result must remain 8 bits, so the vacated leftmost position is filled with a zero. This shift is exact because 52 is even; had the number been odd, the rightmost 1 would have been lost and the remainder discarded.
Question 4
Paper 2 style — AO24 marks
Add the three binary numbers 00010001, 00100010 and 00000100, showing your working and checking in decimal. (4 marks)
Model answer
0 0 0 1 0 0 0 1 17 0 0 1 0 0 0 1 0 34 + 0 0 0 0 0 1 0 0 4 --------------- 0 0 1 1 0 1 1 1 55

Answer: 00110111 (2 marks for method and carries, 1 for the answer.)

Decimal check: 17 + 34 + 4 = 55, and 00110111 = 32 + 16 + 4 + 2 + 1 = 55 ✓ (1)
Why this scores
No column here contains more than one 1 across the three numbers, so no carries arise at all — the specification's limit of three 1s per column guarantees that even in the worst case the carry never exceeds 1. Always finish with the decimal check.
Question 5
Paper 2 style — AO2/AO33 marks
The binary number 00000111 is shifted right by 1 place. Explain why the result is not exactly half of the original value. (3 marks)
Model answer
00000111 is 7, and shifting right by 1 gives 00000011, which is 3 (1).

Half of 7 is 3.5, but the 0.5 cannot be stored because that would require a fractional representation, which is not used here — the bit shifted off the right-hand end is simply lost (1).

The remainder is therefore discarded and the value is rounded down, making the operation equivalent to integer division: 7 DIV 2 = 3 (1).
Why this scores
The specification states explicitly that fractional representations are not required, which is precisely why a right shift truncates rather than rounding. The link to DIV in 3.2.3 is exact — integer division by a power of 2 is a right shift.
Question 6
Paper 2 style — AO23 marks
A program needs to multiply a value by 32 as efficiently as possible. State the shift required and explain why this approach is faster than using multiplication. (3 marks)
Model answer
32 = 2⁵, so the operation required is a shift left by 5 places (1).

This is faster because a shift simply moves every bit along by a fixed number of positions, which the hardware can do in a single clock cycle (1). A full multiplication requires a more complex circuit and takes several clock cycles, so replacing it with a shift saves processing time — which is why compilers automatically substitute shifts for multiplication by powers of 2 (1).
Why this scores
Both halves are needed: the correct shift and the speed reason. Note the boundary of the technique — this works only because 32 is a power of 2; multiplying by 30 could not be done with a single shift.
Question 7
Paper 2 style — AO2/AO36 marks
(a) Add the binary numbers 01001100 and 00110011, showing your working. (b) Apply a logical shift left of 1 place to your answer and give the result. (c) State the decimal values at each stage and explain whether the shift produced the correct result. (6 marks)
Model answer
(a)

0 1 0 0 1 1 0 0 76 + 0 0 1 1 0 0 1 1 51 --------------- 0 1 1 1 1 1 1 1 127

Answer: 01111111 (2 marks)

(b) Shifting left by 1, with a zero entering on the right: 01111111 → 11111110 (1)

(c) The decimal values are:

Before addition: 76 and 51 (1)

After addition: 76 + 51 = 127, and 01111111 = 127 ✓ (1)

After the shift: 11111110 = 254, and 127 × 2 = 254 ✓ (1)

The shift did produce the correct result, because 254 still fits within the 8-bit maximum of 255. Had the value before the shift been 128 or more, the result would have exceeded 255 and the most significant bit would have been lost, causing overflow.
Why this scores
This question deliberately sits at the very edge of the 8-bit range: 127 is the largest value that can be safely shifted left by 1, since 127 × 2 = 254 fits but 128 × 2 = 256 does not. Recognising that boundary is what the final mark rewards.
Question 8
Paper 2 style — AO35 marks
Explain why shifting a binary number one place to the left doubles its value, referring to place values in your answer. (5 marks)
Model answer
In binary, each column has a place value that is a power of 2, and every place value is exactly double the one to its right — 1, 2, 4, 8, 16, 32, 64, 128 (1).

When a bit is shifted one place to the left, it moves into a column whose place value is twice as large (1). For example, a 1 in the 4s column contributes 4 to the total; after shifting left it sits in the 8s column and contributes 8 — exactly double its previous contribution (1).

Because every bit in the number moves left simultaneously, every contribution to the total is doubled (1), so the value of the whole number is doubled. Shifting left by n places moves each bit n columns, multiplying each contribution by 2ⁿ and therefore multiplying the whole number by 2ⁿ (1).
Why this scores
This asks students to justify a rule they normally apply mechanically, which is genuinely demanding. The pivot is that every place value is double the one to its right, so moving a bit one column left doubles its contribution — and since all bits move together, the whole value doubles. A worked example with a specific column strengthens the answer considerably.
Question 9
Paper 2 style — AO1/AO36 marks
Explain what is meant by overflow, describe how it can occur during both binary addition and a left shift, and state its consequence. (6 marks)
Model answer
Definition. Overflow occurs when the result of a calculation is too large to be stored in the number of bits available (1). In an 8-bit register the largest storable value is 255, so any result of 256 or more cannot be held (1).

During addition. If two numbers are added and the total exceeds 255, a carry is produced out of the most significant (128s) column with nowhere to go — adding 11111111 (255) and 00000001 (1) gives 256, which needs 9 bits (1). The ninth bit cannot be stored, so the register holds 00000000 — zero — instead of the correct answer.

During a left shift. Shifting left doubles the value, so shifting any number with the most significant bit set pushes that bit off the end of the register, where it is lost (1). Shifting 10000001 (129) left by 1 should give 258, but the leading 1 is lost and the stored result is 00000010 — just 2 (1).

Consequence. In both cases the bit that is lost cannot be recovered, so the stored result is incorrect — and because the processor continues without any error being visible in the data itself, the wrong value may be used in subsequent calculations, producing errors that are difficult to trace (1).
Why this scores
The definition must be about the number of bits available, not simply 'the number is too big'. Covering both routes — addition and left shift — is what the question asks for, and the strongest closing point is that the calculation continues silently with a wrong value, which makes overflow bugs hard to detect.

Key Formulae — Binary arithmetic

The formulae you need to memorise for binary arithmetic on the AQA GCSE 8525 paper, with every variable defined in plain English and a note on when to use it.

Logical shift left
$\text{shift left by } n \text{ places} = \times\, 2^n$
$n$
The number of places shifted
$Zeros$
Fill the vacated positions on the right
When to use
Multiplying by a power of 2. Only valid if the result still fits in the available bits — otherwise the most significant bits are lost and the result overflows.
Example
00001011 (11) shifted left 2 → 00101100 (44), since 11 × 2² = 44
Logical shift right
$\text{shift right by } n \text{ places} = \div\, 2^n$
$n$
The number of places shifted
$Zeros$
Fill the vacated positions on the left
When to use
Dividing by a power of 2. Bits shifted off the right are lost, so any remainder is discarded — this is integer division, not true division.
Example
00001011 (11) shifted right 1 → 00000101 (5), since 11 DIV 2 = 5
Binary addition rules
$0{+}0{=}0 \;\;|\;\; 0{+}1{=}1 \;\;|\;\; 1{+}1{=}0\text{ carry }1 \;\;|\;\; 1{+}1{+}1{=}1\text{ carry }1$
$Direction$
Always work from right to left
$Limit$
At most three 1s per column, so the carry is never more than 1
When to use
Every binary addition. Show the carry row — marks are awarded for correct carries independently of the final answer.
Example
00101101 + 00010110 = 01000011 (45 + 22 = 67)

Key Definitions and Keywords — Binary arithmetic

Definitions to memorise and the exact keywords mark schemes credit for binary arithmetic answers — sharpened from recent examiner reports for the 2026 AQA GCSE 8525 sitting.

Binary addition
Examiner keyword
Adding binary numbers column by column from the right, carrying into the next column when a column sums to 2 or more. AQA sets a maximum of three numbers, 8 bits each, and three 1s per column.
Example
0+0=0, 0+1=1, 1+1=0 carry 1, 1+1+1=1 carry 1
Related: Carry, Overflow
Carry
Examiner keyword
The 1 passed into the next column to the left when a binary column sums to 2 or more. Because AQA limits a column to three 1s, the carry is never greater than 1.
Related: Binary addition, Overflow
Overflow
Examiner keyword
When the result of a calculation is too large to be stored in the number of bits available. The lost bit cannot be recovered, so the stored result is incorrect.
Example
In 8 bits, 255 + 1 = 256 needs 9 bits and overflows.
Related: Carry, Logical shift left
Logical binary shift
Examiner keyword
Moving every bit in a number a given number of places left or right. Zeros fill the vacated positions and bits shifted off the end are lost. Only logical shifts are required by the specification.
Related: Logical shift left, Logical shift right
Shift left
Examiner keyword
Moving every bit n places to the left, which multiplies the value by 2ⁿ. Zeros enter from the right; bits pushed off the left are lost, which can cause overflow.
Example
00001011 (11) shifted left 2 = 00101100 (44)
Related: Shift right, Overflow
Shift right
Examiner keyword
Moving every bit n places to the right, which divides the value by 2ⁿ. Zeros enter from the left; bits pushed off the right are lost, so any remainder is discarded.
Example
00001011 (11) shifted right 1 = 00000101 (5), not 5.5
Related: Shift left, Integer division
Lost bits
Examiner keyword
Bits pushed off either end of a register during a shift. They cannot be recovered — a right shift loses precision, and a left shift can lose the most significant bits entirely.
Related: Logical binary shift, Overflow
Loss of precision
Examiner keyword
The discarding of a remainder when a right shift divides an odd number, making the operation equivalent to integer division rather than true division.
Example
11 shifted right 1 gives 5, because the 0.5 cannot be stored.
Related: Shift right, Integer division
Most significant bit
Examiner keyword
The leftmost bit, carrying the largest place value of 128 in an 8-bit number. A left shift pushes this bit out of the register, so any number with it set will overflow when shifted left.
Related: Overflow, Shift left
Power of 2
Examiner keyword
A value of the form 2ⁿ — 2, 4, 8, 16, 32 and so on. Binary shifts can only multiply or divide by powers of 2, so multiplying by 10 requires a genuine multiplication.
Related: Shift left, Shift right
Clock cycle
One tick of the processor's clock. A shift typically completes in a single clock cycle, whereas multiplication or division requires several — which is why shifts are used for arithmetic by powers of 2.
Related: Logical binary shift
Column addition
Examiner keyword
Adding binary numbers right to left, one column at a time, carrying into the next column whenever the total reaches 2. The same method as decimal column addition, with a different carry point.
Related: Binary addition, Carry

Common Mistakes and Misconceptions — Binary arithmetic

The traps other students keep falling into on binary arithmetic questions — taken from recent AQA GCSE 8525 examiner reports and mark schemes — and how to avoid them.

✕Writing 1 + 1 = 2 in a binary addition.
AQA 8525 specification 3.3.4 limits a column to three 1s precisely so that the carry never exceeds 1.
Why it happens
Decimal arithmetic is completely automatic, so the answer appears before the base has been consciously registered — especially under time pressure.
How to avoid it
There is no digit 2 in binary. 1 + 1 is 10 — write 0 and carry 1, exactly as 5 + 5 = 10 in decimal is written as 0 carry 1. Learn the two carry rules as a pair: 1+1 = 0 carry 1 and 1+1+1 = 1 carry 1.
✕Performing a binary addition without writing down the carry row.
Binary addition mark schemes credit correct carries as a separate method mark.
Why it happens
The carries are held mentally to save time, and the working looks tidier without them — until a single column is misremembered and the whole answer is wrong.
How to avoid it
Mark schemes award marks for correct carries independently of the final answer, so showing them protects marks even when the arithmetic slips. Write the carry row above the sum and always finish with a decimal check.
✕Shifting the bits but leaving the vacated positions empty, giving an answer with fewer than 8 bits.
AQA 8525 specification 3.3.4 specifies logical shifts using a maximum of 8 bits.
Why it happens
The bits are physically moved along on paper and the gap at one end is easy to overlook, since the value 'looks' complete.
How to avoid it
A logical shift always fills the vacated positions with zeros, and the answer must still be 8 bits long. After shifting, count the digits — if there are not eight, zeros are missing.
✕Confusing which shift direction multiplies and which divides.
Shift questions require both the resulting bit pattern and the effect on the value, so the direction must be correct for both marks.
Why it happens
Both operations look identical on the page — every bit simply moves along — so the association with multiplication or division has to be recalled rather than seen.
How to avoid it
Anchor it to place values: moving left puts each bit into a column worth double, so left multiplies. Moving right halves each place value, so right divides. Confirm with a small example — 0001 (1) shifted left becomes 0010 (2).
✕Assuming a right shift always gives exactly half the original value.
AQA 8525 specification 3.3.4 states that students will not need to understand or use fractional representations.
Why it happens
It is exactly half for every even number, which covers most classroom examples — the truncation only appears when an odd number is shifted.
How to avoid it
Bits shifted off the right are lost, so any remainder is discarded: 11 shifted right by 1 gives 5, not 5.5. The operation is integer division (DIV), and the specification excludes fractional representations, which is exactly why the remainder cannot be kept.
✕Assuming a shift can multiply or divide by any value, such as 10 or 3.
AQA 8525 specification 3.3.4 states that binary shifts can be used to perform simple multiplication and division by powers of 2.
Why it happens
Shifting is presented as a fast alternative to multiplication, so it is easy to over-generalise into a substitute for multiplication in general.
How to avoid it
A shift changes each place value by a factor of two, so it can only multiply or divide by powers of 2 — 2, 4, 8, 16, 32. Multiplying by 10 or 3 requires a genuine multiplication instruction, and stating that limitation is often worth a mark.

Binary Arithmetic — AQA GCSE Computer Science 8525 (3.3.4)

Sum

Result

Carry

0 + 0

—

0 + 1

—

1 + 1

carry 1

1 + 1 + 1

carry 1

Column

Sum

Write

Carry out

0 + 0

—

1 + 1

0 + 1 + carry 1

1 + 0 + carry 1

16s

1 + 1 + carry 1

32s

0 + 1 + carry 1

64s

1 + 0 + carry 1

128s

0 + 0 + carry 1

—

1 1 1 1 1 1 1 1 255 + 0 0 0 0 0 0 0 1 1 --------------- 1 0 0 0 0 0 0 0 0 256 — needs 9 bits! ↑ this carry has nowhere to go in an 8-bit register

Shift

Risk

When it is safe

Right

Loses the remainder (rounds down)

When the number divides exactly by 2ⁿ

Left

Can overflow, losing the answer entirely

When the result is ≤ 255

Places shifted

Left = multiply by

Right = divide by

Situation

Shift used

Doubling or halving a value quickly

Left or right by 1

Scaling an image by a power of 2

Left or right by n

Adjusting audio volume by a factor of 2

Left or right by 1

Extracting parts of a colour code

Right by 8 or 16

Converting between units that differ by a power of 2

Shift by the appropriate n

Fast calculation in embedded systems with limited processing power

Shift instead of multiply

Binary arithmetic

Detailed Study Notes

At a glance

What you’ll learn

Binary addition — the four rules

The four rules

Worked addition of two numbers

Adding three numbers

The 8-bit limit and overflow

What overflow is

Why it matters

The useful check

Logical binary shifts

Shift LEFT — multiplies

Shift RIGHT — divides

Why shifting works

What happens to bits that are shifted out

Right shift — loss of precision

Left shift — possible overflow

Summary of the risks

Where binary shifts are used

The powers of 2

Why processors use shifts

Genuine applications

A worked application

Quick recap

Memorise this

How it’s examined

Take this whole topic with you

1Apply the four binary addition rules (3 marks)

2Add two 8-bit binary numbers (4 marks)

3Apply a logical shift left (3 marks)

4Add three binary numbers (5 marks)

5Explain what happens to bits shifted out (5 marks)

6Explain overflow in an 8-bit addition (4 marks)

7Describe where binary shifts are used (6 marks)

8Analyse a left shift that overflows (6 marks)

9Compare shifting with multiplication (6 marks)

Logical shift left

Logical shift right

Binary addition rules

Binary addition

Carry

Overflow

Logical binary shift

Shift left

Shift right

Lost bits

Loss of precision

Most significant bit

Power of 2

Clock cycle

Column addition

✕Writing 1 + 1 = 2 in a binary addition.

✕Performing a binary addition without writing down the carry row.

✕Shifting the bits but leaving the vacated positions empty, giving an answer with fewer than 8 bits.

✕Confusing which shift direction multiplies and which divides.

✕Assuming a right shift always gives exactly half the original value.

✕Assuming a shift can multiply or divide by any value, such as 10 or 3.

Binary arithmetic

Detailed Study Notes

At a glance

What you’ll learn

Binary addition — the four rules

The four rules

Worked addition of two numbers

Adding three numbers

The 8-bit limit and overflow

What overflow is

Why it matters

The useful check

Logical binary shifts

Shift LEFT — multiplies

Shift RIGHT — divides

Why shifting works

What happens to bits that are shifted out

Right shift — loss of precision

Left shift — possible overflow

Summary of the risks

Where binary shifts are used

✕Writing `1 + 1 = 2` in a binary addition.