Writing pseudocode to a specification

Totalling and counting

Totalling means adding values into a running total: `Total ← Total + Value`.

Counting means adding 1 each time something happens: `Count ← Count + 1`.

Both variables must start at 0 before the loop.

DECLARE Marks : ARRAY[1:6] OF INTEGER
DECLARE Index : INTEGER
DECLARE Total : INTEGER
DECLARE PassCount : INTEGER
// Marks already holds 34, 48, 21, 40, 15, 45
Total ← 0
PassCount ← 0
FOR Index ← 1 TO 6
  Total ← Total + Marks[Index]
  IF Marks[Index] >= 25
    THEN
      PassCount ← PassCount + 1
  ENDIF
NEXT Index
OUTPUT "Total: ", Total
OUTPUT "Number of passes: ", PassCount

marks = [34, 48, 21, 40, 15, 45]
total = 0
pass_count = 0
for index in range(6):
    total = total + marks[index]
    if marks[index] >= 25:
        pass_count = pass_count + 1
print("Total:", total)
print("Number of passes:", pass_count)

Finding the maximum and minimum

To find the maximum (largest), keep a variable `Highest`. Compare each value with it. If the value is bigger, it becomes the new `Highest`.

The minimum (smallest) works the same way with `Lowest` and `<`.

Start `Highest` at the smallest possible value and `Lowest` at the largest possible value. Another safe way is to start both at the first item.

DECLARE Marks : ARRAY[1:6] OF INTEGER
DECLARE Index : INTEGER
DECLARE Highest : INTEGER
DECLARE Lowest : INTEGER
// Marks already holds 34, 48, 21, 40, 15, 45 (each out of 50)
Highest ← 0
Lowest ← 50
FOR Index ← 1 TO 6
  IF Marks[Index] > Highest
    THEN
      Highest ← Marks[Index]
  ENDIF
  IF Marks[Index] < Lowest
    THEN
      Lowest ← Marks[Index]
  ENDIF
NEXT Index
OUTPUT "Highest: ", Highest
OUTPUT "Lowest: ", Lowest

marks = [34, 48, 21, 40, 15, 45]
highest = 0
lowest = 50
for index in range(6):
    if marks[index] > highest:
        highest = marks[index]
    if marks[index] < lowest:
        lowest = marks[index]
print("Highest:", highest)
print("Lowest:", lowest)

Finding the average

The average (mean) is the total divided by how many values there are.

First total the values in a loop. Then divide once, after the loop.

The answer is usually not a whole number, so store it as `REAL`. Use `ROUND` to give a set number of decimal places.

DECLARE Marks : ARRAY[1:6] OF INTEGER
DECLARE Index : INTEGER
DECLARE Total : INTEGER
DECLARE Average : REAL
// Marks already holds 34, 48, 21, 40, 15, 45
Total ← 0
FOR Index ← 1 TO 6
  Total ← Total + Marks[Index]
NEXT Index
Average ← Total / 6
OUTPUT "Average: ", ROUND(Average, 2)

marks = [34, 48, 21, 40, 15, 45]
total = 0
for index in range(6):
    total = total + marks[index]
average = total / 6
print("Average:", round(average, 2))

Linear search

A linear search looks for a value by checking each item in a list, one at a time, from the start.

It stops when it finds the item, or when it reaches the end of the list.

Try it: the toy's list holds numbers, not names. Type 22 (the last item), press Search for it, then Run all. Then try 99, which is not there. Count the comparisons each time.

DECLARE Names : ARRAY[1:6] OF STRING
DECLARE Target : STRING
DECLARE Index : INTEGER
DECLARE Found : BOOLEAN
// Names already holds Lucia, Hugo, Martina, Pablo, Sofia, Leo
OUTPUT "Which name do you want to find? "
INPUT Target
Found ← FALSE
Index ← 1
WHILE Found = FALSE AND Index <= 6 DO
  IF Names[Index] = Target
    THEN
      Found ← TRUE
    ELSE
      Index ← Index + 1
  ENDIF
ENDWHILE
IF Found = TRUE
  THEN
    OUTPUT Target, " found at position ", Index
  ELSE
    OUTPUT Target, " is not in the list"
ENDIF

names = ["Lucia", "Hugo", "Martina", "Pablo", "Sofia", "Leo"]
target = input("Which name do you want to find? ")
found = False
index = 0
while found == False and index < 6:
    if names[index] == target:
        found = True
    else:
        index = index + 1
if found == True:
    print(target, "found at position", index + 1)
else:
    print(target, "is not in the list")

There is something to try for this step in the IGCSE library.

Bubble sort

A bubble sort puts a list in order. It compares each pair of neighbours. If they are in the wrong order, it swaps them.

One trip through the list is a pass. After each pass the largest unsorted value has 'bubbled' to the end.

It stops when a pass makes no swaps. The toy uses a longer list: 6, 2, 9, 4, 7, 1, 5. Press Reset, then Step one comparison at a time. Watch the 9 move to the end in pass 1.

DECLARE Numbers : ARRAY[1:5] OF INTEGER
DECLARE Top : INTEGER
DECLARE Index : INTEGER
DECLARE Temp : INTEGER
DECLARE Swap : BOOLEAN
Numbers[1] ← 7
Numbers[2] ← 3
Numbers[3] ← 9
Numbers[4] ← 2
Numbers[5] ← 5
Top ← 5
REPEAT
  Swap ← FALSE
  FOR Index ← 1 TO Top - 1
    IF Numbers[Index] > Numbers[Index + 1]
      THEN
        Temp ← Numbers[Index]
        Numbers[Index] ← Numbers[Index + 1]
        Numbers[Index + 1] ← Temp
        Swap ← TRUE
    ENDIF
  NEXT Index
  Top ← Top - 1
UNTIL Swap = FALSE OR Top = 1

# Python has no REPEAT ... UNTIL, so a WHILE loop is used
numbers = [7, 3, 9, 2, 5]
top = 5
swap = True
while swap == True and top > 1:
    swap = False
    for index in range(top - 1):
        if numbers[index] > numbers[index + 1]:
            temp = numbers[index]
            numbers[index] = numbers[index + 1]
            numbers[index + 1] = temp
            swap = True
    top = top - 1
print(numbers)

There is something to try for this step in the IGCSE library.

How many comparisons? (extra)

This formula is not in the syllabus. It is useful for understanding why bubble sort is slow for long lists.

In the worst case every pass is needed. With n items, pass 1 makes n − 1 comparisons, pass 2 makes n − 2, and so on down to 1.

Adding these gives n(n − 1) ÷ 2. Double the list and the work goes up about four times.

Validation and verification are different

Validation is an automatic check by the program that data is reasonable and follows set rules. It happens on input.

Verification checks that data has been copied or typed correctly from the source. It does not check if the data is sensible.

You need both. Validation accepts an age of 15 even if the student is 16. Verification catches that typing mistake.

Range, length, type and presence checks

Range check: a number must be between a lowest and a highest value. Example: an exam mark from 0 to 100.

Length check: the number of characters must be exact or within limits. Example: a password of 8 to 20 characters.

Type check: data must be the right data type. Example: an age must be a whole number, not 'ten'. Presence check: something must be entered. The field cannot be left blank.

DECLARE UserName : STRING
DECLARE Password : STRING
// presence check: something must be typed
OUTPUT "Enter your name: "
INPUT UserName
WHILE UserName = "" DO
  OUTPUT "Error: the name cannot be blank. Enter your name: "
  INPUT UserName
ENDWHILE
// length check: 8 to 20 characters
OUTPUT "Choose a password (8 to 20 characters): "
INPUT Password
WHILE LENGTH(Password) < 8 OR LENGTH(Password) > 20 DO
  OUTPUT "Error: use 8 to 20 characters. Try again: "
  INPUT Password
ENDWHILE

user_name = input("Enter your name: ")
# presence check: something must be typed
while user_name == "":
    user_name = input("Error: the name cannot be blank. Enter your name: ")
# length check: 8 to 20 characters
password = input("Choose a password (8 to 20 characters): ")
while len(password) < 8 or len(password) > 20:
    password = input("Error: use 8 to 20 characters. Try again: ")
print("Welcome,", user_name)

Format and check digit checks

Format check: data must follow a set pattern of characters. Example: a Spanish DNI is 8 digits then 1 letter, like `12345678Z`.

Check digit: an extra digit worked out from the other digits and added to the end. The computer recalculates it. If the answers differ, there is an entry error.

Try the toy: type in each box of the form and watch its checks pass or fail. Press Fill with valid data, then change the Student ID to break the format check. Type 9780140449136 in the ISBN box, then change one digit to break the check digit.

There is something to try for this step in the IGCSE library.

Writing a validation loop

A validation loop asks for input, checks it, and asks again until it passes.

Use `REPEAT … UNTIL` or `WHILE … ENDWHILE`. Always give an error message that says what is allowed.

Python can also do a type check. `isdigit()` returns True only if every character is a digit.

DECLARE Age : INTEGER
REPEAT
  OUTPUT "Enter your age (11 to 18): "
  INPUT Age
  IF Age < 11 OR Age > 18
    THEN
      OUTPUT "Error: age must be from 11 to 18"
  ENDIF
UNTIL Age >= 11 AND Age <= 18
OUTPUT "Age accepted: ", Age

entry = input("Enter your age (11 to 18): ")
# presence, type and range checks, repeated until the entry passes
while entry == "" or not entry.isdigit() or int(entry) < 11 or int(entry) > 18:
    print("Error: enter a whole number from 11 to 18")
    entry = input("Enter your age (11 to 18): ")
age = int(entry)
print("Age accepted:", age)

Verification: visual check and double entry

A visual check means the user reads the data on screen and compares it with the original document. Example: checking a delivery address before you pay.

A double entry check means the data is typed twice. The computer compares the two entries. If they differ, it asks again.

Double entry is used for new passwords and email addresses, where you cannot see a mistake.

DECLARE Password : STRING
DECLARE Confirm : STRING
REPEAT
  OUTPUT "Enter a new password: "
  INPUT Password
  OUTPUT "Enter the same password again: "
  INPUT Confirm
  IF Password <> Confirm
    THEN
      OUTPUT "The two entries do not match. Start again."
  ENDIF
UNTIL Password = Confirm
OUTPUT "Password saved"

password = input("Enter a new password: ")
confirm = input("Enter the same password again: ")
while password != confirm:
    print("The two entries do not match. Start again.")
    password = input("Enter a new password: ")
    confirm = input("Enter the same password again: ")
print("Password saved")

Variables: named boxes in memory

A variable is a named place in memory that holds one value. The value can change while the program runs.

The name is called an identifier. Cambridge pseudocode writes identifiers in PascalCase, such as `TotalScore`.

`DECLARE` gives the name and the data type before the variable is used.

The arrow `←` means assignment: work out the value on the right, then store it in the variable on the left.

DECLARE Score : INTEGER
Score ← 0
Score ← Score + 5
OUTPUT Score

score = 0
score = score + 5
print(score)

Constants: values that never change

A constant is a named value that is set once. It cannot change while the program runs.

In pseudocode write `CONSTANT`, the name, `←` and the value. No data type is given: the value shows it.

Python has no true constants. Programmers write the name in CAPITALS to mean: do not change this.

CONSTANT VATRate ← 0.21
DECLARE Price : REAL
Price ← 50.0
OUTPUT "Price with VAT: ", Price * (1 + VATRate)

VAT_RATE = 0.21
price = 50.0
print("Price with VAT:", price * (1 + VAT_RATE))

The five data types

A data type says what kind of value a variable holds. It decides how the value is stored and what you can do with it.

Cambridge uses five data types. A CHAR goes in single quotes. A STRING goes in double quotes.

DECLARE Age : INTEGER
DECLARE Height : REAL
DECLARE Grade : CHAR
DECLARE FirstName : STRING
DECLARE IsMember : BOOLEAN
Age ← 15
Height ← 1.68
Grade ← 'A'
FirstName ← "Lucia"
IsMember ← TRUE

age = 15
height = 1.68
grade = "A"
first_name = "Lucia"
is_member = True
print(type(age), type(height), type(grade), type(first_name), type(is_member))

Choosing the right data type

Ask two questions. Will I do maths with it? Can it have a decimal part?

A phone number or a postcode is a STRING. You never add phone numbers, and an INTEGER would lose a leading 0.

Use BOOLEAN for anything with only two states: paid or not paid, logged in or not.

Input and output

Input is data going into the program, usually typed by the user. `INPUT Name` waits and stores what is typed in Name.

Output is data coming out, usually on screen. `OUTPUT` can show text and variables separated by commas.

Always show a message before an INPUT so the user knows what to type. This message is a prompt.

In Python, `input()` always gives a string. Wrap it in `int()` or `float()` to get a number.

DECLARE Name : STRING
DECLARE Age : INTEGER
OUTPUT "Enter your name"
INPUT Name
OUTPUT "Enter your age"
INPUT Age
OUTPUT "Hello ", Name, ", next year you will be ", Age + 1

name = input("Enter your name: ")
age = int(input("Enter your age: "))
print("Hello " + name + ", next year you will be", age + 1)

Sequence: one step after another

Sequence means the statements run one after another, in the order they are written.

The order matters. If a value is used before it is worked out, the answer is wrong.

CONSTANT TicketPrice ← 7.50
DECLARE Tickets : INTEGER
DECLARE Total : REAL
Tickets ← 3
Total ← Tickets * TicketPrice
OUTPUT "Total to pay: ", Total

TICKET_PRICE = 7.50
tickets = 3
total = tickets * TICKET_PRICE
print("Total to pay:", total)

Selection with IF

Selection means the program chooses which statements to run, using a condition.

A condition is a question with a TRUE or FALSE answer, such as `Mark >= 50`.

The THEN part runs when the condition is TRUE. The ELSE part runs when it is FALSE. ELSE is optional. ENDIF closes the IF.

DECLARE Mark : INTEGER
OUTPUT "Enter the mark"
INPUT Mark
IF Mark >= 50
  THEN
    OUTPUT "Pass"
  ELSE
    OUTPUT "Fail"
ENDIF

mark = int(input("Enter the mark: "))
if mark >= 50:
    print("Pass")
else:
    print("Fail")

Nested IF: up to three levels

A nested IF is an IF inside another IF. Use it when the next question depends on the first answer.

Cambridge questions use nesting up to three levels deep. More than that is hard to read.

In pseudocode the next IF goes inside the ELSE. Python can shorten ELSE followed by IF to `elif`.

DECLARE Mark : INTEGER
Mark ← 58
IF Mark >= 70
  THEN
    OUTPUT "Grade A"
  ELSE
    IF Mark >= 55
      THEN
        OUTPUT "Grade B"
      ELSE
        IF Mark >= 40
          THEN
            OUTPUT "Grade C"
          ELSE
            OUTPUT "Ungraded"
        ENDIF
    ENDIF
ENDIF

mark = 58
if mark >= 70:
    print("Grade A")
elif mark >= 55:
    print("Grade B")
elif mark >= 40:
    print("Grade C")
else:
    print("Ungraded")

Selection with CASE

`CASE OF` picks one path from many, using the value of one variable.

Each line has a value, a colon, then the statement to run. `OTHERWISE` catches every value that is not listed. ENDCASE closes it.

CASE is neater than a long chain of IFs when one variable is compared with fixed values.

Python 3.10 and later has `match` and `case`. `case _` works like OTHERWISE. Older Python uses if, elif and else.

DECLARE Choice : CHAR
OUTPUT "A = add, S = subtract, Q = quit"
INPUT Choice
CASE OF Choice
  'A' : OUTPUT "Adding"
  'S' : OUTPUT "Subtracting"
  'Q' : OUTPUT "Goodbye"
  OTHERWISE : OUTPUT "Unknown choice"
ENDCASE

choice = input("A = add, S = subtract, Q = quit: ")
match choice:
    case "A":
        print("Adding")
    case "S":
        print("Subtracting")
    case "Q":
        print("Goodbye")
    case _:
        print("Unknown choice")

Relational and logical operators

Relational operators compare two values. The answer is always TRUE or FALSE.

Logical operators join conditions. `AND` needs both to be TRUE. `OR` needs at least one TRUE. `NOT` swaps TRUE and FALSE.

The table uses Age = 15.

DECLARE Age : INTEGER
DECLARE HasCard : BOOLEAN
Age ← 15
HasCard ← TRUE
IF (Age < 26 OR Age >= 65) AND HasCard = TRUE
  THEN
    OUTPUT "Discount fare"
  ELSE
    OUTPUT "Full fare"
ENDIF

age = 15
has_card = True
if (age < 26 or age >= 65) and has_card == True:
    print("Discount fare")
else:
    print("Full fare")

Arithmetic operators, DIV and MOD

Cambridge uses seven arithmetic operators: `+`, `-`, `*`, `/`, `^`, `DIV` and `MOD`.

`/` gives the full answer, which can have a decimal part. `DIV` gives only the whole-number part. `MOD` gives the remainder.

You may see `DIV(17, 5)` or `17 DIV 5`. Both mean the same.

Try the toy: share 17 sweets between 5 friends. Each friend gets DIV(17, 5) = 3. MOD(17, 5) = 2 sweets are left over.

DECLARE Minutes : INTEGER
Minutes ← 135
OUTPUT DIV(Minutes, 60), " hours and ", MOD(Minutes, 60), " minutes"

minutes = 135
print(minutes // 60, "hours and", minutes % 60, "minutes")

There is something to try for this step in the IGCSE library.

Iteration: the count-controlled FOR loop

Iteration means repeating a block of statements. A block that repeats is called a loop.

A count-controlled loop repeats a set number of times. Cambridge writes it `FOR … TO … NEXT`.

The loop variable counts for you. `STEP` sets how much it goes up, or down, each time.

DECLARE Count : INTEGER
FOR Count ← 1 TO 5
  OUTPUT Count * 3
NEXT Count
FOR Count ← 10 TO 0 STEP -2
  OUTPUT Count
NEXT Count

for count in range(1, 6):
    print(count * 3)
for count in range(10, -1, -2):
    print(count)

The pre-condition WHILE loop

A pre-condition loop checks its condition before each pass. Cambridge writes it `WHILE … DO … ENDWHILE`.

It repeats while the condition is TRUE. If the condition is FALSE at the start, the loop body never runs.

Use it when you do not know how many passes are needed.

DECLARE Savings : REAL
DECLARE Years : INTEGER
Savings ← 1000.0
Years ← 0
WHILE Savings < 1500 DO
  Savings ← Savings * 1.1
  Years ← Years + 1
ENDWHILE
OUTPUT "Years needed: ", Years

savings = 1000.0
years = 0
while savings < 1500:
    savings = savings * 1.1
    years = years + 1
print("Years needed:", years)

The post-condition REPEAT UNTIL loop

A post-condition loop checks its condition after each pass. Cambridge writes it `REPEAT … UNTIL`.

The body always runs at least once. The loop stops when the condition becomes TRUE.

It suits validation: ask for the input, and ask again until it is acceptable.

Python has no REPEAT UNTIL. Use `while True:` and `break` out of the loop when the stop condition is TRUE.

DECLARE Mark : INTEGER
REPEAT
  OUTPUT "Enter a mark from 0 to 100"
  INPUT Mark
UNTIL Mark >= 0 AND Mark <= 100
OUTPUT "Accepted: ", Mark

while True:
    mark = int(input("Enter a mark from 0 to 100: "))
    if mark >= 0 and mark <= 100:
        break
print("Accepted:", mark)

Choosing the right loop

First ask: do I know how many times? If yes, use FOR.

If not, ask: must it run at least once? If yes, use REPEAT UNTIL. If it might need to run zero times, use WHILE.

Totalling and counting

Totalling keeps a running total: `Total ← Total + Value`.

Counting adds 1 each time something happens: `Count ← Count + 1`.

Set both to 0 before the loop starts.

DECLARE Total : INTEGER
DECLARE PassCount : INTEGER
DECLARE Mark : INTEGER
DECLARE Count : INTEGER
Total ← 0
PassCount ← 0
FOR Count ← 1 TO 5
  OUTPUT "Enter mark"
  INPUT Mark
  Total ← Total + Mark
  IF Mark >= 50
    THEN
      PassCount ← PassCount + 1
  ENDIF
NEXT Count
OUTPUT "Total: ", Total
OUTPUT "Average: ", Total / 5
OUTPUT "Passes: ", PassCount

total = 0
pass_count = 0
for count in range(1, 6):
    mark = int(input("Enter mark: "))
    total = total + mark
    if mark >= 50:
        pass_count = pass_count + 1
print("Total:", total)
print("Average:", total / 5)
print("Passes:", pass_count)

String handling: LENGTH, UCASE, LCASE

A string is a sequence of characters. Each character has a position number.

`LENGTH(s)` gives the number of characters, and spaces count.

`UCASE(s)` gives the string in capitals. `LCASE(s)` gives it in lower case. The variable itself only changes if you assign the result back.

DECLARE City : STRING
City ← "Madrid Spain"
OUTPUT LENGTH(City)
OUTPUT UCASE(City)
OUTPUT LCASE(City)

city = "Madrid Spain"
print(len(city))
print(city.upper())
print(city.lower())

SUBSTRING and the first position: 1 or 0

`SUBSTRING(s, start, length)` takes a piece out of a string. You give the start position and how many characters you want.

In Cambridge pseudocode the first character is position 1. In Python the first character is position 0.

Python uses slicing: `s[start:end]` takes characters from start up to, but not including, end.

Try the toy: type MADRID as the string. Set the start to 4 and the length to 3, and check you get RID. Then try LENGTH, UCASE and LCASE on the same string.

DECLARE Word : STRING
Word ← "MADRID"
OUTPUT SUBSTRING(Word, 1, 3)
OUTPUT SUBSTRING(Word, 4, 3)
OUTPUT SUBSTRING(Word, 1, 1)

word = "MADRID"
print(word[0:3])
print(word[3:6])
print(word[0])

There is something to try for this step in the IGCSE library.

Procedures and parameters

A subroutine is a named block of code that does one job. You write it once and call it whenever you need it.

A procedure is a subroutine that does a task but does not give a value back. You run it with `CALL`.

A parameter is a variable in the heading that receives a value when the subroutine is called. Cambridge uses up to three.

The value you pass in is called the argument. Here "Ana" and 2 are the arguments.

PROCEDURE Greet(Name : STRING, Times : INTEGER)
  DECLARE Count : INTEGER
  FOR Count ← 1 TO Times
    OUTPUT "Hello ", Name
  NEXT Count
ENDPROCEDURE

CALL Greet("Ana", 2)

def greet(name, times):
    for count in range(1, times + 1):
        print("Hello", name)

greet("Ana", 2)

Functions: subroutines that return a value

A function is a subroutine that returns a value to the place where it was called.

The heading gives the type of the value it returns, such as `RETURNS REAL`. `RETURN` sends the value back.

A function gives a value, so you use it inside an expression or an OUTPUT. You do not use CALL.

FUNCTION Average(Mark1 : REAL, Mark2 : REAL, Mark3 : REAL) RETURNS REAL
  RETURN (Mark1 + Mark2 + Mark3) / 3
ENDFUNCTION

DECLARE Result : REAL
Result ← Average(70, 64, 85)
OUTPUT "Average: ", Result

def average(mark1, mark2, mark3):
    return (mark1 + mark2 + mark3) / 3

result = average(70, 64, 85)
print("Average:", result)

Local and global variables

Scope means the part of the program where a variable can be used.

A global variable is declared in the main program. Every part of the program can use it.

A local variable is declared inside a subroutine. It exists only while that subroutine runs, and nothing outside can see it.

In Python a function can read a global variable. To change it, the function must first say `global`.

DECLARE Score : INTEGER        // global
Score ← 0

PROCEDURE AddBonus(Bonus : INTEGER)
  DECLARE Doubled : INTEGER    // local
  Doubled ← Bonus * 2
  Score ← Score + Doubled
ENDPROCEDURE

CALL AddBonus(5)
OUTPUT Score

score = 0  # global

def add_bonus(bonus):
    global score
    doubled = bonus * 2  # local
    score = score + doubled

add_bonus(5)
print(score)

Library routines: MOD, DIV, ROUND, RANDOM

A library routine is a ready-made, tested subroutine that comes with the language. You use it without writing it.

Cambridge expects four: `MOD`, `DIV`, `ROUND` and `RANDOM`. MOD and DIV were in the arithmetic step.

`ROUND(Value, Places)` rounds to a number of decimal places. `ROUND(6.97354, 2)` gives 6.97.

`RANDOM()` gives a random REAL number from 0 to 1. Multiply it and round it to get the range you want.

DECLARE Price : REAL
DECLARE Dice : INTEGER
Price ← 19.987
OUTPUT ROUND(Price, 2)
Dice ← ROUND(RANDOM() * 5, 0) + 1
OUTPUT "You rolled ", Dice

import random
price = 19.987
print(round(price, 2))
dice = random.randint(1, 6)
print("You rolled", dice)

Writing maintainable programs

A maintainable program is easy for another programmer, or you months later, to read, fix and update.

Use meaningful identifiers: `TotalPrice`, not `tp` or `x`.

Add comments that explain what a part does and why. Pseudocode comments start with `//`. Python comments start with `#`.

Use procedures and functions so each job lives in one named place. Use constants for fixed values, and indent code inside IFs, loops and subroutines.

// Works out the cost of a school trip for one pupil
CONSTANT CoachCost ← 600.0
CONSTANT EntryFee ← 8.5

FUNCTION CostPerPupil(Pupils : INTEGER) RETURNS REAL
  // the coach is shared, the entry fee is paid by each pupil
  RETURN CoachCost / Pupils + EntryFee
ENDFUNCTION

OUTPUT "Cost per pupil: ", CostPerPupil(30)

# Works out the cost of a school trip for one pupil
COACH_COST = 600.0
ENTRY_FEE = 8.5

def cost_per_pupil(pupils):
    # the coach is shared, the entry fee is paid by each pupil
    return COACH_COST / pupils + ENTRY_FEE

print("Cost per pupil:", cost_per_pupil(30))