Technologies · Year 7

Active learning ideas

Algorithm Efficiency and Optimization

Active learning works for algorithm efficiency because students need to feel time and memory trade-offs in their hands. When students physically sort cards or trace paths on grids, they move from abstract ideas to measurable outcomes, building lasting intuition about why some algorithms outperform others.

• ACARA Content Descriptions
• AC9TDI8P02

• 25–45 min
• Pairs → Whole Class
• 4 activities

Activity 01

• Decision Matrix
• 35 min · Pairs

Sorting Race: Bubble vs Insertion

Provide decks of 20 numbered cards to pairs. Have them perform bubble sort then insertion sort, timing each and counting swaps. Pairs graph results and propose one optimization, testing it against originals.

Evaluate two different algorithms designed to solve the same problem for efficiency.

Facilitation Tip

During Sorting Race, have students time each sort twice with different list sizes so they observe scaling effects firsthand.

What to look for

Present students with two simple algorithms for the same task, like finding the largest number in a list. Ask them to count the number of steps each algorithm takes for a small input (e.g., 5 numbers) and identify which is more time efficient. 'Algorithm A takes X steps, Algorithm B takes Y steps. Which is faster and why?'

• Analyze
• Evaluate
• Create
• Decision-Making
• Self-Management

Activity 02

• Decision Matrix
• 30 min · Small Groups

Maze Path Optimization

Draw 5x5 grid mazes on paper. Students trace two paths from start to end: direct count steps, then shortest path by removing obstacles. Groups compare time and space, redesign for efficiency.

Predict how changes to an algorithm might impact its performance.

Facilitation Tip

For Maze Path Optimization, ask students to mark each dead-end path to reveal why fewer steps matter.

What to look for

Pose a scenario: 'Imagine an app that sorts photos by date. If we change the sorting method from checking every photo to a more efficient one, what might happen to the app's speed? What if we used more memory to store photo data for quicker access?' Facilitate a discussion on predicted impacts.

• Analyze
• Evaluate
• Create
• Decision-Making
• Self-Management

Activity 03

• Stations Rotation
• 45 min · Small Groups

Stations Rotation: Algorithm Comparisons

Set stations for linear search (find number in unsorted list), binary search (sorted list), and space check (list copies). Groups rotate, record metrics, discuss winners.

Design an optimized version of a given inefficient algorithm.

Facilitation Tip

In Station Rotation, rotate roles every three minutes so all students compare algorithms from multiple perspectives.

What to look for

Provide students with a pseudocode example of an inefficient algorithm (e.g., a nested loop for a simple search). In pairs, students analyze the algorithm for inefficiency. They then swap their analysis and suggest one specific change to optimize it, explaining their reasoning.

• Remember
• Understand
• Apply
• Analyze
• Self-Management
• Relationship Skills

Activity 04

• Decision Matrix
• 25 min · Individual

Code Walkthrough Challenge

Print inefficient pseudocode for summing arrays. Individuals trace execution on paper, count operations. Share findings in whole class, vote on group optimizations.

Evaluate two different algorithms designed to solve the same problem for efficiency.

Facilitation Tip

During Code Walkthrough Challenge, require students to annotate each loop with a step count before redesigning.

What to look for

Present students with two simple algorithms for the same task, like finding the largest number in a list. Ask them to count the number of steps each algorithm takes for a small input (e.g., 5 numbers) and identify which is more time efficient. 'Algorithm A takes X steps, Algorithm B takes Y steps. Which is faster and why?'

• Analyze
• Evaluate
• Create
• Decision-Making
• Self-Management

A few notes on teaching this unit

Teachers should emphasize that efficiency is about trade-offs, not absolute speed. Students often think faster code is always better, so use physical simulations to make invisible costs visible. Avoid rushing to abstract pseudocode; let students experience inefficiency before optimizing. Research shows that tracing and timing concrete examples builds stronger mental models than early abstraction.

Successful learning shows when students can articulate trade-offs between time and space, identify inefficiencies in code, and justify small optimizations with evidence. They move from guessing to measuring steps and memory, explaining results in clear terms to peers.

---

Watch Out for These Misconceptions

• During Sorting Race, watch for students who assume bubble sort always wins because it looks simpler.

  Pause the race and have students count steps for both sorts on a 10-item list to reveal bubble sort’s quadratic growth compared to insertion sort’s linear performance on nearly sorted lists.

• During Maze Path Optimization, watch for students who think fewer turns automatically mean faster paths.

  Have students time their paths with a stopwatch and compare steps to distance, redirecting them to measure both criteria explicitly.

• During Station Rotation, watch for students who believe all algorithms scale the same way regardless of input size.

  Ask each group to test their algorithm with 5, 10, and 20 items, then graph the results to expose nonlinear scaling patterns.

---

Methods used in this brief

• Decision Matrix
• Stations Rotation