Lesson Notes By Weeks and Term v5 - Grade 10

Lesson Video

This page supports the lesson note with a companion video and a short classroom-ready summary.

For class groups and homework, share this lesson page so learners also get the summary, objectives, and full lesson context.

Performance objectives

• Define 'algorithm' and its importance.
• Decompose a problem into smaller sub-problems.
• Represent an algorithm using pseudocode and flowcharts.
• Identify basic control structures: sequence and selection.
• Trace the execution of a simple algorithm.

Lesson summary

This week, we begin our journey into the exciting world of computer programming! We'll be focusing on the foundational concepts of algorithmic thinking and taking our first steps in introductory programming. Algorithmic thinking is a crucial skill, not just for programmers, but for anyone who wants to solve problems effectively. In a world increasingly driven by technology, understanding how to break down complex tasks into manageable steps and communicate these steps to a computer (or another person!) is invaluable.

Lesson notes

2.1 What is an Algorithm? An algorithm is a well-defined, step-by-step procedure for solving a problem or accomplishing a task. It's a precise sequence of instructions that, when followed correctly, will always lead to the desired outcome. Algorithms are the backbone of computer programs; without them, computers would be unable to perform any useful tasks.

Key characteristics of an algorithm: Finiteness: An algorithm must always terminate after a finite number of steps. It can't go on forever.

Definiteness: Each step in the algorithm must be precisely and unambiguously defined. There should be no room for interpretation.

Input: An algorithm may have zero or more inputs. These are the values that the algorithm needs to start with.

Output: An algorithm must produce at least one output. This is the result of the algorithm's processing.

Effectiveness: Each step in the algorithm must be basic enough to be carried out in a finite amount of time and with finite resources. 2.2 Representing Algorithms: Pseudocode and Flowcharts We can represent algorithms in several ways, but two common methods are pseudocode and flowcharts.

Pseudocode: This is an informal, human-readable description of an algorithm using English-like statements. It's not an actual programming language, but it allows us to express the logic of an algorithm without worrying about the specific syntax of a programming language.

Example: ```pseudocode BEGIN DISPLAY "Enter your age:" INPUT age IF age >= 18 THEN DISPLAY "You are eligible to vote." ELSE DISPLAY "You are not eligible to vote." ENDIF END ``` Flowcharts: This is a visual representation of an algorithm using standard symbols to represent different types of operations. Flowcharts are helpful for understanding the overall flow of an algorithm.

Common Flowchart Symbols: Oval: Start/End Rectangle: Process (an action or instruction)

Diamond: Decision (a condition that can be true or false)

Parallelogram: Input/Output Arrow: Flow of control (direction of the algorithm) (A flowchart illustrating the same age-eligibility algorithm as above would be included here, but markdown struggles to accurately represent flowcharts. Imagine an oval labelled "Start", flowing into a parallelogram labelled "Input age", flowing into a diamond labelled "age >= 18?", with "Yes" flowing to a parallelogram labelled "Display 'Eligible'", and "No" flowing to a parallelogram labelled "Display 'Not Eligible'", both then flowing into an oval labelled "End". Consider using a separate tool like draw.io to create and embed flowcharts in your lessons.) 2.3 Basic Control Structures Control structures determine the order in which the instructions in an algorithm are executed. The two basic control structures we'll focus on this week are: Sequence: Instructions are executed one after another in the order they appear. This is the simplest control structure.

Example (Pseudocode): ```pseudocode BEGIN DISPLAY "Enter your name:" INPUT name DISPLAY "Hello, " + name END ``` Selection (IF-THEN-ELSE): A condition is evaluated, and a different set of instructions is executed depending on whether the condition is true or false. This allows the algorithm to make decisions.

Example (Pseudocode): ```pseudocode BEGIN DISPLAY "Enter a number:" INPUT number IF number > 0 THEN DISPLAY "The number is positive." ELSE DISPLAY "The number is not positive." ENDIF END ``` 2.4 Worked Examples Example 1: Calculating the Area of a Rectangle Problem: Develop an algorithm to calculate the area of a rectangle, given its length and width.

Pseudocode: ```pseudocode BEGIN DISPLAY "Enter the length of the rectangle:" INPUT length DISPLAY "Enter the width of the rectangle:" INPUT width area = length * width DISPLAY "The area of the rectangle is: " + area END ``` Explanation: The algorithm starts by prompting the user to enter the length and width of the rectangle. The user's input is stored in the variables `length` and `width`. The area is calculated by multiplying the `length` and `width`. The calculated area is displayed to the user.

Example 2: Determining if a Number is Even or Odd Problem: Develop an algorithm to determine if a given number is even or odd.

Pseudocode: ```pseudocode BEGIN DISPLAY "Enter a number:" INPUT number remainder = number MOD 2 // MOD operator gives the remainder of a division IF remainder = 0 THEN DISPLAY "The number is even." ELSE DISPLAY "The number is odd." ENDIF END ``` Explanation: The algorithm starts by prompting the user to enter a number. The user's input is stored in the variable `number`. The `MOD` operator calculates the remainder when the number is divided by

2. If the remainder is 0, the number is even; otherwise, it's odd. The appropriate message is displayed to the user.

Example 3: Finding the Larger of Two Numbers Problem: Develop an algorithm to find the larger of two numbers.