How does a game turn 135 seconds into 2:15 on its timer?

Variables, constants, input and output

• A variable is a named memory location whose value can change while the program runs.
• A constant is a named value that cannot change while the program runs. Naming it means one place to update it, and clearer code.
• Assignment puts a value into a variable; the first assignment is initialisation. Use meaningful identifiers like lives, not x.
• Declare every variable with DECLARE and a data type.

CONSTANT MaxLives ← 3
DECLARE Lives : INTEGER
DECLARE PlayerName : STRING
Lives ← MaxLives
OUTPUT "Enter your name"
INPUT PlayerName
OUTPUT "Good luck, ", PlayerName
Lives ← Lives - 1
OUTPUT Lives

Data types

• A data type tells the computer what kind of data a variable holds and which operations make sense.

• Cambridge keywords: INTEGER, REAL, CHAR, STRING, BOOLEAN. A real is always written with a digit each side of the point, e.g. 4.0.

Arithmetic operators

• +, - and * work as in maths. Real division / can give a fractional answer.
• Integer division gives only the whole-number part. The remainder (modulus) is what is left over.

• In Cambridge pseudocode DIV and MOD are library routines written like functions, with integer values.

DECLARE Total : INTEGER
DECLARE Minutes : INTEGER
DECLARE Seconds : INTEGER
Total ← 200
Minutes ← DIV(Total, 60)    // 3
Seconds ← MOD(Total, 60)    // 20

How can a few lines of code print all 100 times-table answers?

Sequence and selection

• Sequence: statements run one after another, in order.
• Selection: a condition that is true or false decides which block of code runs.
• Compare with <, >, <=, >=, equal to = and not equal to <>.
• Join conditions with AND, OR, NOT.

DECLARE Mark : INTEGER
Mark ← 72
IF Mark >= 70
  THEN
    OUTPUT "Distinction"
  ELSE
    IF Mark >= 40
      THEN
        OUTPUT "Pass"
      ELSE
        OUTPUT "Fail"
    ENDIF
ENDIF

CASE statements

• A CASE statement picks one branch by comparing one variable with a list of values.
• Cases are checked in order; the first match runs, then the statement ends.
• OTHERWISE runs if no case matches.
• It is neater than a long chain of IFs when you test one variable for exact values.

DECLARE Day : STRING
INPUT Day
CASE OF Day
  "Sat" : OUTPUT "Weekend"
  "Sun" : OUTPUT "Weekend"
  OTHERWISE OUTPUT "Weekday"
ENDCASE

Count-controlled loops

• Iteration repeats a block of code.
• A count-controlled loop repeats a fixed number of times. A counter variable goes up by 1 each time unless a step is given.

DECLARE Count : INTEGER
FOR Count ← 1 TO 5
    OUTPUT Count * 3
NEXT Count

All output 3, 6, 9, 12, 15.

Condition-controlled loops

• A condition-controlled loop repeats until a condition changes, so you need not know the number of passes.
• A pre-condition (WHILE) loop tests the condition at the start: it may run zero times.
• A post-condition loop, REPEAT … UNTIL, tests at the end, so it always runs at least once.

DECLARE Total : INTEGER
Total ← 1
WHILE Total < 50 DO
    Total ← Total * 2
ENDWHILE
OUTPUT Total

All output 64.

Nesting

• Nesting puts one construct inside another: an IF inside a loop, a loop inside an IF, or a loop inside a loop.
• With nested loops, the inner loop runs in full for every pass of the outer loop.
• Total passes of the inner block = outer passes × inner passes.
• You write at most three levels of nesting.

DECLARE Row : INTEGER
DECLARE Col : INTEGER
FOR Row ← 1 TO 3
    FOR Col ← 1 TO 3
        OUTPUT Row * Col
    NEXT Col
NEXT Row

Output: 1, 2, 3, 2, 4, 6, 3, 6, 9 (9 values).

How can one name hold all 9 squares of a noughts and crosses board?

Arrays

• An array is a data structure: it stores many values under one identifier. Each value is an element.
• All elements have the same data type, and the array has a fixed length (static).
• An index picks out one element. Bounds are declared, e.g. ARRAY[1:5]; the first index is usually 1.

DECLARE Scores : ARRAY[1:5] OF INTEGER
Scores[1] ← 12
Scores[2] ← 7
Scores[3] ← 9
Scores[4] ← 15
Scores[5] ← 4
OUTPUT Scores[2]      // 7
Scores[4] ← 20        // 15 becomes 20

Looping through an array

• Use a variable as the index in a count-controlled loop to visit every element in turn.
• The counter runs from the lower bound to the upper bound.

DECLARE Temps : ARRAY[1:5] OF INTEGER
DECLARE Total : INTEGER
DECLARE Index : INTEGER
// Temps holds 18, 21, 17, 22, 19
Total ← 0
FOR Index ← 1 TO 5
    Total ← Total + Temps[Index]
NEXT Index
OUTPUT Total

All output 97.

2D arrays

• A two-dimensional (2D) array is like a table: one identifier, with rows and columns.
• Each element needs two indexes: Board[Row, Column] (row first here).
• A noughts and crosses board is a 3 × 3 2D array of characters.

DECLARE Board : ARRAY[1:3, 1:3] OF CHAR
Board[2,2] ← 'X'     // centre square
Board[3,1] ← 'O'     // bottom-left square

Two subroutines both use a variable called total. Why no clash?

Subroutines

• A subroutine is a named, out-of-line block of code. It runs when you call it by its name, then control returns to the line after the call.
• A procedure carries out a task. A function carries out a task and returns a value.

PROCEDURE Welcome
    OUTPUT "Welcome to the quiz"
ENDPROCEDURE

CALL Welcome
CALL Welcome

Parameters and return values

• A parameter passes data into a subroutine when it is called. Values are matched to parameters in order.
• A function sends its result back with return. The returned value replaces the call, so store it or use it straight away.
• Give each parameter a data type, and the function a RETURNS type. There are up to three parameters. Procedures are called with CALL; functions are used inside an expression.

FUNCTION Area(Width : INTEGER, Height : INTEGER) RETURNS INTEGER
    DECLARE Result : INTEGER
    Result ← Width * Height
    RETURN Result
ENDFUNCTION

DECLARE RoomArea : INTEGER
RoomArea ← Area(4, 5)
OUTPUT RoomArea    // 20

Local and global variables

• A local variable is declared inside a subroutine: it only exists while that subroutine runs and is only usable inside it.
• A global variable is declared in the main program and can be used anywhere.
• Good practice: nothing outside can change a local variable, and its name can be reused elsewhere.
• A variable DECLAREd inside a subroutine is local; one declared in the main program is global.

FUNCTION AddBonus(Score : INTEGER) RETURNS INTEGER
    DECLARE NewScore : INTEGER    // local
    NewScore ← Score + Bonus
    RETURN NewScore
ENDFUNCTION

DECLARE Bonus : INTEGER           // global
Bonus ← 5
OUTPUT AddBonus(10)               // 15
OUTPUT NewScore                   // error: NewScore does not exist here

Why use subroutines?

• Reuse: write code once and call it many times, so there is less to write and check.
• Decomposition: each subroutine solves one part and can be written and tested on its own.
• Maintenance: fix or improve the code in one place.
• Library routines are ready-made subroutines, e.g. ROUND, RANDOM, DIV, MOD.

How does an app show only the last 4 digits of your card number?

Strings have positions

• A string is a sequence of characters. Each character has a position, its index.
• Cambridge usually counts the first character as position 1, but a question may use 0, so check.
• The length of a string is how many characters it holds, spaces included.
• A card number is stored as a string, not an integer: it is never used in arithmetic.

DECLARE Card : STRING
Card ← "4929123456789012"
OUTPUT LENGTH(Card)
// outputs 16

Taking a substring

• A substring is part of a string, picked out by position.
• SUBSTRING(string, start, length) takes length characters from position start.
• Using the length makes the code work for any card length.

DECLARE Card : STRING
DECLARE Last4 : STRING
Card ← "4929123456789012"
Last4 ← SUBSTRING(Card, LENGTH(Card) - 3, 4)
OUTPUT "****", Last4

More string tools

• UCASE("Happy") gives "HAPPY"; LCASE('W') gives 'w'.
• Use these to compare text whatever case it was typed in.

Random numbers

• Games, quizzes and simulations need unpredictable values, such as a dice roll.
• RANDOM() gives a number from 0 to 1, so multiply, round and add to get the range you need.

DECLARE Dice : INTEGER
Dice ← ROUND(RANDOM() * 5, 0) + 1
OUTPUT Dice

Reading and writing files

• Variables are lost when a program ends. A file in secondary storage keeps data, such as high scores, for next time.
• Open the file, read or write it, then close it so the data is saved and the file is freed.
• Open a file FOR READ or FOR WRITE; WRITE creates a new file, so any existing data is lost.

DECLARE Line : STRING
Line ← "Zara,42"
OPENFILE "Scores.txt" FOR WRITE
WRITEFILE "Scores.txt", Line
CLOSEFILE "Scores.txt"
OPENFILE "Scores.txt" FOR READ
READFILE "Scores.txt", Line
OUTPUT Line
CLOSEFILE "Scores.txt"

Big ideas

• A variable is a named memory location whose value can change; a constant keeps one value while the program runs.
• Choose the data type that fits the data: integer, real, Boolean, character or string.
• Integer division gives the whole-number part; the remainder (modulus) gives what is left over.
• Sequence runs statements in order; selection uses a true/false condition to choose a branch (IF or CASE).
• Count-controlled loops repeat a fixed number of times; condition-controlled loops repeat until a condition changes, tested at the start or the end.
• In nested loops the inner loop runs fully for every pass of the outer loop.
• An array holds many values of one data type under one identifier; an index picks out an element (from the declared lower bound, usually 1).
• A 2D array is a table of rows and columns, so each element needs two indexes.
• A subroutine is a named block of code called by its name; a function returns a value and a procedure does not.
• Parameters pass data in, in order; return passes a result back to the call.
• Local variables exist only inside their subroutine while it runs, so the same name can be reused safely; global variables can be used anywhere.
• A string is a sequence of characters, each with an index; the length is how many characters it has. Positions usually start at 1.
• A substring picks out part of a string by position.
• Files keep data after a program ends: open, read or write, close.
• Random number functions give a value in a range, including both ends.