Computational Thinking

A recipe is a perfect everyday example of an algorithm. Consider making a cup of tea:

1. Fill the kettle with water
2. Turn the kettle on
3. Wait for the water to boil
4. Put a teabag in a mug
5. Pour boiling water into the mug
6. Wait 3 minutes
7. Remove the teabag
8. Add milk (optional)

Every step is clear, unambiguous, and the process finishes — all the properties of a good algorithm. Notice it also includes sequence (steps in order), selection (optional milk), and iteration (you could say "stir 5 times").

Analogy: Imagine you need to organise a school trip. That's a huge task! Decomposition means breaking it into sub-problems:

• Transport — book a coach, plan the route
• Permissions — send consent forms, collect replies
• Activities — plan the schedule, book tickets
• Safety — risk assessment, first aid kit, staff ratios
• Budget — calculate costs, collect payments

Each sub-problem is now small enough to give to a different person. This is exactly how software developers work — they decompose a big program into modules that different team members build independently.

The London Underground map is a famous example of abstraction. The real Tube tunnels twist, turn, and vary in depth underground. But Harry Beck's map removes all that unnecessary detail and shows only what matters: which stations exist and how they connect.

More examples of abstraction:

• A car dashboard shows speed and fuel — you don't need to see every engine component
• A weather forecast shows temperature and rain chance — not atmospheric pressure equations
• A variable name like playerScore abstracts away the memory address where the data is stored

Sequence is everywhere — brushing your teeth (wet brush → apply toothpaste → brush → rinse). The order matters!

Selection is every decision you make: "IF it's raining THEN take an umbrella ELSE wear sunglasses." In Python:

if temperature < 15:
    print("Wear a coat")
else:
    print("T-shirt weather!")

Iteration is any repetition. A count-controlled loop is like doing 20 press-ups (you know in advance how many). A condition-controlled loop is like stirring soup until it boils (you don't know when it will happen).

# Count-controlled (FOR)
for i in range(20):
    print("Press-up", i + 1)

# Condition-controlled (WHILE)
while soup_temp < 100:
    stir()

How it works: Start at the first item. Check each item one by one. If found, return its position. If the end is reached without finding it, the item is not in the list.

Analogy: Linear search is like looking for a specific book on an unsorted bookshelf — you start at one end and check each book until you find it. If it's the last book, you've checked every single one.

Walkthrough: Searching for 42 in [10, 23, 42, 7, 15]:

1. Check index 0: 10 ≠ 42 → move on
2. Check index 1: 23 ≠ 42 → move on
3. Check index 2: 42 = 42 → Found at index 2!

Only 3 comparisons needed here (best case = 1, worst case = all items).

How it works: The list must be sorted. Find the middle item. If it matches, return its position. If the target is smaller, discard the right half. If larger, discard the left half. Repeat until found or the list is empty.

Analogy: Binary search is like looking up a word in a dictionary. You don't start at page 1 — you open to the middle. If your word comes before that page alphabetically, you look in the first half. If after, the second half. Each time you halve the pages to search.

Walkthrough: Searching for 31 in [3, 7, 11, 15, 23, 31, 42]:

1. low=0, high=6, mid=3 → list[3]=15 → 31 > 15 → search right half
2. low=4, high=6, mid=5 → list[5]=31 → Found at index 5!

Only 2 comparisons! A linear search would have needed 6. For 1 million items, binary search needs at most 20 comparisons vs 1,000,000 for linear.

How it works: Compare adjacent pairs. If they are in the wrong order, swap them. Repeat passes through the list until no swaps are needed.

Analogy: Imagine bubbles rising in a fizzy drink — the largest values "bubble up" to the end of the list with each pass.

Walkthrough: Sorting [5, 3, 8, 1]:

Pass 1: [5,3,8,1] → swap → [3,5,8,1] → ok → [3,5,8,1] → swap → [3,5,1,8]
Pass 2: [3,5,1,8] → ok → [3,5,1,8] → swap → [3,1,5,8]
Pass 3: [3,1,5,8] → swap → [1,3,5,8]
✓ Sorted!

How it works: Divide the list in half repeatedly until each sub-list has one item. Then merge the sub-lists back together in order.

Analogy: Imagine sorting a deck of cards by splitting the deck in half again and again until you have single cards, then merging them back in order — like a tournament bracket in reverse.

Walkthrough: Sorting [6, 3, 8, 2]:

Split: [6,3,8,2] → [6,3] and [8,2]
Split: [6,3] → [6] and [3]  |  [8,2] → [8] and [2]
Merge: [6]+[3] → [3,6]  |  [8]+[2] → [2,8]
Merge: [3,6]+[2,8] → [2,3,6,8] ✓

How it works: Take each item from the unsorted part and insert it into the correct position in the sorted part. Like sorting playing cards in your hand.

Analogy: This is exactly how you sort playing cards in your hand. You pick up one card at a time and slide it into the right position among the cards you're already holding.

Walkthrough: Sorting [5, 2, 8, 1]:

Start: [5] | 2, 8, 1  (5 is the sorted part)
Take 2: insert before 5 → [2, 5] | 8, 1
Take 8: insert after 5 → [2, 5, 8] | 1
Take 1: insert before 2 → [1, 2, 5, 8] ✓

Break the problem into sub-problems:

• Get each student's score (input)
• Add up all the scores (processing)
• Divide total by 30 to get average (processing)
• Display the result (output)

What do we need? Student scores and the count (30). What do we ignore? Student names, subjects, dates — they're not needed for calculating an average.

total ← 0
FOR i ← 1 TO 30
    INPUT score
    total ← total + score
NEXT i
average ← total / 30
OUTPUT "The average score is: " + average

This uses sequence (steps run in order), iteration (FOR loop repeats 30 times), and variables (total, score, average). Selection isn't needed here, but we could add it: IF average >= 50 THEN OUTPUT "Pass" ELSE OUTPUT "Fail"

total = 0
for i in range(30):
    score = int(input("Enter score: "))
    total = total + score
average = total / 30
print("The average score is:", average)