← IGCSE Computer Science Paper 1

What parity bytes and blocks cannot detect

Four flipped bits at the corners of a rectangle keep every row and column parity correct, so a parity block check misses the error. Only one error can be located reliably.

Part of: IGCSE Computer Science 0478 — 2.2 Methods of Error Detection — Module 21

Understanding What parity bytes and blocks cannot detect in IGCSE Computer Science Paper 1

What it does: Both rows hold five 1s before and after the changes, so the parity bit still matches and the error is not flagged. Four crossing points are possible, so the error cannot be located reliably. Only one error can be pinpointed. Each affected row and column has two flips, which cancel out, so every parity still looks correct. Two flips change the count of 1s by 0 or plus or minus 2, so the row parity does not change. With one error, exactly one row and one column fail, and they cross at the wrong bit. The row parity cancels out. Only the columns show a problem, which is not enough to pinpoint both bits.

Common mistakes: When the four flipped bits sit at the corners of a rectangle, every row and column parity stays correct. The check misses the error, so missed should be set to TRUE. The line should show two bits changed in the row (1 0 1 1 becomes 0 0 1 0), so the row still has an even number of 1s and the row check passes. The broken line flips only one bit, which would make the row parity fail.

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 parity bytes and blocks 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

Four bits at the corners of a rectangle in a parity block are flipped. What does the parity block check show?

Four rows and columns show a parity errorEvery row and column parity is still correct, so the error is missed

Matches

4 flips in a rectangle -> parity block always catches it

↓

Four flipped bits at the corners of a rectangle keep every row and column parity correct, so the block check misses them.

Applying

Meanings

Term

four-corner error

Meaning

Four flipped bits at the corners of a rectangle keep every row and column parity correct, so a parity block check misses the error. Only one error can be located reliably.

Practice

SENT

Testing

Gaps

IF rowFails = 0 colFails = 0 THEN

Check Answer

Spots

2corners ← TRUE

3IF corners THEN missed ← FALSE

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

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. Four bits at the corners of a rectangle in a parity block are flipped. What does the parity block check show?

A. Four rows and columns show a parity error

B. Every row and column parity is still correct, so the error is missed ✓

Each affected row and column has two flips, which cancel out, so every parity still looks correct.

2. Why does flipping two bits in the same row leave that row's parity unchanged?

A. The number of 1s changes by two, so it stays odd or even as before ✓

B. The parity bit is automatically recalculated by the receiver

Two flips change the count of 1s by 0 or plus or minus 2, so the row parity does not change.

3. Which error can a parity block locate reliably?

A. A single changed bit ✓

B. Four changed bits at the corners of a rectangle

With one error, exactly one row and one column fail, and they cross at the wrong bit.

4. Two bits in the same row are changed. What happens in a parity block check?

A. The row check fails and points to exactly which two bits are wrong

B. The row check passes, but two column checks fail, so the error cannot be located reliably ✓

The row parity cancels out. Only the columns show a problem, which is not enough to pinpoint both bits.

5. A parity block check guarantees that every transmission error will be found.

A. False ✓

B. True

A four-corner error passes every row and column check, so some errors go undetected.

Match the Pairs

Flip (r1,c2) (r1,c6) (r4,c2) (r4,c6) → Four changed bits at the corners of a rectangle. Every row and column parity still looks correct, so the parity block check misses the error.

Row 3 wrong, column 5 wrong → Points to one changed bit where row 3 and column 5 cross, so a single error can be located and corrected.

Two bit changes in the same row cancel out in that row's parity, so the row check passes → Row 2: 10110101 -> 11110001

With errors in two rows and two columns, the block cannot tell which bits changed → Wrong rows: 2 and 4. Wrong columns: 3 and 6

4 flips in a rectangle -> parity block always catches it → Four flipped bits at the corners of a rectangle keep every row and column parity correct, so the block check misses them.

Row 2 wrong + column 5 wrong = two errors found → One wrong row and one wrong column mean a single error at their crossing point, not two errors.

Key Term

four-corner error

Four flipped bits at the corners of a rectangle keep every row and column parity correct, so a parity block check misses the error. Only one error can be located reliably.

Fill in the Blanks

1. IF rowFails = 0 AND colFails = 0 THEN OUTPUT "No error found" ENDIF

Hint: Type the logic keyword that needs both the row check and the column check to pass.

2. corners ← 4 OUTPUT "Parity looks correct"

Hint: Type how many bits change at the corners of a rectangle for the error to be missed.

3. errorsInRow ← 2 IF errorsInRow MOD 2 = 0 THEN rowCheck ← "passes"

Hint: Type the number used to test whether an even number of bits flipped in a row.

4. IF rowFails = 1 AND colFails = 1 THEN OUTPUT "Error located at intersection" ENDIF

Hint: Type how many rows must fail for a single error to be located reliably.

5. rowsChanged ← 2 colsChanged ← 2 bitsFlipped ← rowsChanged * colsChanged

Hint: Type the variable that holds the number of columns affected, to work out the four corner bits.

Spot the Error

Question 1

A OUTPUT "Four bits flipped"

B corners ← TRUE

C IF corners THEN missed ← FALSE

Line C — When the four flipped bits sit at the corners of a rectangle, every row and column parity stays correct. The check misses the error, so missed should be set to TRUE.

Question 2

A sent: 1 0 1 1 | 1

B received: 0 0 1 1 | 1

C // row parity still even

D // two bits changed in one row

Line B — The line should show two bits changed in the row (1 0 1 1 becomes 0 0 1 0), so the row still has an even number of 1s and the row check passes. The broken line flips only one bit, which would make the row parity fail.

Question 3

A rBad ← 1

B cBad ← 1

C IF rBad = 1 AND cBad = 1 THEN

D OUTPUT "cannot locate it"

Line D — With exactly one bad row and one bad column, a single error can be located where they cross. The output should say the error is located, not that it cannot be located.

Question 4

A 0 0 0 0

B 0 1 0 0

C 0 1 1 0

D 0 0 0 0

E // all parities still even

Line B — Every row and column must still have even parity after the four corner bits flip. The row 0 1 0 0 has an odd number of 1s, so it should be 0 1 1 0.

Question 5

A bitsChanged ← 1

B IF bitsChanged >= 1 THEN

C OUTPUT "located"

D ELSE OUTPUT "cannot locate"

Line B — Only a single error can be located reliably. The test must be = 1, because with two or more changed bits the bad row and column cannot be pinned down.

Student with a class code? Join your class →