← IGCSE Computer Science Paper 1

What a single parity check cannot detect

A single parity check misses an error when an even number of bits change, because the count of 1s keeps the same parity. It also cannot show which bit is wrong.

Part of: IGCSE Computer Science 0478 — 2.2 Methods of Error Detection — Module 16, ACARA Digital Technologies Years 7–8 — Wired and Wireless Networks — Module 66

Understanding What a single parity check cannot detect in IGCSE Computer Science Paper 1

What it does: The check cannot locate the faulty bit, so the only option is to resend the whole byte rather than fix one bit. A lost byte has no bad parity to check, so a separate count of bytes is needed to notice that data is missing. Two flips change the number of 1s by 0 or 2, so the parity stays the same and the error goes unnoticed. Swapped bits give the same count of 1s, so the parity bit still looks correct. The parity bit is just one extra bit about the whole byte, so it carries no information about position.

Common mistakes: The sent byte should be 10110010. It differs from the received byte in exactly two bits, which matches flipped <- 2. The broken byte differs in three bits, so it does not fit the rest of the program. The sent byte should be 11010000, which has three 1s. Swapping two bits gives 10110000, which also has three 1s. The broken byte has four 1s, so the counts would not match.

Class: _____________________  ·  Name: _____________________  ·  Date: _________

Free printable worksheet with full answer key — or add this module to a class and your students practise it interactively.

🖨 Print worksheet + answer key Add What a single parity check cannot detect to a class →

This module's key terms are also in a printable crossword (Modules 155–164) and word search (Modules 142–164).

Take this worksheet further — free with Cloodit

Each concept is reinforced from every angle — learned, then applied, then tested.

Learning
Duo
A byte is sent with even parity and two of its bits flip in transit. What does the parity check report?
An error, because two bits changedNo error, because the count of 1s still has the right parity
Matches
Two bits flip, parity changes, error is always found
↓
Two flipped bits cancel out, so the number of 1s keeps the same parity and the error is not found
Applying
Meanings
Term
even number of bits change
Meaning
A single parity check misses an error when an even number of bits change, because the count of 1s keeps the same parity. It also cannot show which bit is wrong.
Practice
sent ← "10110010"
Testing
Gaps
IF bitsChanged 2 = 0 THEN
Check Answer
Spots
1sent <- 10110110
2received <- 10101010

Cloodit turns curriculum-aligned coding content into journeys students work through one biome at a time.

The 'Viperfish' badge — Deep Debugger, one of Cloodit's 106 collectible badges
Students earn collectable badges

Over 100 of them, across seven natural biomes.

Study Buddy
Students build a real study resource

Turns their work into revision material ready for Flash Cards and Exam study.

Diamond Dash — one of Cloodit's live, competitive Sprint games
Students lock in with Sprints

Live, competitive practice for the start of the lesson or a teacher-led lesson finisher.

A Cloodit certificate of achievement, ready to personalise and print
Custom printable certificates

Honour your top performers, or encourage a student who's trying hard — ready to print in seconds.

Add to class →

Quick Questions

1. A byte is sent with even parity and two of its bits flip in transit. What does the parity check report?
A. An error, because two bits changed
B. No error, because the count of 1s still has the right parity ✓
Two flips change the number of 1s by 0 or 2, so the parity stays the same and the error goes unnoticed.
2. Which error will a single parity check miss?
A. Four bits in the byte flip ✓
B. One bit in the byte flips
Any even number of flipped bits keeps the parity the same. A single flipped bit always changes it, so that is detected.
3. A 0 flips to a 1 and a 1 flips to a 0 in the same byte. Is the parity check likely to notice?
A. No, the number of 1s stays the same ✓
B. Yes, because the bits are different now
Swapped bits give the same count of 1s, so the parity bit still looks correct.
4. A parity check reports an error in a received byte. What can the receiver tell from the parity bit alone?
A. That at least one bit is wrong, but not which one ✓
B. Exactly which bit is wrong, so it can fix it
A single parity check only shows that the parity is wrong. It cannot locate the error, so the data must be sent again.
5. Which statement about a single parity check is true?
A. It points to the position of the flipped bit
B. It cannot locate the bit that has changed ✓
The parity bit is just one extra bit about the whole byte, so it carries no information about position.

Match the Pairs

Sent 10110001 (even parity), received 10010101 → Two bits flipped, so the number of 1s is still even and the parity check passes even though the data is wrong
Sent 11001100, received 11001010 → Two bits swapped places, so the count of 1s is the same and the parity check cannot see the error
A parity error only tells you that a byte is wrong, not which bit, so the whole byte must be sent again → if parity_error: request_resend(byte)
A single parity check cannot spot a missing byte unless the number of bytes is also counted → if bytes_received != bytes_expected: error
Two bits flip, parity changes, error is always found → Two flipped bits cancel out, so the number of 1s keeps the same parity and the error is not found
Parity error found, so flip bit 3 to fix it → Parity cannot show which bit is wrong, so you cannot know bit 3 is the faulty one

Key Term

even number of bits change
A single parity check misses an error when an even number of bits change, because the count of 1s keeps the same parity. It also cannot show which bit is wrong.

Fill in the Blanks

1. IF bitsChanged MOD 2 = 0 THEN OUTPUT "Parity check misses it" ENDIF
Hint: Type the operator that gives the remainder after division, used to test for an even number of changed bits.
2. sent ← "10110010" received ← "10110001" same ← ones(sent) = ones(received)
Hint: Type the comparison operator that tests whether the two counts of 1s are equal.
3. IF parity <> expected THEN OUTPUT "Error but position unknown" ENDIF
Hint: Type the keyword that displays a message, because parity only says an error exists, not where.
4. IF bytesReceived <> bytesSent THEN OUTPUT "A byte was lost or gained" ENDIF
Hint: Type the not-equal operator used to compare the byte counts, since parity alone cannot spot a missing byte.
5. IF onesCount MOD 2 = 0 THEN OUTPUT "Even parity, no error found" ENDIF
Hint: Type the remainder value that shows the count of 1s is still even after two bits flipped.

Spot the Error

Question 1
A sent <- 10110110
B received <- 10101010
C flipped <- 2
D OUTPUT 'Parity check passes'
Line A — The sent byte should be 10110010. It differs from the received byte in exactly two bits, which matches flipped <- 2. The broken byte differs in three bits, so it does not fit the rest of the program.
Question 2
A sent <- 11010001
B received <- 10110000
C ones_before <- 3
D ones_after <- 3
E OUTPUT 'Swap not detected'
Line A — The sent byte should be 11010000, which has three 1s. Swapping two bits gives 10110000, which also has three 1s. The broken byte has four 1s, so the counts would not match.
Question 3
A received <- 10110011
B ones <- 5
C IF ones MOD 2 = 1 THEN
D OUTPUT 'Error in bit 3'
Line D — A parity check only shows that an error exists. It cannot show which bit is wrong, so the output should say the bit is unknown.
Question 4
A sent <- 5
B got <- 5
C IF sent <> got THEN
D OUTPUT 'Byte lost'
Line B — Parity cannot spot a lost byte, so the program compares a count of bytes. For the 'Byte lost' message to make sense, got must be 4. With got <- 5 the counts match and nothing is lost.
Question 5
A sent <- 10000001
B received <- 00000000
C ones <- 0
D IF ones MOD 2 = 1 THEN
E OUTPUT 'Passes, but wrong'
Line D — With even parity, a byte passes when its count of 1s is even. Zero is even, so the test must be MOD 2 = 0. Two bits changed, so the error is missed.

Student with a class code? Join your class →