Iteration and Selection Revision Notes for VCE SSCE Mathematical Methods

Iteration and Selection

When writing algorithms, the order in which steps are executed is crucial. Normally, steps run sequentially, one after another. However, there are two powerful programming constructs that allow you to control this flow in different ways: iteration and selection.

Understanding iteration

Iteration is a fundamental concept in programming that allows you to repeat a set of instructions multiple times in a controlled manner. Think of it as creating a cycle of steps that keeps running until a specific condition is met.

infoNote

Iteration is the backbone of efficient programming. Without loops, you would have to write the same instructions repeatedly, making code long, error-prone, and difficult to maintain. Mastering iteration is essential for solving real-world problems that involve repetitive tasks.

Key terms in iteration

A loop is the sequence of instructions that you want to repeat. Each time the loop completes one full cycle, we call this a pass of the loop. Loops are essential for performing repetitive calculations efficiently, such as processing lists of data or performing the same operation many times.

chatImportant

When working with loops, you'll often need to update variables. We use the arrow notation ( $\leftarrow$ ) to show variable assignment. For example, $n \leftarrow n + 1$ means "take the current value of $n$ , add $1$ to it, and store this new value back in $n$ ".

This is different from an equation - it's an instruction to update a variable's value, not a mathematical equality.

Worked example: compound interest calculation

lightbulbExample

Worked Example: Compound Interest Calculation

Let's see how iteration works with a practical financial example.

Problem: Sophia invests $100,000 at an interest rate of 5% per annum, compounded annually. We need to find the value of her investment at the end of each year for the first five years.

Solution:

The interest rate of 5% means we multiply by $1.05$ each year (since $100\% + 5\% = 105\% = 1.05$ ).

We'll use two variables:

A represents the current value of the investment
n keeps track of how many years have passed

Algorithm steps:

Step 1: Set initial values: $A \leftarrow 100000$ and $n \leftarrow 0$

Step 2: Update the investment value and year counter: $A \leftarrow 1.05A$ and $n \leftarrow n + 1$

Step 3: Display the results: Print $n$ and Print $A$

Step 4: Continue repeating from Step 2 while $n < 5$

Flowchart representation:

Table showing each pass of the loop:

Table

Notice how the investment grows from $100,000 to $127,628.16 over five years. Each pass of the loop applies the same multiplication, demonstrating the power of iteration for repetitive calculations.

Working with sequences

The compound interest example produces a sequence of values. In mathematics, a sequence is an ordered list of numbers, where the position of each number matters. The individual numbers in a sequence are called terms. For instance, in the sequence $A_1, A_2, A_3, A_4, A_5$ , the first term is $A_1$ , the second term is $A_2$ , and so on.

infoNote

An infinite sequence can be thought of as a function whose domain is the natural numbers. For example, the sequence of odd numbers $1, 3, 5, 7, \ldots$ can be defined by the function $f : \mathbb{N} \to \mathbb{R}$ , where $f(n) = 2n - 1$ . The first term is $f(1) = 1$ , the second term is $f(2) = 3$ , and the pattern continues.

Worked example: summing sequence terms

lightbulbExample

Worked Example: Summing Sequence Terms

This example shows how to use iteration to calculate the sum of terms in a sequence.

Problem: Consider the sequence defined by $f : \mathbb{N} \to \mathbb{R}$ , $f(n) = 3n + 1$ . Find the sum of the first five terms: $f(1) + f(2) + f(3) + f(4) + f(5)$ .

Solution:

We need a variable called sum to keep a running total. It's crucial to start sum at 0 before adding anything to it.

Algorithm steps:

Step 1: Initialize variables: $sum \leftarrow 0$ and $n \leftarrow 1$

Step 2: Add the current term to the sum: $sum \leftarrow sum + f(n)$

Step 3: Move to the next term: $n \leftarrow n + 1$

Step 4: Continue repeating from Step 2 while $n \leq 5$

Step 5: Display the final result: Print $sum$

Flowchart representation:

Table tracking the accumulation:

Table

The final output is 50, which represents $4 + 7 + 10 + 13 + 16$ . Notice how the sum accumulates gradually with each pass, and the algorithm automatically calculates $f(n)$ for each value of $n$ from $1$ to $5$ .

Understanding selection

While iteration allows you to repeat steps, selection lets you make decisions within your algorithm. Selection uses conditional statements to determine which steps to execute based on whether certain conditions are true or false. The most common form is the "If...then...else" structure.

Selection is particularly useful when dealing with piecewise-defined functions, where different rules apply depending on the input value. This decision-making capability makes algorithms much more flexible and powerful.

Worked example: piecewise-defined function

lightbulbExample

Worked Example: Piecewise-Defined Function

Problem: Consider the function $f : \mathbb{N} \to \mathbb{R}$ given by:

f(n) = \begin{cases} 2n + 4 & \text{if } n \text{ is even} \\ n + 3 & \text{if } n \text{ is odd} \end{cases}

This function generates the sequence $4, 8, 6, 12, \ldots$ . Write an algorithm to generate the first six terms.

Solution:

We use a variable T to represent the current term of the sequence.

Algorithm steps:

Step 1: Initialize the counter: $n \leftarrow 1$

Step 2: Determine which formula to use:

If $n$ is even, then $T \leftarrow 2n + 4$

Otherwise $T \leftarrow n + 3$

Step 3: Display the results: Print $n$ , $T$

Step 4: Move to the next term: $n \leftarrow n + 1$

Step 5: Continue repeating from Step 2 while $n \leq 6$

Table of results:

$n$	$T$
1	4
2	8
3	6
4	12
5	8
6	16

After the 6th pass, $n$ becomes $7$ , which fails the condition $n \leq 6$ , so the loop terminates.

The key feature here is the selection in Step 2, where the algorithm chooses between two different formulas based on whether $n$ is even or odd.

Worked example: Australian tax calculation

lightbulbExample

Worked Example: Australian Tax Calculation

This real-world example demonstrates how selection handles multiple conditions in a practical application.

Problem: Calculate tax based on Australian tax brackets (from a past financial year).

Tax brackets:

Table

Solution:

Part a: Express the tax as a piecewise-defined function.

Let $f(A)$ be the tax on an income of $A, where $A$ is a whole number:

f(A) = \begin{cases} 0 & \text{if } A \leq 18200 \\ 0.19A - 3458 & \text{if } 18200 < A \leq 37000 \\ 0.325A - 8453 & \text{if } 37000 < A \leq 90000 \\ 0.37A - 12503 & \text{if } 90000 < A \leq 180000 \\ 0.45A - 26903 & \text{if } A > 180000 \end{cases}

Part b: Write an algorithm to calculate the tax.

Step 1: Input income

Step 2a: If $income \leq 18200$ , then $tax \leftarrow 0$

Step 2b: Else if $income \leq 37000$ , then $tax \leftarrow 0.19 \times income - 3458$

Step 2c: Else if $income \leq 90000$ , then $tax \leftarrow 0.325 \times income - 8453$

Step 2d: Else if $income \leq 180000$ , then $tax \leftarrow 0.37 \times income - 12503$

Step 2e: Else $tax \leftarrow 0.45 \times income - 26903$

Step 3: Print $tax$

chatImportant

Understanding Cascading Selection:

The "Else" instructions mean the tax is calculated only at the first stage where the condition is satisfied. For example, if the income is $70,000, the algorithm will skip Steps 2a and 2b, calculate the tax at Step 2c (since $70,000 falls in the range where $income \leq 90000$ ), and then proceed directly to Step 3.

This cascading structure ensures each income is taxed according to exactly one bracket, making the algorithm both efficient and accurate.

Remember!

bookmarkSummary

Key Points to Remember:

Iteration allows you to repeat steps in a controlled way using loops, where each complete cycle is called a pass
The arrow notation ( $\leftarrow$ ) is used for variable assignment, such as $n \leftarrow n + 1$ , which means "update $n$ by adding 1"
Sequences are ordered lists of numbers, and iteration is particularly useful for processing sequence terms
Selection enables decision-making in algorithms using conditional statements like "If...then...else"
Piecewise-defined functions require selection to determine which formula applies based on the input value
In cascading "else if" structures, only the first matching condition is executed, making them efficient for multi-bracket calculations like tax systems

Iteration and Selection (VCE SSCE Mathematical Methods): Revision Notes