Algorithms

An algorithm is a solution to a problem expressed as a finite sequence of clearly defined steps. Follow the steps in order and you turn the input into the required output.

A good algorithm is:

• Finite — it ends (it doesn't loop forever).
• Defined — each step is precise and unambiguous; anyone following it gets the same result.
• General — it works for any valid input, not just one specific case.

Most algorithms in 9618 follow the Input → Process → Output pattern:

Stage	What happens
Input	get the data needed (INPUT)
Process	do calculations / make decisions / repeat steps
Output	report the result (OUTPUT)

You will describe algorithms in three forms — structured English, flowcharts and pseudocode — and Paper 2 expects your written answers in pseudocode.

Before writing code, decide what data you need and give each item a meaningful identifier (name). Good names describe the data — StudentMark, Total, Counter — not x or a.

In 9618 you declare each variable with a data type using DECLARE:

DECLARE Total : INTEGER
DECLARE Price : REAL
DECLARE Grade : CHAR
DECLARE Name  : STRING
DECLARE Found : BOOLEAN

The five basic data types you must know:

Data type	Holds	Example
INTEGER	whole numbers	42, −7
REAL	numbers with a decimal part	3.14, 99.5
CHAR	a single character	'A', '?'
STRING	a sequence of characters	"Hello"
BOOLEAN	a truth value	TRUE / FALSE

You document all of these in an identifier table — a simple table with three columns. Examiners love to see one:

Identifier	Data type	Description
Mark	INTEGER	The student's exam mark
Pass	BOOLEAN	TRUE if Mark >= 50

Arrays are declared with their bounds and base type (1-based in 9618):

DECLARE Scores : ARRAY[1:10] OF INTEGER

Any algorithm — however large — is built from just three constructs.

Sequence — steps run one after another, each once, top to bottom:

INPUT Length
INPUT Width
Area ← Length * Width
OUTPUT Area

Selection — choose a path based on a condition. Use IF for two-way (or nested) choices and CASE for many fixed values:

IF Mark >= 50 THEN
    OUTPUT "Pass"
ELSE
    OUTPUT "Fail"
ENDIF

CASE OF Grade
    'A' : OUTPUT "Excellent"
    'B' : OUTPUT "Good"
    OTHERWISE OUTPUT "Keep trying"
ENDCASE

Iteration — repeat a block. There are three forms:

Form	Use when	Keyword pair
Count-controlled	repetitions are known/fixed	FOR i ← 1 TO n … NEXT i
Pre-condition	may run zero times	WHILE cond DO … ENDWHILE
Post-condition	must run at least once	REPEAT … UNTIL cond

FOR Count ← 1 TO 5
    INPUT Number
    Total ← Total + Number
NEXT Count

9618 has its own pseudocode style. Use it exactly — sloppy syntax loses easy marks.

Assignment uses a left arrow, not =:

Total ← 0
Name ← "Alex"

Input / output:

INPUT Age
OUTPUT "You are ", Age, " years old"

Comparison operators (used in conditions):

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

Logic (Boolean) operators: AND, OR, NOT. Combine conditions to make logic statements:

IF Age >= 13 AND Age <= 19 THEN
    OUTPUT "Teenager"
ENDIF

Comments start with //. Arrays are 1-based: ARRAY[1:n].

Closing keywords are not optional — every construct is closed:

Open	Close
IF	ENDIF
CASE OF	ENDCASE
WHILE … DO	ENDWHILE
REPEAT	UNTIL
FOR	NEXT

The same algorithm can be written three ways, and you must convert between them.

Structured English — restricted, keyword-led English. Good for a first sketch:

INPUT a number
IF the number is negative THEN
    OUTPUT "Negative"
OTHERWISE
    OUTPUT "Not negative"

Flowchart — a diagram using standard symbols. The four you must recognise are the terminator (start/stop), the parallelogram (input/output), the rectangle (process), and the diamond (decision):

Pseudocode — the most precise of the three, and what Paper 2 answers use:

INPUT Number
IF Number < 0 THEN
    OUTPUT "Negative"
ELSE
    OUTPUT "Not negative"
ENDIF

Converting: a decision diamond → an IF (or the test of a loop); a loop arrow going back → a WHILE/REPEAT; a parallelogram → INPUT/OUTPUT. Going the other way, every IF becomes a diamond with labelled Yes/No branches.

Stepwise refinement is a top-down way to design an algorithm. You start with the problem as a few large steps, then take each step and break it into smaller ones, repeating until every step is detailed enough to turn directly into pseudocode.

Example — output the largest of three numbers:

Level 1 (the big steps):

1. Get the three numbers.
2. Find the largest.
3. Output the largest.

Level 2 (refine step 2):

• Assume the first number is the largest.
• If the second is bigger, it becomes the largest.
• If the third is bigger, it becomes the largest.

Level 3 (programmable pseudocode):

INPUT Num1
INPUT Num2
INPUT Num3
Largest ← Num1
IF Num2 > Largest THEN
    Largest ← Num2
ENDIF
IF Num3 > Largest THEN
    Largest ← Num3
ENDIF
OUTPUT Largest

Each high-level step maps cleanly onto a chunk of code. This keeps complex problems manageable and makes the design easy to test and to explain.

A logic statement (condition) is anything that is either TRUE or FALSE. Logic statements drive every selection and iteration. They use the comparison operators and can be combined with AND, OR and NOT:

Logic statement	TRUE when…
Mark >= 50	the mark is 50 or more
Age >= 13 AND Age <= 19	the age is between 13 and 19 inclusive
Answer = "Y" OR Answer = "y"	either capital or lowercase Y
NOT Found	the BOOLEAN Found is FALSE

Mind the boundaries: 'at least 50' is >= 50, not > 50.

Testing with a trace table. A trace table (dry run) lets you check an algorithm by hand. Make one column per variable that changes, plus an OUTPUT column, and fill in one value as each line runs:

X ← 1
Total ← 0
WHILE X <= 3 DO
    Total ← Total + X
    X ← X + 1
ENDWHILE
OUTPUT Total

X	Total	OUTPUT
1	0
1	1
2	1
2	3
3	3
3	6
4	6
		6

When X becomes 4 the condition 4 <= 3 is FALSE, the loop ends, and 6 is output. Always show the row where the condition becomes FALSE so it's clear why the loop stopped.