ALGORITHM DESIGN AND PROBLEM-SOLVING: END OF TOPIC REVIEW

Sample answer: A request using an already-booked student ID must be rejected without adding another booking. A request made when capacity is reached must also be rejected without increasing the booking count. Decomposition separates receiving a request, checking duplication and capacity, and recording an accepted booking. Therefore each smaller task can be designed and tested while keeping its connection to the overall booking process clear.

• Precise duplicate-rejection requirement: one mark.
• Precise capacity-rejection requirement: one mark.
• Relevant breakdown into component jobs: one mark.
• Explain how smaller jobs support manageable design/testing: one mark.

Writing focus: describe observable behaviour, then connect the decomposition to its benefit.

Sample answer: Validation checks whether the entered mark satisfies the specified rules, whereas verification checks whether it was copied accurately from the paper register. Forty-three passes the whole-number range rule but differs from thirty-four, so visual verification should reveal the copying error. Both are useful because a value can be within permitted limits yet inaccurately copied; conversely, accurately copying an invalid source value does not make it valid.

• Rule-based validation contrasted with accurate-copying verification: one mark.
• Apply validation correctly to 43: one mark.
• Apply verification correctly against source 34: one mark.
• Explain complementary roles with a valid link or example: one mark.

Writing focus: address both checks on the same basis, using whereas and because where helpful.

Sample answer: Compare five and two: swap, giving [2, 5, 4, 1]. Compare five and four: swap, giving [2, 4, 5, 1]. Compare five and one: swap, giving [2, 4, 1, 5]. The largest value has reached the end, but four still precedes one, so an out-of-order pair remains and further passes are needed.

• First comparison and resulting list: one mark.
• Second comparison and resulting list: one mark.
• Third comparison and resulting list: one mark.
• Explain remaining disorder and need for further passes: one mark.

Writing focus: provide structured intermediate evidence rather than only the final list.

Sample answer: After input two: Total two, Count one. After minus one: Total two, Count one because the condition is false. After four: Total six, Count two. Count is positive, so the output is six divided by two, or three.

• State after first iteration: one mark.
• Unchanged state after negative input: one mark.
• Final Total six and Count two: one mark.
• Correct final branch and output three: one mark.

Writing focus: distinguish state from output and show the effect of the selection.

Sample answer: The UNTIL condition currently stops for an invalid value rather than a valid one. For example, thirty-one ends the retry and is then labelled accepted. Also, OR combines the outside-range conditions, rather than requiring both valid bounds. Replace the whole condition with Value >= 0 AND Value <= 30: REPEAT now stops only when both inclusive bounds hold. Test minus one then zero, and thirty-one then thirty, to confirm retry and endpoint acceptance.

• Identify wrong stopping sense with its effect: one mark.
• Replace lower comparison with Value >= 0: one mark.
• Replace upper comparison with Value <= 30: one mark.
• Combine valid bounds with AND and explain that both must hold: one mark.

Writing focus: the original condition describes being outside the range, but UNTIL needs the acceptance condition here. The correction is one coherent replacement; a different correctly reasoned valid condition can also work.

Sample answer: Fifteen is a representative normal input and should be accepted. Boundary values are twelve: reject; thirteen: accept; seventeen: accept; eighteen: reject. Testing only fifteen cannot distinguish the correct exclusive rule from a faulty inclusive twelve-to-eighteen rule, because both accept fifteen. Endpoint-focused tests reveal that difference.

• Valid representative normal test with acceptance: one mark.
• Lower boundary pair twelve/reject and thirteen/accept: one mark.
• Upper boundary pair seventeen/accept and eighteen/reject: one mark.
• Explain why a middle value misses endpoint faults: one mark.

Writing focus: relate each chosen input to a rule or possible fault.

Sample answer: Initialise ParticipatingClasses to zero before the class loop so earlier counts are retained. After each accepted input, increment it by one only when Attendance is greater than zero; this excludes invalid attempts and zero-attendance classes. After all classes, divide only if that count is positive, because otherwise the denominator is zero. Retest the original inclusive input range, for example confirming that zero and thirty remain accepted after the amendment.

• Initialisation before repetition with reason: one mark.
• Positive accepted-input count update inside repetition: one mark.
• Guard before division with zero-denominator reason: one mark.
• Relevant retained rule and specific regression check: one mark.

Writing focus: link the location of an instruction to the effect it prevents.

One possible solution:

DECLARE Attendance : INTEGER
DECLARE ClassIndex : INTEGER
DECLARE Total : INTEGER
DECLARE ParticipatingClasses : INTEGER
DECLARE Average : REAL
Total ← 0
ParticipatingClasses ← 0
FOR ClassIndex ← 1 TO 4
    REPEAT
        OUTPUT "Enter attendance from 0 to 30"
        INPUT Attendance
    UNTIL Attendance >= 0 AND Attendance <= 30
    Total ← Total + Attendance
    IF Attendance > 0
      THEN
        ParticipatingClasses ← ParticipatingClasses + 1
    ENDIF
NEXT ClassIndex
OUTPUT "Total: ", Total
OUTPUT "Participating classes: ", ParticipatingClasses
IF ParticipatingClasses > 0
  THEN
    Average ← Total / ParticipatingClasses
    OUTPUT "Mean: ", Average
  ELSE
    OUTPUT "No participating classes"
ENDIF

Thirty-one is retried for the first class. Accepted values are twelve, zero, eighteen and zero. Summary outputs are Total thirty, participating count two and mean fifteen.

• Appropriate variables/types and both initialisations: one mark.
• Exactly four accepted class values using appropriate repetition: one mark.
• Inclusive range retry nested within class processing: one mark.
• Total and conditional class count updated after acceptance: one mark.
• Final output and guarded mean/alternative: one mark.
• Correct summary outputs for the supplied attempts: one mark.

Other complete, correct algorithms are valid. These grouped practice marks are deliberately broad; they are not an official Cambridge mark scheme.

Writing focus: precise complete instructions demonstrate the solution; a prose description alone does not replace the requested pseudocode.