Introduction to Algorithms and Problem Solving

Active learning works well for this topic because students need to physically experience inefficiencies to truly understand algorithmic complexity. Moving beyond abstract explanations helps them grasp why certain methods scale poorly or excel as data grows. Simulating processes like sorting and searching makes the hidden steps visible and memorable for young learners transitioning to O-Level rigor.

• Secondary 4
• Computing
• 3 activities
• 15 min–30 min

Learning Objectives

1. Analyze a given problem statement to identify its core components and constraints for algorithmic design.
2. Compare and contrast different strategies for breaking down complex problems into smaller, manageable steps.
3. Explain the fundamental role of algorithms in solving everyday computational and non-computational problems.
4. Differentiate between the abstract concept of an algorithm and its concrete implementation as a computer program.
5. Design a sequence of steps to solve a simple problem, representing it as a flowchart or pseudocode.

Simulation Game

⏱ 30 min·Small Groups

Simulation Game: The Human Sort Race

Assign students random numbers on cards and have two groups compete to sort themselves. One group must follow the strict adjacent-swap logic of a Bubble Sort, while the other uses the divide-and-conquer approach of a Merge Sort to see which is faster as the 'list' grows.

Prepare & details

Explain how algorithms are essential for solving everyday problems.

Facilitation Tip: During The Human Sort Race, assign roles clearly so students focus on the algorithm’s steps rather than social dynamics.

Setup: Flexible space for group stations

Materials: Role cards with goals/resources, Game currency or tokens, Round tracker

• Apply
• Analyze
• Evaluate
• Create
• Social Awareness
• Decision-Making

Think-Pair-Share

⏱ 15 min·Pairs

Think-Pair-Share: Search Strategy Showdown

Give students a sorted list of 100 Singaporean landmarks and ask them to find 'Merlion Park'. They first brainstorm the maximum number of guesses needed for linear versus binary search, then pair up to prove their logic using a deck of cards.

Prepare & details

Differentiate between an algorithm and a program.

Facilitation Tip: For Search Strategy Showdown, provide identical unsorted lists to each pair to highlight why binary search requires prior sorting.

Setup: Standard classroom seating; students turn to a neighbor

Materials: Discussion prompt (projected or printed), Optional: recording sheet for pairs

• Understand
• Apply
• Analyze
• Self-Awareness
• Relationship Skills

Inquiry Circle

⏱ 25 min·Small Groups

Inquiry Circle: Best Case vs Worst Case

Provide three sets of data: one already sorted, one reverse-sorted, and one random. Groups run a bubble sort on each and count the number of comparisons made, documenting why the 'best case' scenario drastically changes performance.

Prepare & details

Analyze a given problem to identify its core components for algorithmic design.

Facilitation Tip: In Best Case vs Worst Case, use a visible timer to show how input order affects runtime, making the concept concrete.

Setup: Groups at tables with access to source materials

Materials: Source material collection, Inquiry cycle worksheet, Question generation protocol, Findings presentation template

• Analyze
• Evaluate
• Create
• Self-Management
• Self-Awareness

Teaching This Topic

Experienced teachers introduce this topic by letting students experience the pain of inefficient methods firsthand. Avoid starting with definitions or theory, as students won’t grasp why optimizations matter. Instead, let them struggle with bubble sort on a large dataset, then introduce merge sort as a relief. Research shows this ‘productive failure’ approach builds deeper understanding than direct instruction alone. Always connect timing results back to real-world scenarios, like searching a phone contact list, to make the stakes clear.

What to Expect

Students will demonstrate understanding by accurately timing and comparing algorithms, explaining trade-offs between methods, and justifying their choices based on real data. They should articulate why some approaches fail on large datasets while others adapt. Look for clear reasoning about time complexity and precision in their analyses.

Watch Out for These Misconceptions

Common Misconception

During Search Strategy Showdown, watch for students who try binary search on an unsorted list without realizing it will fail.

What to Teach Instead

Pause the activity and ask pairs to attempt binary search on their unsorted list, then observe the incorrect results. Have them manually sort the list first, then repeat the search to see the difference. Discuss why the initial approach didn’t work.

Common Misconception

During The Human Sort Race, watch for students who assume bubble sort is efficient because it’s easy to describe.

What to Teach Instead

Have students time themselves performing bubble sort on a 20-item list, then time a peer using merge sort on the same list. Compare the two times and discuss how ease of coding doesn’t translate to speed or scalability.

Assessment Ideas

Exit Ticket

After The Human Sort Race, provide a short pseudocode snippet of a sorting algorithm. Ask students to identify whether it is bubble sort or merge sort, and explain one way it could be improved.

Discussion Prompt

During Search Strategy Showdown, ask each pair to present one key difference they noticed between linear and binary search. Collect these on the board to assess their understanding of input requirements and efficiency.

Quick Check

After Best Case vs Worst Case, give students a partially sorted list and ask them to predict which algorithm will perform best and worst. Collect predictions to check their grasp of best-case versus worst-case scenarios.

Extensions & Scaffolding

• Challenge students to design a hybrid sort combining bubble and merge methods, then test its efficiency on a 1000-item list.
• For students who struggle, provide pre-sorted lists for bubble sort trials to isolate the algorithm’s mechanics from sorting errors.
• Deeper exploration: Ask students to research and compare the time complexity of quicksort versus heapsort, then present findings in a mini-poster session.

Key Vocabulary

Algorithm	A step-by-step procedure or set of rules to be followed in calculations or other problem-solving operations, especially by a computer.
Problem Decomposition	The process of breaking down a complex problem into smaller, more manageable sub-problems that are easier to solve individually.
Computational Thinking	A problem-solving process that involves formulating problems and their solutions in a way that a computer can effectively carry out.
Pseudocode	An informal, high-level description of the operating principle of a computer program or other algorithm, using natural language conventions rather than a formal programming language.
Flowchart	A diagram that represents a workflow or process, showing the steps as boxes of various shapes and their order by connecting the boxes with arrows.