Welcome to the World of Algorithms!

Hi there! In this chapter, we are going to learn how to design, create, and fix algorithms. Think of an algorithm as a recipe: a set of clear, step-by-step instructions to complete a task or solve a problem. Whether you're making a piece of toast or coding the next big app, you need a plan. Let's dive in!

Quick Review: An algorithm is just a plan. It isn't code yet—it's the logic behind the code.


1. The Big Three: Inputs, Processes, and Outputs

Before you start writing an algorithm, you need to identify three things: Input, Process, and Output (IPO). This helps you understand exactly what the problem is asking for.

  • Input: What data goes into the system? (e.g., typing your name).
  • Process: What happens to that data? (e.g., adding two numbers together).
  • Output: What comes out at the end? (e.g., a message saying "Hello" or the result of a sum).

Analogy: A Juicer. The fruit is the input, the spinning blades are the process, and the delicious juice is the output!

Key Takeaway: Always ask yourself: "What do I have?", "What do I need to do with it?", and "What should the final result look like?"


2. Structure Diagrams

Sometimes a problem is too big to solve all at once. Structure diagrams help us break a big problem down into smaller, manageable chunks (this is called Decomposition).

A structure diagram looks like an upside-down tree. The main problem is at the top, and the smaller sub-tasks are connected underneath it. This shows the hierarchy of the problem and how different parts link together.

Quick Review Box:
- Shows how a problem is broken down.
- Each box represents a smaller part of the task.
- Helps teams work on different parts of a project at the same time.


3. Flowcharts: Seeing the Logic

A flowchart is a visual way to show an algorithm using specific shapes. Each shape has a special meaning that you must learn for your OCR exam.

Important Flowchart Symbols:

  • Terminal (Oval): Used for "Start" and "Stop". Every flowchart needs these!
  • Input / Output (Parallelogram): Used when the program asks for data or shows a result.
  • Process (Rectangle): Used for instructions like calculations or setting a variable. For example: \( x = x + 1 \).
  • Decision (Diamond): Used for "Yes/No" or "True/False" questions. This is where the path splits.
  • Sub program (Rectangle with double sides): Used to show a separate set of instructions that happens elsewhere.
  • Line (Arrow): Shows the direction of the "flow".

Don't worry if your first flowchart looks messy! Use a pencil and remember that arrows must always point to the next step.


4. Pseudocode: Thinking Like a Computer

Pseudocode is "fake code." It looks like a programming language, but it's designed for humans to read. It doesn't have strict "grammar" rules like Python, but it should be easy to follow.

In the OCR exam, you will see the Exam Reference Language. Here is a simple example of pseudocode for a login system:

INPUT username
IF username == "Admin" THEN
  PRINT "Welcome back!"
ELSE
  PRINT "Access Denied"
ENDIF

Memory Aid: Think of Pseudocode as the "Rough Draft" of your program.


5. Nesting: Boxes within Boxes

Nesting is when you place one programming construct inside another. You can nest Selection (IF statements) or Iteration (Loops).

  • Nested Selection: An IF statement inside another IF statement. Useful for narrowing down choices.
  • Nested Iteration: A loop inside another loop. Imagine a clock: the "minutes" loop runs 60 times for every 1 time the "hour" loop runs.

Common Mistake: Forgetting to indent your nested code. Indentation (moving code to the right) makes it much easier to see which "box" is inside which.


6. Trace Tables: Being the Computer

A trace table is a tool used to follow an algorithm step-by-step. It helps you keep track of what happens to variables as the program runs. This is often called a "dry run".

How to use a Trace Table:
1. List every variable as a column heading.
2. Follow the algorithm line by line.
3. Every time a variable changes, write its new value in the next row of the table.

Quick Review Box: Trace tables are the best way to find logic errors. If the final value in your table isn't what you expected, there's a bug in the logic!


7. Fixing and Refining Algorithms

Sometimes algorithms have "bugs" (errors). You need to be able to identify and fix two main types:

  • Syntax Errors: These are mistakes in the "grammar" of the code (e.g., misspelling PRITN instead of PRINT). The program won't run at all.
  • Logic Errors: The program runs, but it gives the wrong answer. For example, using \( + \) when you meant to use \( * \).

Refining means making an algorithm better. This could mean making it shorter, faster, or more robust (harder to break). You can refine code by using loops instead of repeating lines or by using better variable names.

Did you know? The first "computer bug" was an actual moth stuck inside a computer in 1947! Today, we just use the term for any mistake in code.

Key Takeaway Summary:
- Use IPO to understand the goal.
- Use Flowcharts and Pseudocode to plan the steps.
- Use Trace Tables to test your plan and find errors.
- Refine your work to make it the best it can be!