Why is "Filling the vacated bit positions with the wrong value after a logical shift — leaving them blank, or copying the old bits across." a common mistake in Bit manipulation?

Why it happens: Students focus on moving the bits and forget that the empty positions must be explicitly filled. How to avoid it: For a LOGICAL shift always feed in 0s at the vacated end. For an ARITHMETIC right shift copy the sign bit; for a CYCLIC shift bring round the bits that fell off the other end. Source: Examiner reports note that omitting the fed-in zeros is a frequent reason shift answers lose the answer mark.

Why is "Mixing up the operators: using AND to set a bit, or OR to test/clear a bit." a common mistake in Bit manipulation?

Why it happens: All three operators look similar and students memorise 'use a mask' without the per-operator rule. How to avoid it: Memorise the trio: OR with 1 = SET, AND with 0 = CLEAR, AND with 1 = TEST/keep, XOR with 1 = TOGGLE.

Why is "Writing the wrong mask — e.g. using 1s everywhere except the target bit when setting, instead of a single 1 in the target bit." a common mistake in Bit manipulation?

Why it happens: Students confuse the 'set' mask (a single 1) with the 'clear' mask (a single 0 among 1s). How to avoid it: For OR (set) and XOR (toggle) the mask has 1 only in the target bit(s). For AND (clear) the mask has 0 only in the target bit(s) and 1 everywhere else.

Why is "Counting bit positions from the wrong end, giving an off-by-one error in the mask." a common mistake in Bit manipulation?

Why it happens: Some questions number bits from the left, but the convention used is usually bit 0 = rightmost (LSB). How to avoid it: Confirm which bit is bit 0 (almost always the rightmost), then line the mask's single 1 or 0 up with that position's place value (bit 3 = place value 8).

Why is "Using a logical right shift (feeding in 0) on a negative two's complement value and assuming it still divides correctly." a common mistake in Bit manipulation?

Why it happens: Students apply the unsigned 'right shift = divide by 2' rule to signed numbers. How to avoid it: For signed division use an ARITHMETIC shift, which preserves the sign bit. A logical right shift feeds in a 0, turning a negative number positive — wrong for signed values.

Why is "Claiming a logical left shift always multiplies by a power of 2, even when a 1-bit is shifted off the left end." a common mistake in Bit manipulation?

Why it happens: Students learn the ×2 rule without the condition that no significant bit is lost. How to avoid it: The ×2^n result only holds if no 1-bit falls off the most significant end (otherwise the value wraps/overflows). State this condition for full marks.

Cambridge International A Levels Computer Science (9618)

Bit manipulation

0% Complete

Detailed Study Notes

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

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

How to shift binary patterns (logical, arithmetic and cyclic), how shifts multiply and divide, and how to test, set, clear and toggle individual bits with masks using bitwise AND, OR and XOR — including how this lets a processor monitor and control a device. Everything is done by hand on 8-bit values; no calculator is allowed in Paper 1.

At a glance

A logical shift moves all bits left/right, feeds in 0s, and loses bits off the end.
LSL #n multiplies an unsigned value by 2^n; LSR #n divides an unsigned value by 2^n.
An arithmetic right shift preserves the sign bit — used for signed (two's complement) division.
A cyclic (rotate) shift loses no bits: bits that fall off one end re-enter the other end.
A bit mask + a bitwise operator lets you work on individual bits.
AND with 1 = keep / test; AND with 0 = clear a bit.
OR with 1 = set a bit; OR with 0 = leave unchanged.
XOR with 1 = toggle (flip) a bit; XOR with 0 = leave unchanged.
Bit manipulation lets a processor monitor sensor flags and control devices (turn on/off) via a status register.

What you’ll learn

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

4.3 — Show understanding of and perform binary shifts: logical, arithmetic and cyclic, for both left and right shifts.
4.3 — Show how binary shifts can be used to multiply and divide by powers of 2 and recognise when bits are lost.
4.3 — Show how bit manipulation can be used to monitor and/or control a device.
4.3 — Test and set/clear a bit using bit masking with the bitwise operators AND, OR and XOR.
4.3 — Use the given instruction set (AND, OR, XOR with #n / Bn / &n / <address>; LSL #n; LSR #n) and labels for instructions and data.

What bit manipulation is (and why it matters)

Working with individual bits inside a byte, not just the whole number.

Most of the time a program works with whole numbers, but sometimes each individual bit of a byte carries its own meaning. Bit manipulation is the set of techniques for moving, testing and changing those single bits.

Two big jobs use it:

Shifts — sliding all the bits left or right. This is how a processor can multiply or divide by powers of 2 very quickly, and it is also used inside graphics and encryption.
Bit masking — using a pattern (a mask) with a bitwise operator (AND, OR, XOR) to test, set, clear or toggle chosen bits without disturbing the others.

A common real use is a status register where each bit is a separate on/off flag — for example bit 0 = 'heater on', bit 7 = 'temperature too high'. To read or change just one flag you must manipulate a single bit, which is exactly what masks are for.

Term	Meaning
Bit 0	the rightmost bit (least significant), place value 1
MSB	most significant bit — the leftmost
Mask	a binary pattern chosen to pick out particular bit positions

Bit manipulation = working on individual bits, not the whole value.
Shifts slide bits left/right (fast ×/÷ by powers of 2).
Masks test/set/clear/toggle chosen bits with AND/OR/XOR.
Bit 0 is usually the rightmost (least significant) bit.

Logical shifts (LSL and LSR)

All bits move; zeros fill the gap; bits off the end are lost.

A logical shift moves every bit a fixed number of places. The vacated positions are filled with 0, and any bits pushed off the end are lost.

LSL #n — logical shift left by n: bits move left, 0s feed in on the right, top bits fall off.
LSR #n — logical shift right by n: bits move right, 0s feed in on the left, bottom bits fall off.

Here is a logical shift left by 1, with a zero entering at the right:

Shifts as fast multiply/divide (unsigned values):

LSL #n multiplies by 2^n. Example: 00010011 (19) LSL #2 → 01001100 (76), and 19 × 4 = 76.
LSR #n divides by 2^n. Example: 10110100 (180) LSR #1 → 01011010 (90), and 180 ÷ 2 = 90.

Condition: the ×2^n rule only holds for a left shift if no 1-bit falls off the most significant end (otherwise the value wraps and the answer is wrong). For LSR, the division is exact only if the bits that fall off the right were 0.

Logical shift: all bits move, 0s fill the gap, end bits are lost.
LSL #n × 2^n (unsigned); LSR #n ÷ 2^n (unsigned).
Left shift only multiplies cleanly if no 1-bit is lost off the left.
LSR feeds a 0 into the leftmost position.

See the full worked example for bit manipulation →

Arithmetic and cyclic shifts

Arithmetic preserves the sign bit; cyclic loses no bits.

Besides the logical shift, 9618 needs two more shift types.

Arithmetic shift — for SIGNED (two's complement) numbers. On an arithmetic right shift the sign bit (MSB) is preserved (copied into the vacated left-hand positions). This keeps a negative number negative and performs signed division by a power of 2.

11110000 (−16) arithmetic-shifted right by 1 → 11111000 (−8). The leading 1 (the sign) is copied in, not a 0.
A logical right shift here would feed in a 0 → 01111000 (+120), which is wrong for a signed value.
(An arithmetic left shift feeds in 0s, just like a logical left shift.)

Cyclic (circular / rotate) shift — no bits are lost. Bits that fall off one end re-enter at the other end, so the bits simply rotate around the byte. The total number of 1s never changes.

Summary of the three shift types:

Shift	Right-shift fill	Bits off the end
Logical	0	lost
Arithmetic	copy of sign bit	lost
Cyclic	the bit from the other end	re-enter the other end (kept)

Arithmetic right shift copies the sign bit → keeps the sign for signed division.
Logical right shift on a negative value gives the wrong (positive) result.
Cyclic shift loses no bits — they wrap around to the other end.
Number of 1s is unchanged by a cyclic shift.

Bit masks and the three operators

AND tests/clears, OR sets, XOR toggles — choose the mask carefully.

A bit mask is a binary pattern you combine with a value using a bitwise operator. The operator decides what happens; the mask decides which bits it happens to.

Learn these truth-table facts — they are the whole topic:

Operator	Rule with mask bit 1	Rule with mask bit 0	Used to…
AND	keeps the bit (test)	clears the bit to 0	test or clear
OR	sets the bit to 1	leaves the bit unchanged	set
XOR	toggles (flips) the bit	leaves the bit unchanged	toggle

The four standard operations (target = bit 3, value 00001011):

Test bit 3: AND B00001000 → 00001000. Non-zero ⇒ the bit is set; zero ⇒ it is clear.
Set bit 5: OR B00100000 → forces bit 5 to 1, others unchanged.
Clear bit 0: AND B11111110 → forces bit 0 to 0 (note: 0 only in the target bit, 1s elsewhere).
Toggle bit 1: XOR B00000010 → flips bit 1 to its opposite, others unchanged.

Choosing the mask is where marks are won or lost:

For OR (set) and XOR (toggle) the mask has a 1 in the target bit(s) and 0 elsewhere.
For AND (clear) the mask has a 0 in the target bit(s) and 1 everywhere else (the 1s preserve the bits you want to keep).
For AND (test) the mask has a 1 in the bit you are testing and 0 elsewhere, so only that bit can survive.

In the given instruction set you can supply the mask as a binary literal (AND B00001000), as a denary number (AND #8), or from a labelled memory location (AND <address>).

Mask = which bits; operator = what happens to them.
OR with 1 sets; AND with 0 clears; AND with 1 tests/keeps; XOR with 1 toggles.
Set/toggle masks have a 1 in the target bit; clear masks have a 0 there and 1s elsewhere.
A test (AND) result that is non-zero means the tested bit was set.

See the full worked example for bit manipulation →

Monitoring and controlling a device

Read sensor flags with AND; switch devices with OR (on) and AND (off).

Embedded systems use a status / control register where each bit is a separate flag for a sensor or a device. Bit manipulation is how the processor monitors inputs and controls outputs.

Imagine a greenhouse controller whose 8-bit register has: bit 0 = heater, bit 1 = fan, bit 7 = 'temperature too high' sensor (bit 0 is rightmost).

Monitoring (reading a sensor flag) — use AND:

LDD  STATUS
AND  B10000000     ; mask = 1 only in bit 7

If the result is non-zero, bit 7 is set (too hot). If it is zero, the flag is clear.

Control — switch a device ON (set its bit) — use OR:

LDD  STATUS
OR   B00000010     ; set bit 1 → fan ON
STO  STATUS

Control — switch a device OFF (clear its bit) — use AND:

LDD  STATUS
AND  B11111110     ; 0 in bit 0, 1s elsewhere → heater OFF
STO  STATUS

The pattern is always: load the register, mask it to test or change just the bit(s) you care about, then (for control) store the result back. Every other device's bit is untouched because the mask is 0 (for OR) or 1 (for AND) in those positions.

Status register: one bit per sensor/device flag.
Monitor a sensor bit with AND + a single-1 mask (non-zero ⇒ set).
Turn a device ON with OR (set its bit); OFF with AND (clear its bit).
Always load, mask, then store the result back to the register.

See the full worked example for bit manipulation →

Exam technique and the instruction set

Use the given ACC instructions, binary masks and clear bit numbering.

The questions are short and very rule-based, so accuracy and the right vocabulary score the marks.

The instructions you are given (assembly-style):

Instruction	Effect
`LSL #n`	logical shift left by n (0s in on the right)
`LSR #n`	logical shift right by n (0s in on the left)
`AND #n` / `AND Bn` / `AND &n` / `AND <address>`	bitwise AND with the operand
`OR #n` / `OR Bn` / `OR &n` / `OR <address>`	bitwise OR with the operand
`XOR #n` / `XOR Bn` / `XOR &n` / `XOR <address>`	bitwise XOR with the operand

(Operands: #n = denary, Bn = binary, &n = hexadecimal, <address>/label = a memory location. You may also label instructions and data.)

A reliable answering routine:

Decide the action: test, set, clear, toggle, or shift.
Pick the operator: AND (test/clear), OR (set), XOR (toggle), LSL/LSR (shift).
Build the mask: a single 1 in the target bit for set/test/toggle; a single 0 (1s elsewhere) for clear.
Apply it bit by bit and write the full 8-bit result.
State the rule in words ('OR with 1 sets the bit') — this earns the explanation marks.

Show your working on shifts (the moved bits and the fed-in 0s) and always give the answer to the full 8 bits requested.

Operands: #n denary, Bn binary, &n hex, <address> a labelled location.
Routine: action → operator → mask → apply → state the rule.
Give shift answers to the full bit length with the fed-in 0s shown.
Explanation marks need the rule in words, not just a bit pattern.

Quick recap

Logical shift: bits move, 0s fill the gap, end bits are lost; LSL ×2^n, LSR ÷2^n (unsigned).
Arithmetic right shift preserves the sign bit (signed division); cyclic shift wraps bits round, losing none.
A mask picks the bits; the operator decides the action.
AND with 1 tests/keeps; AND with 0 clears; OR with 1 sets; XOR with 1 toggles.
Set/toggle masks have a 1 in the target bit; clear masks have a 0 there with 1s elsewhere.
Bit manipulation lets a processor monitor sensor flags (AND) and control devices on/off (OR / AND).
Always answer to the full 8 bits and state the operator's rule in words.

Memorise this

Verbatim phrases and definitions Cambridge mark schemes credit.

Logical shift: feed in 0s, bits off the end are lost.
LSL #n multiplies by 2^n; LSR #n divides by 2^n (unsigned).
Arithmetic right shift copies the sign bit (for signed division).
Cyclic shift: bits that fall off one end re-enter the other (none lost).
AND with 1 = keep/test; AND with 0 = clear.
OR with 1 = set; OR with 0 = unchanged.
XOR with 1 = toggle; XOR with 0 = unchanged.
Set/test/toggle mask = single 1 in target bit; clear mask = single 0, 1s elsewhere.

How it’s examined

Section 4.3 is assessed in Paper 1 (Theory Fundamentals, 1 h 30 min, 75 marks) — written, externally assessed, no calculator. Expect short structured questions: perform a stated shift on an 8-bit value (give the result and the multiply/divide effect), distinguish logical/arithmetic/cyclic shifts, and write the operator + mask to test, set, clear or toggle a named bit. Scenario questions ask you to monitor a sensor and control a device via a status register. Show the masked working and state the operator's rule in words — explanation marks are available even when the bit pattern is otherwise correct.

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

Take this whole topic with you

Step-by-step worked examples — Bit manipulation

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

Question type:

1Logical shift left by 2 (LSL #2)
Getting startedDirect calculation• 9618 Paper 1 style• logical shift, LSL, AO2
Question
The 8-bit binary value 00010011 is in the accumulator. The instruction LSL #2 is executed. Give the contents of the accumulator after the shift and state the effect on the denary value. (3 marks)
Step-by-step solution
1. Step 1
  LSL #2 means a logical shift left by 2 places. Every bit moves 2 positions to the left.
  $00010011$
2. Step 2
  The two bits at the left-hand (most significant) end fall off and are lost. Two zeros are fed in at the right-hand (least significant) end.
  $00010011 \rightarrow 01001100$
3. Step 3
  A logical shift left by 2 multiplies an unsigned value by 2^2 = 4. Check: 00010011 = 19 and 01001100 = 76, and 19 × 4 = 76.
Answer
After LSL #2 the accumulator holds 01001100. The denary value is multiplied by 4 (19 → 76).
Examiner tip
1 mark for shifting all bits left, 1 mark for feeding zeros into the vacated right-hand positions, 1 mark for the ×4 effect. Always fill the empty positions with 0 for a LOGICAL shift — leaving them blank or copying the old bits loses marks.
2Logical shift right by 1 (LSR #1)
Getting startedDirect calculation• 9618 Paper 1 style• logical shift, LSR, AO2
Question
The 8-bit binary value 10110100 is in the accumulator. The instruction LSR #1 is executed. Give the contents of the accumulator after the shift and state the effect on the unsigned denary value. (3 marks)
Step-by-step solution
1. Step 1
  LSR #1 means a logical shift right by 1 place. Every bit moves 1 position to the right.
  $10110100$
2. Step 2
  The bit at the right-hand (least significant) end falls off and is lost. A single zero is fed in at the left-hand (most significant) end.
  $10110100 \rightarrow 01011010$
3. Step 3
  A logical shift right by 1 divides an unsigned value by 2^1 = 2 (any remainder is lost with the bit that falls off). Check: 10110100 = 180 and 01011010 = 90, and 180 ÷ 2 = 90.
Answer
After LSR #1 the accumulator holds 01011010. The unsigned denary value is divided by 2 (180 → 90).
Examiner tip
For a LOGICAL right shift the vacated left-hand bit is always filled with 0 — never copy the old sign bit (that would be an ARITHMETIC shift). Division only gives an exact answer when the bit that falls off the right is 0.
3Test a single bit with a mask (AND)
Building confidenceMulti-step problem• 9618 Paper 1 style• bit mask, bitwise AND, test a bit, AO2
Question
A status byte is held in the accumulator. Bit 3 (counting bit 0 as the rightmost) is a fault flag. Write the mask and the instruction that tests whether bit 3 is set, and explain how the result shows the answer. The accumulator currently holds 00001011. (4 marks)
Step-by-step solution
1. Step 1
  To TEST one bit, AND the byte with a mask that has a 1 in only that bit position and 0 everywhere else. Bit 3 has place value 8, so the mask is 00001000.
  $\text{AND } B00001000$
2. Step 2
  AND keeps a bit only where the mask is 1 (1 AND 1 = 1) and clears every other bit to 0 (anything AND 0 = 0). So only bit 3 of the byte can survive.
3. Step 3
  Apply the mask bit by bit to 00001011.
  $00001011 \;\text{AND}\; 00001000 = 00001000$
4. Step 4
  The result is not zero (it is 00001000), so bit 3 was a 1 — the fault flag is set. If the result had been 00000000, bit 3 would have been 0.
Answer
Mask = B00001000; instruction AND B00001000 gives 00001000. The result is non-zero, so bit 3 is set (the fault flag is on). A zero result would mean the bit is clear.
Examiner tip
The high-value points are: AND is used to TEST/isolate, the mask has a 1 only in the bit being tested, and the decision is 'result zero → bit clear, result non-zero → bit set'. State which bit is bit 0 to avoid an off-by-one error.
4Set a single bit with a mask (OR)
Building confidenceMulti-step problem• 9618 Paper 1 style• bit mask, bitwise OR, set a bit, AO2
Question
The accumulator holds the control byte 01000010. Write the mask and the instruction that SETS bit 5 (bit 0 is the rightmost) to 1 without changing any other bit, and give the result. (4 marks)
Step-by-step solution
1. Step 1
  To SET one bit to 1, OR the byte with a mask that has a 1 in that bit position and 0 everywhere else. Bit 5 has place value 32, so the mask is 00100000.
  $\text{OR } B00100000$
2. Step 2
  OR forces a bit to 1 wherever the mask is 1 (anything OR 1 = 1) and leaves every other bit unchanged (x OR 0 = x). So only bit 5 is affected.
3. Step 3
  Apply the mask bit by bit to 01000010.
  $01000010 \;\text{OR}\; 00100000 = 01100010$
4. Step 4
  Bit 5 has changed from 0 to 1; all the other bits are exactly as before. The bit is now set.
Answer
Mask = B00100000; instruction OR B00100000 gives 01100010. Bit 5 is now 1 and every other bit is unchanged.
Examiner tip
OR with a 1 SETS a bit; OR with 0 leaves a bit alone. The mask must be 0 everywhere except the target bit, otherwise you would set bits you did not intend to. Confusing OR (set) with AND (test/clear) is the most common error here.
5Toggle a bit with XOR
StretchMulti-step problem• 9618 Paper 1 style• bit mask, bitwise XOR, toggle, AO2
Question
A byte 11010110 stores eight on/off settings. Bit 1 and bit 4 (bit 0 is the rightmost) must each be flipped to the opposite state in a single instruction, leaving all other bits unchanged. Write the mask and instruction, give the result, and explain why XOR is the correct operator. (5 marks)
Step-by-step solution
1. Step 1
  To TOGGLE (flip) bits, XOR the byte with a mask that has a 1 in every bit you want to flip and 0 everywhere else. Bit 4 has place value 16 and bit 1 has place value 2, so the mask is 00010010.
  $\text{XOR } B00010010$
2. Step 2
  XOR rules: x XOR 1 = NOT x (the bit flips), and x XOR 0 = x (the bit is unchanged). So a 1 in the mask flips the matching bit and a 0 leaves it alone.
3. Step 3
  Apply the mask bit by bit to 11010110.
  $11010110 \;\text{XOR}\; 00010010 = 11000100$
4. Step 4
  Check the two target bits: bit 4 went 1 → 0 and bit 1 went 1 → 0; every other bit is identical to the original. XOR is correct because it is the only one of AND/OR/XOR that flips a bit to its opposite while leaving the others untouched.
Answer
Mask = B00010010; instruction XOR B00010010 gives 11000100. Bits 1 and 4 are flipped and all other bits are unchanged. XOR is used because XOR with 1 inverts a bit and XOR with 0 preserves it.
Examiner tip
A* discriminator: XOR with 1 = toggle, XOR with 0 = keep. XOR-ing the same mask twice returns the original byte — a property worth quoting. AND and OR cannot flip a bit conditionally, so they score nothing for a 'toggle' question.
6Monitor and control a device with bit masking
StretchWord problem• 9618 Paper 1 style• monitor and control, bit mask, AND, OR, AO2
Question
A microcontroller controls a greenhouse. Its 8-bit status register STATUS has: bit 0 = heater on/off, bit 1 = fan on/off, bit 7 = 'temperature too high' sensor flag (bit 0 is the rightmost). Using the ACC instruction set, write the steps to (a) test whether the temperature-too-high flag (bit 7) is set, and (b) if it is, turn the fan ON (set bit 1) and turn the heater OFF (clear bit 0). Explain each mask. (6 marks)
Step-by-step solution
1. Step 1
  (a) To MONITOR bit 7, load the status register and AND it with a mask that is 1 only in bit 7 (place value 128 = 10000000). A non-zero result means the flag is set.
  $\text{LDD STATUS} \;\;|\;\; \text{AND } B10000000$
2. Step 2
  If the AND result is zero, bit 7 is clear (temperature OK) and no action is needed. If it is non-zero, bit 7 is set, so carry out the control actions in steps 3–4.
3. Step 3
  (b) To CONTROL the fan — turn it ON — set bit 1 by OR-ing with a mask that is 1 only in bit 1 (00000010). OR with 1 forces the bit to 1; OR with 0 leaves the others unchanged.
  $\text{LDD STATUS} \;\;|\;\; \text{OR } B00000010 \;\;|\;\; \text{STO STATUS}$
4. Step 4
  To turn the heater OFF — clear bit 0 — AND with a mask that is 0 in bit 0 and 1 everywhere else (11111110). AND with 0 clears the bit; AND with 1 keeps the others.
  $\text{LDD STATUS} \;\;|\;\; \text{AND } B11111110 \;\;|\;\; \text{STO STATUS}$
Answer
(a) Monitor: LDD STATUS; AND B10000000 — non-zero result means bit 7 (too hot) is set. (b) Control: to set the fan, LDD STATUS; OR B00000010; STO STATUS. To clear the heater, LDD STATUS; AND B11111110; STO STATUS. OR with a 1 sets a bit, AND with a 0 clears a bit, and 1s in the AND mask preserve the bits you want to leave alone.
Examiner tip
This is the classic 'bit manipulation controls a device' question. Marks are for: AND mask with a single 1 to monitor a sensor bit; OR mask with a single 1 to switch a device on; AND mask with a single 0 (and 1s elsewhere) to switch a device off; and storing the result back. State clearly which operator sets, clears or tests — examiners want the rule, not just the bit pattern.

Model Answers — Bit manipulation

High-scoring sample answers for bit manipulation 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
Explain what is meant by a logical shift left by 1 place applied to an 8-bit binary value. (2 marks)
Model answer
In a logical shift left by 1, every bit moves one position to the left. The bit at the most significant (left-hand) end falls off and is lost, and a 0 is fed in at the least significant (right-hand) end.
Why this scores
1 mark for 'all bits move left', 1 mark for 'a 0 is fed in at the right / the leftmost bit is lost'. Mentioning that this multiplies an unsigned value by 2 is creditable extra detail but the two core points are the bit movement and the zero fill.
Question 2
9618 Paper 1 style3 marks
State which bitwise operator (AND, OR or XOR) is used for each of the following, and give the mask bit value used: (a) set a bit to 1, (b) test/isolate a bit, (c) toggle a bit. (3 marks)
Model answer
(a) Set a bit: use OR with a 1 in that position (OR with 1 forces the bit to 1).

(b) Test/isolate a bit: use AND with a 1 in that position (AND with 1 keeps the bit, AND with 0 clears the rest, so the result reveals the bit).

(c) Toggle a bit: use XOR with a 1 in that position (XOR with 1 flips the bit).
Why this scores
1 mark per correct operator + mask pairing. The mask value matters: OR/XOR use a 1 in the target position, and a 1 is also used in the AND mask for testing. A common slip is naming the right operator but the wrong mask bit.
Question 3
9618 Paper 1 style4 marks
A program needs to CLEAR bit 2 (bit 0 is the rightmost) of the 8-bit value held in the accumulator to 0, leaving all other bits unchanged. (a) State the bitwise operator and the 8-bit mask required. (b) Apply your answer to the value 11101111 and give the result. (4 marks)
Model answer
(a) Use AND with the mask 11111011 — a 0 in bit 2 (to clear it) and a 1 in every other position (to keep those bits). AND with 0 forces a bit to 0; AND with 1 leaves a bit unchanged.

(b) 11101111 AND 11111011 = 11101011. Bit 2 has changed from 1 to 0; all other bits are unchanged.
Why this scores
(a) 2 marks: AND (1) and the correct mask with a single 0 in bit 2 (1). (b) 2 marks for the correct bitwise calculation. The frequent error is using OR or putting the 0 in the wrong position — clearing needs AND and a 0 only in the target bit.
Question 4
9618 Paper 1 style5 marks
A programmer uses a logical shift left to multiply an unsigned 8-bit value by 4. (a) State the instruction needed and explain why it multiplies by 4. (b) Apply it to 00010110 and give the result. (c) Explain one situation in which using a shift to multiply would give an incorrect result. (5 marks)
Model answer
(a) Use LSL #2 (logical shift left by 2 places). Each single left shift doubles the value (×2), so shifting left by 2 places multiplies by 2 × 2 = 4, with 0s fed in on the right.

(b) 00010110 (=22) shifted left by 2 places → 01011000 (=88), and 22 × 4 = 88. ✓

(c) If a 1 bit is shifted off the most significant end, it is lost, so the value can no longer be held in 8 bits. The result would then be wrong (an overflow) — for example shifting 01000000 left by 2 loses the 1 and gives 0 instead of 256.
Why this scores
(a) 2 marks: LSL #2 (1) and 'each shift left doubles, so 2 shifts ×4' (1). (b) 1 mark for 01011000. (c) 2 marks: a 1 is shifted out of the MSB and lost / the result overflows the available bits → incorrect value. The limitation in (c) is the A* discriminator most students omit.
Question 5
9618 Paper 1 style6 marks
Describe the difference between a logical shift, an arithmetic shift and a cyclic (circular) shift when applied to an 8-bit binary value. (6 marks)
Model answer
Logical shift: All bits move the stated number of places left or right. Vacated positions are always filled with 0, and any bits shifted out of the end are lost. A logical left shift multiplies an unsigned value by a power of 2; a logical right shift divides an unsigned value by a power of 2.

Arithmetic shift: Used for signed values in two's complement. On an arithmetic right shift the sign bit (MSB) is preserved/copied into the vacated left-hand positions, so a negative number stays negative — this performs signed division by a power of 2. (An arithmetic left shift behaves like a logical left shift, feeding in 0s.)

Cyclic (circular/rotate) shift: No bits are lost. Bits that fall off one end re-enter at the other end, so the byte's bits are rotated around. The number of 1s in the value is unchanged.
Why this scores
Up to 2 marks per shift type: logical = zeros fill, bits lost; arithmetic = sign bit preserved on right shift (signed division); cyclic = bits that fall off one end re-enter the other (nothing lost). The key discriminators are 'zeros vs sign bit' for right shifts and 'bits lost vs bits re-enter' for cyclic.
Question 6
9618 Paper 1 style6 marks
An 8-bit output port controls four motors (bit 0 to bit 3) and four lamps (bit 4 to bit 7), where bit 0 is the rightmost. Using the ACC instruction set, write the instructions to (a) switch motor 2 (bit 2) ON, and (b) switch lamp 0 (bit 4) OFF, in each case leaving the other seven bits unchanged. Explain why your chosen operator and mask achieve this. (6 marks)
Model answer
(a) Switch motor 2 (bit 2) ON — set the bit to 1:

LDD PORT OR B00000100 STO PORT

OR with a mask that has a 1 only in bit 2 forces that bit to 1, while OR with 0 in every other position leaves the other seven bits exactly as they were.

(b) Switch lamp 0 (bit 4) OFF — clear the bit to 0:

LDD PORT AND B11101111 STO PORT

AND with a mask that has a 0 only in bit 4 forces that bit to 0, while AND with 1 in every other position keeps the other seven bits unchanged.
Why this scores
Up to 3 marks per part: correct operator (OR to set, AND to clear), correct mask (single 1 in bit 2 for OR; single 0 in bit 4 with 1s elsewhere for AND), and load/store back to the port. The explanation must link the operator to the effect ('OR with 1 sets', 'AND with 0 clears') — restating the bit pattern without the rule limits the marks.

Key Definitions and Keywords — Bit manipulation

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

Bit mask
Examiner keyword
A binary pattern combined with a value using a bitwise operator (AND, OR or XOR) so that selected bits can be tested, set, cleared or toggled while the bit positions are chosen by where the mask has 1s and 0s.
Example
Mask 00001000 isolates bit 3 when used with AND.
Logical shift
Examiner keyword
A shift in which all bits move a stated number of places left or right; vacated positions are filled with 0 and any bits shifted out of the end are lost. It treats the value as unsigned.
Arithmetic shift
Examiner keyword
A shift used for signed (two's complement) numbers. On a right shift the sign bit (MSB) is preserved/copied into the vacated positions so a negative number stays negative — performing signed division by a power of 2.
Cyclic (circular/rotate) shift
Examiner keyword
A shift in which no bits are lost: bits that fall off one end re-enter at the other end, rotating the pattern around. The number of 1s in the value is unchanged.
LSL #n (logical shift left)
Examiner keyword
An ACC instruction that shifts the accumulator left by n places, feeding zeros in at the right-hand end. For an unsigned value it multiplies by 2^n (if no 1-bits are lost off the left).
Example
LSL #2 changes 00010011 (19) into 01001100 (76).
LSR #n (logical shift right)
Examiner keyword
An ACC instruction that shifts the accumulator right by n places, feeding zeros in at the left-hand end. For an unsigned value it divides by 2^n (any remainder is lost with the bits that fall off the right).
Example
LSR #1 changes 10110100 (180) into 01011010 (90).
Bitwise AND
Examiner keyword
An operator giving 1 only when BOTH bits are 1, otherwise 0. AND with a 1 keeps a bit; AND with a 0 clears a bit to 0. Used to test/isolate or clear bits with a mask.
Example
1 AND 1 = 1; 1 AND 0 = 0; 0 AND 0 = 0.
Bitwise OR
Examiner keyword
An operator giving 1 when EITHER (or both) bits are 1, otherwise 0. OR with a 1 sets a bit to 1; OR with a 0 leaves a bit unchanged. Used to set bits with a mask.
Example
1 OR 0 = 1; 0 OR 0 = 0; 1 OR 1 = 1.
Bitwise XOR
Examiner keyword
Exclusive OR: gives 1 when the two bits are DIFFERENT, and 0 when they are the same. XOR with a 1 toggles (flips) a bit; XOR with a 0 leaves it unchanged. Used to toggle bits with a mask.
Example
1 XOR 1 = 0; 1 XOR 0 = 1; 0 XOR 0 = 0.
Monitoring and control (using bit manipulation)
Examiner keyword
Reading sensor bits in a status register (monitoring) by AND-ing with a mask, and switching devices on or off (control) by OR-ing to set or AND-ing to clear the relevant output bits.
Most/least significant bit
The most significant bit (MSB) is the leftmost bit (highest place value); the least significant bit (LSB) is the rightmost (place value 1). Shifts feed new bits into whichever end is vacated.
Status register / flag bit
A register whose individual bits each hold a separate true/false condition (a flag), e.g. a fault or 'too hot' flag. Single flags are read and changed using bit masks rather than the whole register.

Common Mistakes and Misconceptions — Bit manipulation

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

✕Filling the vacated bit positions with the wrong value after a logical shift — leaving them blank, or copying the old bits across.
Examiner reports note that omitting the fed-in zeros is a frequent reason shift answers lose the answer mark.
Why it happens
Students focus on moving the bits and forget that the empty positions must be explicitly filled.
How to avoid it
For a LOGICAL shift always feed in 0s at the vacated end. For an ARITHMETIC right shift copy the sign bit; for a CYCLIC shift bring round the bits that fell off the other end.
✕Mixing up the operators: using AND to set a bit, or OR to test/clear a bit.
Why it happens
All three operators look similar and students memorise 'use a mask' without the per-operator rule.
How to avoid it
Memorise the trio: OR with 1 = SET, AND with 0 = CLEAR, AND with 1 = TEST/keep, XOR with 1 = TOGGLE.
✕Writing the wrong mask — e.g. using 1s everywhere except the target bit when setting, instead of a single 1 in the target bit.
Why it happens
Students confuse the 'set' mask (a single 1) with the 'clear' mask (a single 0 among 1s).
How to avoid it
For OR (set) and XOR (toggle) the mask has 1 only in the target bit(s). For AND (clear) the mask has 0 only in the target bit(s) and 1 everywhere else.
✕Counting bit positions from the wrong end, giving an off-by-one error in the mask.
Why it happens
Some questions number bits from the left, but the convention used is usually bit 0 = rightmost (LSB).
How to avoid it
Confirm which bit is bit 0 (almost always the rightmost), then line the mask's single 1 or 0 up with that position's place value (bit 3 = place value 8).
✕Using a logical right shift (feeding in 0) on a negative two's complement value and assuming it still divides correctly.
Why it happens
Students apply the unsigned 'right shift = divide by 2' rule to signed numbers.
How to avoid it
For signed division use an ARITHMETIC shift, which preserves the sign bit. A logical right shift feeds in a 0, turning a negative number positive — wrong for signed values.
✕Claiming a logical left shift always multiplies by a power of 2, even when a 1-bit is shifted off the left end.
Why it happens
Students learn the ×2 rule without the condition that no significant bit is lost.
How to avoid it
The ×2^n result only holds if no 1-bit falls off the most significant end (otherwise the value wraps/overflows). State this condition for full marks.

Bit manipulation

Detailed Study Notes

At a glance

What you’ll learn

Quick recap

Memorise this

How it’s examined

Take this whole topic with you

1Logical shift left by 2 (LSL #2)

2Logical shift right by 1 (LSR #1)

3Test a single bit with a mask (AND)

4Set a single bit with a mask (OR)

5Toggle a bit with XOR

6Monitor and control a device with bit masking

Bit mask

Logical shift

Arithmetic shift

Cyclic (circular/rotate) shift

LSL #n (logical shift left)

LSR #n (logical shift right)

Bitwise AND

Bitwise OR

Bitwise XOR

Monitoring and control (using bit manipulation)

Most/least significant bit

Status register / flag bit

✕Filling the vacated bit positions with the wrong value after a logical shift — leaving them blank, or copying the old bits across.

✕Mixing up the operators: using AND to set a bit, or OR to test/clear a bit.

✕Writing the wrong mask — e.g. using 1s everywhere except the target bit when setting, instead of a single 1 in the target bit.

✕Counting bit positions from the wrong end, giving an off-by-one error in the mask.

✕Using a logical right shift (feeding in 0) on a negative two's complement value and assuming it still divides correctly.

✕Claiming a logical left shift always multiplies by a power of 2, even when a 1-bit is shifted off the left end.