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.
• Assignment puts a value into a variable; the first assignment is initialisation. Use meaningful identifiers like lives, not x.

lives is integer
playerName is string
set lives = 3
output "Enter your name"
input playerName
output playerName
set 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.

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.

set total = 200
set minutes = total DIV 60    /** 3 */
set seconds = total MOD 60    /** 20 */

Casting

• Casting converts a value from one data type to another, e.g. the string '15' to the integer 15.
• Keyboard input usually arrives as a string, so cast it before doing arithmetic.
• Cast numbers to strings to join them into a message.

input ageText
set age = val(ageText)
output age + 1

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, XOR.

set mark = 72
if mark >= 70
    output "Distinction"
else
    if mark >= 40
        output "Pass"
    else
        output "Fail"
    end if
end if

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.

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 WHILE loop tests the condition at the start: it may run zero times.
• repeat … until tests at the end, so it always runs at least once.

set total = 1
while total < 50
    set total = total * 2
repeat
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.

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).

Counts and rogue values

• A count records how many times something has happened; it can stop a loop when it reaches a set value.
• A rogue value is a value outside the normal data (e.g. −1 for a mark) that tells a loop to stop.
• Check for the rogue value before processing, so it is never counted or added.

set count = 0
set total = 0
input mark
while mark <> -1
    set count = count + 1
    set total = total + mark
    input mark
repeat
output count
output total

Inputs 12, 7, 9, −1 give a count of 3 and a total of 28.

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.
• An index picks out one element. The first element has index 0.

set scores[0] = 12
set scores[1] = 7
set scores[2] = 9
set scores[3] = 15
set scores[4] = 4
output scores[1]      /** 7 */
set scores[3] = 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 0 to length − 1.

/** temps holds 18, 21, 17, 22, 19 */
set total = 0
for i = 0 to 4
    set total = total + temps[i]
next i
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, col] (row first here).
• A noughts and crosses board is a 3 × 3 2D array of characters.

/** board is a 3 x 3 array of characters */
set board[1,1] = "X"    /** centre square */
set board[2,0] = "O"    /** bottom-left square */

Records

• A record groups related data about one item under one name.
• Each item of data in a record is a field. Fields can have different data types.
• Compare: an array's elements all share one data type, but a record mixes types.
• A file is a collection of records of the same design.

File design

• Design each record first: field names, data types and field lengths.
• Fixed-length records give every field a set size, so every record is the same length.
• Choose a key field whose value is unique for every record, e.g. petID.
• File size = record size × number of records, e.g. 40 bytes × 500 records = 20,000 bytes.

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.

Declare Welcome
    output "Welcome to the quiz"
End Subroutine

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.

Declare Area(width, height)
    set result = width * height
    return result
End Subroutine

set 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.

Declare AddBonus(score)
    set newScore = score + bonus    /** newScore is local */
    return newScore
End Subroutine

set bonus = 5                       /** bonus is global */
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.
• Give subroutines well-defined interfaces and self-documenting identifiers.

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.
• A question tells you whether the first character is position 0 or 1, 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.

set card = "4929123456789012"
output len(card)
/** outputs 16 */

Taking a substring

• A substring is part of a string, picked out by position.
• left(string, x) and right(string, x) take x characters from the left or right end; mid(string, x, y) takes characters from the middle.
• right counts back from the end, so the code works for any card length.

set card = "4929123456789012"
set last4 = right(card, 4)
output "****", last4

More string tools

• len(string) gives the length; mid(string, x, y) takes characters from the middle.
• trim(string) removes spaces from the ends; val(string) and int(string) turn digit strings into numbers.
• char(number) gives the character for a character code; instring finds one string inside another.

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.
• Lines can be read into a variable or into an array (a list), and written from one.

file = open("scores.csv", "a")
file.write("Zara,42\n")
file.close()
file = open("scores.csv", "r")
for line in file:
    fields = line.strip("\n").split(",")
    print(fields[0] + " scored " + fields[1])
file.close()

Big ideas

• A variable is a named memory location whose value can change as the program runs.
• Choose the data type that fits the data: integer, real, Boolean, character or string, and cast between types when needed (input text to an integer).
• 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.
• 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 (the first is index 0).
• A 2D array is a table of rows and columns, so each element needs two indexes.
• A record groups fields of different data types about one item.
• 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. Check whether positions start at 0 or 1.
• A substring picks out part of a string by position.
• Files keep data after a program ends: open, read or write, close.