How to answer pseudocode questions

What it looks like in the real exam

From NESA material 2025 HSC 2025 HSC exam, Q17 (3 marks): an algorithm that sums an array and gives a risk rating. 2025 sample 2025 NESA sample exam, Q14 (3 marks, subroutines and RETURN). 2025 familiarisation 2025 NESA familiarisation exam, Q8 (3 marks, fix a linear search) and 2025 NESA familiarisation exam, Q13. The online exam gives you a pseudocode editor (the familiarisation exam has it on Q8 so you can practise).

From NESA material Typical tasks: write an algorithm from a description, complete or fix given pseudocode, or read it and say what it does (see also trace tables).

The conventions (what markers expect)

From NESA material “Keywords are in capitals; structural elements come in pairs; indent to show control structures” (course specifications). Reasoned Array notation is not fixed: 2025 Q17 uses Risks[index] starting at 0, and the familiarisation Q8 uses ItemArray(Index) starting at 1. Use the notation and start index the question uses.

Method (the course’s 5 steps, with detail)

1. Read the question. Underline what it asks you to produce (display, return, store) and any limits. Course step 1
2. Analyse the stimulus and list every requirement. Number them in the margin: each one is probably a mark. Note the input, the process, the output. Course step 2 From NESA material NESA feedback: use the stimulus to identify the structures needed.
3. Plan the mainline. Decide the structures: a loop over an array? a selection with three outcomes? Decide whether any piece is a subroutine. Write the mainline first with calls only if you use subroutines. Course step 3
4. Write the subroutines/body. Initialise variables before the loop (Total = 0). Put every structure’s closing word in as soon as you type the opening word. Course step 4
5. Re-read and test with one example. Do a quick trace with a simple input and one boundary value (see the trace table method). Course step 5

Worked example 1: array sum and selection (2025 HSC Q17)

BEGIN RiskRating
  Total = 0
  index = 0
  REPEAT
    Total = Total + Risks[index]
    index = index + 1
  UNTIL index = 10
  IF Total > 35 THEN
    Rating = "High"
  ELSE
    IF Total < 20 THEN
      Rating = "Low"
    ELSE
      Rating = "Medium"
    ENDIF
  ENDIF
  Display Rating
END RiskRating
(NESA also accepts a CASEWHERE version: CASEWHERE Total is  > 35: Rating = "High"  < 20: Rating = "Low"  OTHERWISE: Rating = "Medium"  END CASE; and an IF / ELSEIF / ELSE version.)

1. Requirements (from the criteria): iterate the array, total it, compare with the thresholds, display a rating.
2. Initialise: Total = 0 and index = 0 before the loop.
3. Loop: REPEAT adds each element and moves index on; UNTIL index = 10 stops after 10 items (indexes 0 to 9).
4. Selection: a nested IF (High above 35; Low below 20; otherwise Medium).
5. Output: Display Rating after the structures close.

From NESA material 2025 marker feedback: use pseudocode control structures accurately; iterate an array and sum it; apply relational operators correctly.

Original practice Quick check: totals of 20 and 35 give “Medium”, because neither is below 20 nor above 35. This is why you test boundary values (I ran this to confirm).

Worked example 2: subroutines and RETURN (2025 sample Q14)

BEGIN main
     Get num_pizzas
     total_cost = 0
     FOR i = 1 TO num_pizzas
           Get pizza_size
           Get num_toppings
           cost_per_pizza = calculate_pizza_cost(pizza_size, num_toppings)
           DISPLAY cost_per_pizza
           total_cost = total_cost + cost_per_pizza
     NEXT i
     DISPLAY total_cost
END main

BEGIN calculate_pizza_cost(size, num_toppings)
     base_price = 10
     topping_price = 1.5
     IF size = "Medium" THEN
           base_price = base_price + 2
     ELSEIF size = "Large" THEN
           base_price = base_price + 4
     ENDIF
     pizza_cost = base_price + num_toppings * topping_price
     RETURN pizza_cost
END calculate_pizza_cost

From course notes A clean mainline that calls named subroutines is something the specifications ask for (see Mainline and subroutines (algorithms)).

Original practice A tiny original example of the structure (verified by tracing):

BEGIN Main
    FOR i = 1 TO 3
        Display Square (i)
    NEXT i
END Main

BEGIN Square (x)
    result = x * x
    RETURN result
END Square (x)

Output: 1, 4, 9. The mainline only calls; Square returns a value.

Worked example 3: fixing a linear search (2025 familiarisation Q8)

BEGIN Search (SearchItem)
    Set LastIndex to the number of elements in ItemArray
    Found = FALSE
    Index = 1
    WHILE Found = FALSE AND Index < LastIndex + 1
         IF ItemArray(Index) = SearchItem THEN
               Found = TRUE
         ENDIF
         Index = Index + 1
    ENDWHILE
    IF Found = TRUE THEN
         Display 'Position', Index - 1
    ELSE
         Display 'Not found'
    ENDIF
END Search

From NESA material The sample note tells you why Index - 1 is displayed: Index is incremented after the item is found, so the position is one behind.

Original practice A complete search that follows this pattern (original reconstruction; the original buggy algorithm is not published):

BEGIN Search (SearchItem)
    Set LastIndex to the number of elements in ItemArray
    Found = FALSE
    Index = 1
    WHILE Found = FALSE AND Index < LastIndex + 1
        IF ItemArray(Index) = SearchItem THEN
            Found = TRUE
        ENDIF
        Index = Index + 1
    ENDWHILE
    IF Found = TRUE THEN
        Display 'Position', Index - 1
    ELSE
        Display 'Not found'
    ENDIF
END Search

Linear search pattern: Found flag, check each item until found or end. See Linear search pattern.

More patterns you should be able to write

Original practice All of these were traced by hand and run in Python to check the outputs.

Validation loop (REPEAT…UNTIL)

BEGIN GetMark
    REPEAT
        Display "Enter a mark from 0 to 100"
        Get Mark
        IF Mark < 0 OR Mark > 100 THEN
            Display "Invalid mark, try again"
        ENDIF
    UNTIL Mark >= 0 AND Mark <= 100
    Display "Mark accepted: ", Mark
END GetMark

Largest in an array (1 to 10)

BEGIN LargestScore
    Largest = Scores[1]
    FOR i = 2 TO 10
        IF Scores[i] > Largest THEN
            Largest = Scores[i]
        ENDIF
    NEXT i
    Display Largest
END LargestScore

Sum of the even numbers 1 to 20 (answer 110)

BEGIN EvenSum
    Total = 0
    FOR n = 1 TO 20
        IF n MOD 2 = 0 THEN
            Total = Total + n
        ENDIF
    NEXT n
    Display Total
END EvenSum

Choosing between three grades (IF/ELSEIF)

BEGIN Grade
    Get Mark
    IF Mark >= 80 THEN
        Grade = "H"
    ELSEIF Mark >= 50 THEN
        Grade = "P"
    ELSE
        Grade = "N"
    ENDIF
    Display Grade
END Grade

Common mistakes

• From NESA material NESA 2025 Q17 feedback: use control structures accurately; apply relational operators correctly (> vs >=). Better responses used the stimulus to pick the structures.
• General advice Forgetting to initialise Total = 0 or to add index = index + 1 inside a WHILE/REPEAT (infinite loop).
• General advice Off-by-one: FOR i = 1 TO 10 over a 0-based array, or the other way. Check the first and last index.
• General advice Missing the closing word (ENDIF, ENDWHILE, NEXT, END name).
• General advice Writing Python (print(), :, ==) in a pseudocode question. Use Display, THEN, =.
• General advice Using AND where OR is needed in a validation (Mark < 0 AND Mark > 100 can never be true).

Time per mark

Derived 1.75 minutes per mark on average gives about 5 minutes for a 3-mark pseudocode question. General advice Plan: 1 minute read and underline, 3 minutes write, 1 minute check.

Practice (4 items, with answers)

BEGIN Average
    Total = 0
    FOR i = 1 TO 5
        Total = Total + Marks[i]
    NEXT i
    Average = Total / 5
    IF Average >= 50 THEN
        Display "Pass"
    ELSE
        Display "Fail"
    ENDIF
END Average

BEGIN CountPasses
    Count = 0
    FOR i = 1 TO 10
        IF Marks[i] >= 50 THEN
            Count = Count + 1
        ENDIF
    NEXT i
    Display Count
END CountPasses

BEGIN Mystery
    x = 3
    y = 0
    WHILE x > 0
        y = y + x * 2
        x = x - 1
    ENDWHILE
    Display y
END Mystery

BEGIN Main
    Display IsEven (7)
END Main

BEGIN IsEven (n)
    IF n MOD 2 = 0 THEN
        result = TRUE
    ELSE
        result = FALSE
    ENDIF
    RETURN result
END IsEven

More: all past questions (filter to pseudocode), flashcards.

Terms, flashcards and past questions

Key terms for this page: Pseudocode questions · Pseudocode keywords · Pseudocode · Mainline and subroutines (algorithms) · Subroutine and function (pseudocode) · WHILE loop (pre-test) · REPEAT UNTIL loop (post-test) · FOR / NEXT loop (counted) · Multi-way selection (CASEWHERE) · Array · Array sum pattern · Linear search pattern · Desk checking

Flashcards · All key terms · Learn step by step · All past questions · Multiple-choice bank · Mock exam

Past questions used on this page:

• 2025 HSC exam, Q17
• 2025 NESA sample exam, Q14
• 2025 NESA familiarisation exam, Q8
• 2025 NESA familiarisation exam, Q13
• Open this question page
• Open this question page
• Open this question page