Constructs

Every algorithm is built from just three constructs:

Construct	What it does	Pseudocode
Sequence	run statements one after another, top to bottom	(no special keyword)
Selection	choose between different paths	IF…ELSE, CASE
Iteration	repeat statements	FOR, WHILE, REPEAT

Sequence is automatic — statements simply run in the order written. This topic is about the other two: selection (making decisions) and iteration (looping). Both are controlled by a condition — a Boolean expression that is either TRUE or FALSE, built with the comparison operators:

Operator	Meaning
=	equal to
<>	not equal to
<	less than
>	greater than
<=	less than or equal to
>=	greater than or equal to

In Cambridge pseudocode, assignment uses the arrow ← (e.g. Total ← 0), which is different from the equality test =.

An IF statement chooses between two paths:

IF condition THEN
   <statements run when TRUE>
ELSE
   <statements run when FALSE>
ENDIF

Only one branch ever runs, and the structure is always closed with ENDIF. The ELSE branch is optional — if you only need to do something when the condition is TRUE, leave it out.

Nested IF means putting an IF inside the THEN or ELSE branch of another. This is how you test several mutually exclusive conditions in order, such as grade boundaries:

IF Mark >= 70 THEN
   OUTPUT "A"
ELSE
   IF Mark >= 50 THEN
      OUTPUT "B"
   ELSE
      OUTPUT "C"
   ENDIF
ENDIF

The trick is to test from the top boundary downwards. Because the second test (Mark >= 50) is only reached when Mark < 70 was already FALSE, it automatically means "50 to 69" — you never need to write the lower bound. Every IF needs its own matching ENDIF, so indent each level to keep them clear.

When you are comparing one variable against several specific values, a CASE structure is clearer than a long chain of nested IFs:

CASE OF Choice
   1 : OUTPUT "Add"
   2 : OUTPUT "Edit"
   3 : OUTPUT "Delete"
   OTHERWISE : OUTPUT "Invalid"
ENDCASE

Key rules:

• It is CASE OF Variable (the OF is required), closed with ENDCASE.
• Each value is followed by a colon and the statement(s) to run.
• You can list several values for one outcome, separated by commas: 1, 2, 3, 4, 5 : OUTPUT "Weekday".
• OTHERWISE catches every value not listed (like the final ELSE of an IF chain).

Important limit: CASE only tests equality against single values. It cannot test a range like Mark > 50. For ranges you must use nested IF statements instead.

There are three iteration constructs. The crucial difference is when (and whether) the condition is tested.

Count-controlled — FOR…NEXT (known number of repeats):

FOR Count ← 1 TO 10
   OUTPUT Count
NEXT Count

The counter (Count) is updated automatically by NEXT — never increment it yourself. An optional STEP changes the step size: FOR Count ← 10 TO 1 STEP -1.

Pre-condition — WHILE…ENDWHILE (test BEFORE the body → 0 or more runs):

WHILE Total < 100 DO
   INPUT Value
   Total ← Total + Value
ENDWHILE

Post-condition — REPEAT…UNTIL (test AFTER the body → at least 1 run):

REPEAT
   INPUT Value
UNTIL Value > 0

This diagram shows the single most-examined distinction — WHILE may skip the body entirely, REPEAT always runs it once:

Notice the conditions point opposite ways: WHILE keeps looping while its condition is TRUE (a continue condition); REPEAT stops when its UNTIL condition becomes TRUE (an exit condition).

Examiners love asking you to pick a loop and justify it. Use this decision routine:

1. Is the number of repeats known in advance? → use a count-controlled FOR loop.
2. If not, must the body run at least once? → use a post-condition REPEAT…UNTIL (e.g. validating input you must ask for first).
3. If the body might need to run zero times (e.g. an empty list, or the very first value is the rogue/sentinel value) → use a pre-condition WHILE loop.

Worked reasoning — summing values that end with the rogue value -1:

• A FOR loop is out: we don't know how many values there are.
• A REPEAT loop is risky: it always runs once, so if the user enters -1 immediately it would wrongly process -1.
• A WHILE loop is best: tested before the body, it can run zero times, handling an empty list correctly.

Total ← 0
INPUT Value          // priming read
WHILE Value <> -1 DO
   Total ← Total + Value
   INPUT Value        // re-read each pass
ENDWHILE
OUTPUT Total

The two INPUTs are deliberate: the priming read gives the WHILE condition a value to test on the first check, and the re-read at the end of the body fetches each new value. Miss either and you get a wrong total or an infinite loop.

How to phrase a justification for marks: name the chosen loop, then give a concrete reason tied to the construct's behaviour — e.g. "a pre-condition WHILE loop is best because the count is unknown and the body must be able to run zero times (the list could be empty)." A bare "WHILE is best" with no reason scores almost nothing.

Paper 2 awards marks for correct Cambridge pseudocode, so style matters. Use this checklist:

Construct	Opens with	Closes with
Selection	IF … THEN … (ELSE)	ENDIF
Selection	CASE OF Var	ENDCASE
Count loop	FOR Var ← a TO b [STEP s]	NEXT Var
Pre-condition	WHILE cond DO	ENDWHILE
Post-condition	REPEAT	UNTIL cond

Other conventions examiners expect:

• Assignment uses the arrow ← (e.g. Count ← Count + 1), not =.
• Comparison uses = <> < > <= >= (note <> for "not equal").
• Keywords in capitals (IF, THEN, ELSE, WHILE, REPEAT…) and identifiers in MixedCase.
• Indent the body of every construct one level so the structure is visible.
• After CASE values use a colon; after FOR use NEXT Var (repeat the variable name).

Most lost marks here are mechanical: a missing ENDIF/ENDWHILE, the wrong loop condition sense, or hand-incrementing a FOR counter. Slow down on the closing keywords.