Introduction to Pseudocode Revision Notes for VCE SSCE Mathematical Methods

Introduction to Pseudocode

This section introduces pseudocode, a way of writing algorithms that bridges the gap between natural language and actual programming code. Understanding pseudocode helps you plan and communicate algorithms before implementing them on a computer.

infoNote

Pseudocode is like a bridge between human thinking and computer instructions. It allows you to focus on the logic of your algorithm without worrying about the strict syntax rules of specific programming languages.

Terminology

Before diving into pseudocode, it's important to understand some key terms.

A computer is a machine that executes the instructions contained in algorithms. Every computer has two main components:

Hardware: the physical parts of the machine (keyboard, screen, processor, etc.)
Software: the instructions that tell the computer what to do

Computers cannot understand natural human language directly. Instead, we must give them instructions in a programming language—a formal language designed for computers to interpret. The process of converting an algorithm into a programming language is called coding.

Pseudocode is an informal notation for writing algorithms that sits between natural language and programming code. It doesn't follow the rules of any specific programming language, making it easier to read and understand. When you're ready to run an algorithm on a computer, you must translate the pseudocode into an actual programming language.

chatImportant

Why use pseudocode?

Pseudocode allows you to plan and communicate algorithms without getting bogged down in programming syntax. It's easier to understand, easier to modify, and serves as excellent documentation for your algorithm's logic before you start coding.

If–then blocks

When algorithms need to make decisions, we use if–then blocks. These structures allow different instructions to execute depending on whether a condition is true or false.

Basic if–then structure

The simplest form checks one condition:

if condition then
    follow these instructions
end if

If–else structure

We can provide alternative instructions when the condition is not satisfied:

if condition then
    follow these instructions
else
    follow these instructions
end if

Extended if–else if structure

For multiple alternatives, we can chain conditions together:

if first condition then
    follow these instructions
else if second condition then
    follow these instructions
else
    follow these instructions
end if

lightbulbExample

Worked Example: Finding the Maximum of Two Numbers

Let's write an algorithm in pseudocode to find the larger of two numbers $a$ and $b$ .

Solution:

input a, b
if a ≥ b then
    print a
else
    print b
end if

Explanation:

When $a \geq b$ , the maximum value is $a$ .

Otherwise, we must have $a < b$ , so the maximum value is $b$ .

Only one of these two outcomes will occur, and the appropriate value gets printed.

lightbulbExample

Worked Example: Assigning Letter Grades

Let's create an algorithm that assigns a letter grade based on a numerical mark out of $100$ .

Solution:

input mark
if mark ≥ 90 then
    print 'A'
else if mark ≥ 75 then
    print 'B'
else if mark ≥ 60 then
    print 'C'
else if mark ≥ 50 then
    print 'D'
else
    print 'E'
end if

Explanation:

The algorithm checks conditions in order from highest to lowest mark.

Only one grade is printed for any given input.

The grade is assigned at the first stage where the condition is satisfied.

For example, if the mark is $85$ , it doesn't meet the first condition ( $\geq 90$ ), but it does meet the second condition ( $\geq 75$ ), so 'B' is printed.

For loops

A for loop allows us to repeat the same instructions multiple times in a controlled manner. We use for loops when we know exactly how many times to repeat.

Basic for loop template

for i from 1 to n
    follow these instructions
end for

This loop uses the sequence $1, 2, 3, \ldots, n$ . There are $n$ iterations in total.

The variable i takes the values $1, 2, 3, \ldots, n$ in turn, and the instructions execute once for each value.

chatImportant

When to Use For Loops

Use a for loop when you know in advance exactly how many times the instructions need to repeat. The loop counter variable automatically tracks which iteration you're on.

lightbulbExample

Worked Example: Desk Check of Sum of Squares

Let's perform a desk check for the following algorithm:

sum ← 0
for i from 1 to 4
    sum ← sum + i²
end for
print sum

Solution:

Table

Explanation:

The initial value of sum is $0$ .

There are four passes through the loop, with the variable i taking the values $1, 2, 3$ and $4$ in turn.

In each pass, we add $i^2$ to the current sum:

Pass 1: $sum = 0 + 1^2 = 1$
Pass 2: $sum = 1 + 2^2 = 5$
Pass 3: $sum = 5 + 3^2 = 14$
Pass 4: $sum = 14 + 4^2 = 30$

The printed output is $30$ .

This algorithm calculates $1^2 + 2^2 + 3^2 + 4^2 = 30$ .

lightbulbExample

Worked Example: Sum of Reciprocals of Cubes

Part a: Write an algorithm in pseudocode to calculate the sum of the first $n$ terms of the sequence:

\frac{1}{1^3}, \frac{1}{2^3}, \frac{1}{3^3}, \ldots

Part b: Perform a desk check for $n = 5$ (give values correct to six decimal places).

Solution to part a:

input n
sum ← 0
for i from 1 to n
    sum ← sum + 1/(i³)
end for
print sum

Solution to part b:

$i$	$sum$
Initial	$0$
Pass 1	$1$
Pass 2	$2$
Pass 3	$3$
Pass 4	$4$
Pass 5	$5$

Each pass adds $\frac{1}{i^3}$ to the running sum.

While loops

A while loop provides another way to repeat instructions, but it's used when we don't know in advance how many iterations will be needed. The loop continues executing as long as a specified condition remains true.

When to use while loops

While loops are particularly useful when:

You're working towards a target accuracy
You're searching for something and don't know when you'll find it
The number of iterations depends on the values calculated during execution

Basic while loop template

while condition
    follow these instructions
end while

The loop checks the condition before each iteration. If the condition is true, the instructions execute. If false, the loop ends and the algorithm continues.

chatImportant

For Loop vs While Loop

Use a for loop when you know exactly how many iterations are needed.

Use a while loop when the number of iterations depends on a condition that changes during execution.

lightbulbExample

Worked Example: Division with Quotient and Remainder

Part a: Write an algorithm that divides $72$ by $14$ and returns the quotient and remainder.

Part b: Show a desk check to test the operation of the algorithm.

Solution to part a:

count ← 0
remainder ← 72
while remainder ≥ 14
    count ← count + 1
    remainder ← remainder − 14
end while
print count, remainder

Explanation:

We use a while loop because we don't know in advance how many times $14$ can be subtracted from $72$ .

The variable count tracks how many times we can subtract $14$ from $72$ (this will be the quotient).

The variable remainder keeps track of what's left after each subtraction.

Solution to part b:

Table

The first output is $5$ (the quotient) and the second output is $2$ (the remainder).

We can verify: $72 = 5 \times 14 + 2$ ✓

After the 5th pass, the value of remainder is $2$ . Since $2 < 14$ , the condition $remainder \geq 14$ is no longer satisfied, so we exit the loop.

lightbulbExample

Worked Example: Approximating √11

Perform a desk check for this algorithm (give values correct to six decimal places):

A ← 3
while A² > 11 + 10⁻⁴ or A² < 11 − 10⁻⁴
    A ← 0.5 × (A + 11/A)
    print A, A²
end while

Solution:

Table

Explanation:

The table shows the values of A and $A^2$ after each pass through the loop.

After the 3rd pass, $A^2 = 11.000000$ (to six decimal places), so the condition is no longer satisfied and the algorithm finishes.

infoNote

Absolute Value Function

The condition on the while loop above checks that the distance between $A^2$ and $11$ is greater than $10^{-4}$ . Using the absolute value function, this condition can be written more compactly as $|A^2 - 11| > 10^{-4}$ . Most calculators and programming languages have this as a built-in function called abs.

Functions

In algorithms, a function is a self-contained block of code that performs a specific task. Functions can be reused throughout different algorithms.

Key features of functions

Functions have several important characteristics:

Functions must be defined before they can be used
They can accept one or more inputs
They return an output value
Once defined, they can be called (used) repeatedly

chatImportant

Benefits of Functions

Functions make your code more readable, reusable, and easier to debug. Instead of writing the same code multiple times, you define it once and call it whenever needed. This follows the programming principle: "Don't Repeat Yourself."

Defining functions

Here are two examples of function definitions:

Example 1: A linear function $f(x) = 3x + 2$

define f(x):
    y ← 3x + 2
    return y

We can call this function by writing f(5), which would return $17$ .

Example 2: A function with two inputs that calculates distance from the origin

define dist(x, y):
    dist ← √(x² + y²)
    return dist

We can call this function by writing dist(3, 4), which would return $5$ .

lightbulbExample

Worked Example: Factorial Function

For a natural number $n$ , the factorial function gives the value $n! = 1 \times 2 \times 3 \times \cdots \times n$ .

Part a: Write the factorial function using pseudocode.

Part b: Using your function from part a, write an algorithm to evaluate the sum:

\frac{1}{1!} + \frac{1}{2!} + \frac{1}{3!} + \cdots + \frac{1}{10!}

Solution to part a:

define factorial(n):
    product ← 1
    for i from 1 to n
        product ← product × i
    end for
    return product

Solution to part b:

sum ← 0
for i from 1 to 10
    sum ← sum + 1/factorial(i)
end for
print sum

This demonstrates how functions make code more readable and reusable. Instead of writing the factorial calculation ten times, we define it once and call it repeatedly.

Nested loops

A nested loop is a loop placed inside another loop. This creates a two-level (or more) iteration structure.

How nested loops work

When a loop is nested inside another:

The outer loop starts its first iteration
This triggers the inner loop, which runs through all its iterations
Once the inner loop completes, control returns to the outer loop
The outer loop moves to its second iteration
This triggers the inner loop again, which runs through all its iterations
This pattern continues until the outer loop finishes

chatImportant

Key Concept: Complete Inner Cycles

For each single iteration of the outer loop, the inner loop completes all of its iterations. If the outer loop runs $m$ times and the inner loop runs $n$ times, the innermost instruction executes $m \times n$ times in total.

lightbulbExample

Worked Example: Desk Check of Nested Loop

Perform a desk check for this algorithm that tracks the values of a, b and c at each step:

c ← 0
for a from 1 to 2
    for b from 1 to 3
        c ← c + 1
    end for
end for

Solution:

Table

Explanation:

The initial value of a in the outer loop is $1$ .

With $a = 1$ , we enter the inner loop where b takes the values $1, 2$ and $3$ in turn.

After the inner loop completes (three iterations), we exit back to the outer loop.

The variable a then takes its next value, which is $2$ .

With $a = 2$ , we enter the inner loop again where b takes the values $1, 2$ and $3$ once more.

In total, there are $2 \times 3 = 6$ iterations of the innermost instruction.

Remember!

bookmarkSummary

Key Points to Remember:

Pseudocode is an informal way to write algorithms before translating them into actual programming code.
If-then blocks allow algorithms to make decisions based on conditions. Always close them with end if.
For loops are used when you know exactly how many times to repeat instructions. The loop variable takes each value in sequence.
While loops are used when the number of iterations is unknown. They continue as long as a condition is true.
Functions are reusable blocks of code that perform specific tasks. They must be defined before being called.
Nested loops have one loop inside another. For each iteration of the outer loop, the inner loop completes all its iterations.
Desk checks help verify that algorithms work correctly by manually tracking variable values through each step.

Introduction to Pseudocode (VCE SSCE Mathematical Methods): Revision Notes