Representing algorithms

Welcome to the World of Algorithms!

Hello there! Welcome to one of the most important chapters in Computer Science. In this section, we are going to look at how we take a big, messy problem and turn it into a clear set of instructions that a computer can understand. This is called representing algorithms.

Don’t worry if this seems a bit "techy" at first. Think of an algorithm like a recipe for baking a cake or the instructions for building a LEGO set. If the instructions are clear, anyone can do it! Let's dive in.

1. What is an Algorithm?

At its heart, an algorithm is simply a sequence of steps that can be followed to complete a task.

Important Distinction: A computer program is the actual code (like Python or C#) that runs on a machine. An algorithm is the logic or the "plan" behind that code.
Analogy: An algorithm is the musical score (the notes on paper), while the program is the actual performance of the music.

Quick Review: Algorithm vs. Program

• Algorithm: The plan/steps (Language independent).
• Program: The implementation (Written in a specific language).

2. Decomposition: Breaking it Down

Sometimes, a problem is too big to solve all at once. Decomposition means breaking a complex problem down into smaller, more manageable parts (sub-problems).

Each sub-problem should accomplish one specific task. These can often be broken down even further until they are easy to solve.

Real-world Example: If you want to "Clean the House," you decompose it into:
1. Clean the kitchen.
2. Vacuum the living room.
3. Scrub the bathroom.

3. Abstraction: Focusing on What Matters

Abstraction is the process of removing unnecessary details from a problem so you can focus on the important parts. If we include too much detail, our algorithm becomes confusing.

The Best Analogy: A London Underground (Tube) Map.
The map doesn't show you exactly where the tracks curve or how deep they are under the ground. It removes those "details" (abstraction) and only shows you what you need: the stations and the connections between them.

Summary Takeaway:

Decomposition breaks it into pieces. Abstraction removes the fluff.

4. Ways to Represent Algorithms

When we create an algorithm, we need a way to write it down so others (and computers) can follow it. The AQA syllabus focuses on three main ways:

A. Flowcharts

A flowchart is a visual diagram of an algorithm. We use specific shapes for different actions:

• Ovals: Start and Stop points.
• Rectangles: Processes (e.g., Calculation: Total = Score + 10).
• Parallelograms: Input and Output (e.g., Get User Name or Print "Hello").
• Diamonds: Decisions (e.g., Is the score > 50?). These always have two paths: Yes/No or True/False.

B. Pseudo-code

Pseudo-code is a way of writing instructions that looks like a programming language but uses simple English words. It doesn't have strict rules like real code, but AQA has a "standard version" you will see in exams.

Example:
IF score > 50 THEN
   OUTPUT "You passed!"
ELSE
   OUTPUT "Try again."
ENDIF

C. Program Code

This is the actual code written in a language like Python, C#, or VB.NET. This is the final version the computer actually runs.

5. Inputs, Processes, and Outputs (IPO)

Every simple algorithm can be explained using these three stages:

1. Inputs: The data that goes into the algorithm (e.g., the user typing their age).
2. Processing: The calculations or decisions made using that data (e.g., checking if the age is over 18).
3. Outputs: The result produced by the algorithm (e.g., displaying "Access Granted").

Did you know? Almost every app you use, from TikTok to Calculator, follows this basic IPO pattern!

6. Determining the Purpose of an Algorithm

If you are given an algorithm and asked "What does this do?", there are two ways to figure it out:

Visual Inspection

This is simply looking at the code or flowchart and "reading" it logically to see what the goal is.

Trace Tables

A trace table is a tool used to track the values of variables as an algorithm runs. It helps you see exactly what is happening at every step.

Step-by-Step for Trace Tables:
1. Create a column for each variable in the algorithm.
2. Create a column for the "Output".
3. Follow the instructions line-by-line, updating the values in the table whenever they change.

Common Mistake to Avoid:

When using a trace table, don't skip lines! Even if a variable doesn't change on a certain step, keep following the logic line-by-line to ensure you don't miss a Decision (Diamond) or a Loop.

Quick Review Box

• Algorithm: A step-by-step plan.
• Decomposition: Breaking it down.
• Abstraction: Hiding the detail.
• Flowchart: The visual map.
• Pseudo-code: The "fake" code.
• Trace Table: The tool to test if it works.

Great job! You've covered the fundamentals of representing algorithms. Remember, algorithms are just logical paths—once you learn to spot the patterns of inputs and decisions, you'll be able to solve any problem!