Algorithms and Flowcharts Revision Notes for VCE SSCE Mathematical Methods

Algorithms and Flowcharts

Introduction to algorithms

An algorithm is a step-by-step set of instructions designed to solve a problem or complete a task. Algorithms are fundamental in mathematics and computer science, providing clear procedures that can be followed systematically.

infoNote

Algorithms form the backbone of computational thinking. They allow us to break down complex problems into manageable steps that can be executed methodically, making them essential tools for problem-solving across many disciplines.

The Sieve of Eratosthenes

One famous algorithm is the Sieve of Eratosthenes, an ancient method for finding all prime numbers up to a given natural number $n$ . This algorithm works by systematically eliminating composite numbers, leaving only the primes.

infoNote

The algorithm steps:

Step 1: Create a list of all natural numbers from $1$ to $n$ .

Step 2: Cross out $1$ and let $p$ be $2$ (the first prime).

Step 3: Circle $p$ and then cross out all the other multiples of $p$ .

Step 4: Let $p$ be the smallest number in the list that has not been marked.

Step 5: If $p^2 \leq n$ , then repeat from Step 3.

The prime numbers are all the numbers in the list that remain uncrossed.

In this algorithm, the variable $p$ represents the current prime number being considered. Its value updates each time Step 4 is performed. For example, when applied to find all primes up to $100$ , the algorithm systematically identifies: $2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97$ .

Assigning values to variables

In algorithms, a variable is a name (consisting of one or more letters) that acts as a placeholder for storing values. The concept differs from variables in pure mathematics because algorithmic variables can be reassigned different values as the algorithm progresses.

chatImportant

Unlike mathematical variables which typically represent fixed unknown values, algorithmic variables are storage locations whose values can change throughout the execution of an algorithm. This dynamic nature is fundamental to how algorithms process and manipulate data.

We use a left-pointing arrow ( $\leftarrow$ ) to show when a value is assigned to a variable. For example:

$p \leftarrow 2$ means "assign the value $2$ to the variable $p$ "

Often, a variable's new value depends on its previous value. Here are two examples:

Understanding how variables update is crucial. In the first example, $A \leftarrow A + 5$ takes the current value of $A$ (which is $3$ ), adds $5$ to it, and stores the result ( $8$ ) back in $A$ . This replaces the old value completely.

Worked example: Tracing variable values

For each sequence of instructions, we can trace how variable values change by creating a table:

lightbulbExample

Worked Example: Tracing Single Variable

Part a

Step 1: $A \leftarrow 3$
Step 2: $A \leftarrow A + 4$
Step 3: $A \leftarrow A - 1$

Starting with $A = 3$ , adding $4$ gives $A = 7$ , then subtracting $1$ gives the final value $A = 6$ .

lightbulbExample

Worked Example: Tracing Multiple Variables

Part c (two variables)

Step 1: $A \leftarrow 3$
Step 2: $B \leftarrow A$
Step 3: $A \leftarrow B + 1$

The table shows how both variables change. Initially $A = 3$ . Then $B$ is assigned the value of $A$ , so $B = 3$ . Finally, $A$ is reassigned to $B + 1 = 4$ , whilst $B$ remains $3$ .

Flowcharts

A flowchart is a visual diagram that represents an algorithm. It uses different shapes connected by arrows to show the sequence of steps and decisions in a process.

Flowchart components

Each shape in a flowchart has a specific meaning:

infoNote

Standard Flowchart Shapes:

Oval (Start/End): Marks the beginning or end of the algorithm
Rectangle (Process): Represents a basic step or operation
Diamond (Decision): Indicates a decision point with yes/no outcomes
Parallelogram (Input/Output): Shows where data is received or displayed

The arrows between shapes show the order in which steps should be followed.

Worked example: Flowchart for a piecewise function

lightbulbExample

Worked Example: Creating a Flowchart for a Piecewise Function

Create a flowchart to evaluate the piecewise-defined function:

f(x) = \begin{cases} x + 3 & \text{if } x > 0 \\ 2 - x & \text{if } x \leq 0 \end{cases}

This flowchart demonstrates how decisions work. After inputting $x$ , the diamond shape asks "Is $x > 0$ ?". If yes, we calculate $y = x + 3$ . If no, we calculate $y = 2 - x$ . Both paths then converge to print the result.

Worked example: Swapping variable values

A common algorithmic task is swapping the values of two variables. Consider this incorrect attempt:

Step 1: Input $A, B$
Step 2: $A \leftarrow B$
Step 3: $B \leftarrow A$
Step 4: Print $A, B$

lightbulbExample

Worked Example: The Problem with Direct Swapping

Testing with $A = 2$ and $B = 3$ :

Table

The problem is that when $A \leftarrow B$ is executed in Step 2, the original value of $A$ is lost. Both variables end up with the value $3$ .

chatImportant

When swapping variables, you cannot simply assign one to the other and then reverse it. The first assignment overwrites the original value, making it impossible to complete the swap. A temporary variable is essential to preserve the original value.

The solution uses a temporary variable to preserve values:

Step 1: Input $A, B$
Step 2: $\text{temp} \leftarrow A$
Step 3: $A \leftarrow B$
Step 4: $B \leftarrow \text{temp}$
Step 5: Print $A, B$

lightbulbExample

Worked Example: Correct Variable Swapping

Testing this corrected algorithm:

Table

Now the values swap correctly: the output is $A = 3$ and $B = 2$ .

The flowchart shows the sequence clearly. By storing $A$ in a temporary variable first, we preserve its value so it can be assigned to $B$ later.

Desk checking and loops

A desk check is a method for verifying that an algorithm works correctly. It involves carefully following the algorithm step by step and recording all variable values in a table after each step.

Loops in algorithms

Some algorithms contain loops - sections of code that repeat until a certain condition is met. Each time the loop repeats, we say we have completed another pass of the loop.

infoNote

Loops are powerful constructs that allow algorithms to perform repetitive tasks efficiently. Rather than writing the same instructions multiple times, a loop executes them repeatedly until a specified condition is no longer true.

Worked example: Finding remainders using loops

lightbulbExample

Worked Example: Using Loops for Remainder Calculation

Create a flowchart to find the remainder when a natural number $n$ is divided by $3$ , using repeated subtraction.

This flowchart contains a loop. Starting from the decision box "Is $n \geq 3$ ?", if the answer is yes, we subtract $3$ from $n$ and return to the decision box. This continues until $n < 3$ , at which point we exit the loop and print the final value.

Desk check for $n = 14$ :

Table

Starting with $n = 14$ , we subtract $3$ repeatedly: $14 \to 11 \to 8 \to 5 \to 2$ . After four passes through the loop, we reach $n = 2$ , which is less than $3$ , so we stop. The output is $2$ , which is indeed the remainder when $14$ is divided by $3$ (since $14 = 4 \times 3 + 2$ ).

Remember!

bookmarkSummary

Key Points to Remember:

Algorithms are step-by-step instructions for solving problems
Variables in algorithms store values that can change, using the assignment notation $\leftarrow$
Flowcharts visualise algorithms using standard shapes: ovals (start/end), rectangles (processes), diamonds (decisions), and parallelograms (input/output)
Desk checking verifies algorithms by tracing variable values through each step
Loops repeat sections of an algorithm until a condition is met, with each repetition called a pass

Algorithms and Flowcharts (VCE SSCE Mathematical Methods): Revision Notes