Computing · Secondary 4

Active learning ideas

Introduction to Data Structures: Arrays

Active learning works for arrays because students need to visualize memory organization and practice index manipulation to internalize abstract concepts. When students build, modify, and debug arrays themselves, they move from passive reading to active problem-solving, which strengthens retention and confidence.

• MOE Syllabus Outcomes
• MOE: Data Structures - S4
• MOE: Programming - S4

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

Activity 01

• Concept Mapping
• 35 min · Pairs

Pair Programming: Score Array Analyzer

Pairs declare a 1D array for class test scores and a 2D array for scores by subject. They code loops to find averages, highest values, and display formatted grids. Pairs test edge cases like empty arrays and swap code for review.

Explain how arrays provide an organized way to store multiple pieces of data.

Facilitation Tip

During Pair Programming: Score Array Analyzer, circulate to ensure both students share the keyboard and verbalize decisions, not just one coding while the other observes.

What to look for

Present students with a pre-written code snippet that declares and initializes a one-dimensional array. Ask them to predict the output if the code attempts to access index 5 in an array of size 5. Ask: 'What error message might occur and why?'

• Understand
• Analyze
• Create
• Self-Awareness
• Self-Management

Activity 02

• Concept Mapping
• 45 min · Small Groups

Small Groups: Grid Puzzle Solver

Groups build a 2D array as a puzzle grid with numbers. They write code to search rows and columns for sums matching a target, rotate elements, and validate solutions. Groups present one solved puzzle to the class.

Compare the use cases for one-dimensional versus two-dimensional arrays.

Facilitation Tip

In Small Groups: Grid Puzzle Solver, provide graph paper or digital grids for students to draw out how 2D arrays map to physical grids, reinforcing the concept of rows and columns.

What to look for

Pose the scenario: 'Imagine you are building a simple checkerboard game. Would you use a one-dimensional or a two-dimensional array to represent the board? Justify your choice by explaining how you would access specific squares.'

• Understand
• Analyze
• Create
• Self-Awareness
• Self-Management

Activity 03

• Concept Mapping
• 25 min · Individual

Individual: Scenario Array Builder

Students select a real scenario, such as inventory tracking, and code appropriate 1D or 2D arrays. They add input functions, update values, and output summaries. Submit code with a written justification for array choice.

Construct a scenario where an array is the most suitable data structure.

Facilitation Tip

For Individual: Scenario Array Builder, set a strict 10-minute timer for scenario writing so students focus on clear, concise data representation before coding.

What to look for

Provide students with a small dataset, such as a list of student names and their corresponding test scores. Ask them to write down: 1. How they would declare a one-dimensional array to store the scores. 2. The index they would use to access the score of the third student.

• Understand
• Analyze
• Create
• Self-Awareness
• Self-Management

Activity 04

• Concept Mapping
• 30 min · Whole Class

Whole Class: Live Array Debugger

Display buggy array code on the projector. Class suggests fixes for index errors or traversal issues step by step. Vote on solutions and run collectively to verify outputs.

Explain how arrays provide an organized way to store multiple pieces of data.

Facilitation Tip

During Whole Class: Live Array Debugger, intentionally include a common off-by-one error in the pre-written code so the class can collaboratively trace and fix it.

What to look for

Present students with a pre-written code snippet that declares and initializes a one-dimensional array. Ask them to predict the output if the code attempts to access index 5 in an array of size 5. Ask: 'What error message might occur and why?'

• Understand
• Analyze
• Create
• Self-Awareness
• Self-Management

A few notes on teaching this unit

Teach arrays by starting with physical manipulatives like index cards in envelopes to represent memory slots, then transition to code. Avoid abstract explanations without concrete examples, as students often confuse the concept with lists or dynamic containers. Research shows that pairing visualization with coding tasks improves spatial reasoning about indices and memory layout.

Successful learning shows when students can declare, initialize, and traverse arrays without errors, explain why indices start at zero, and choose the correct dimensionality for real-world data. They should also trace code paths and predict outputs before execution.

---

Watch Out for These Misconceptions

• During Pair Programming: Score Array Analyzer, watch for students who try to store mixed data types in the same array, such as both names and scores.

  Redirect the pair by asking them to define the data type before coding. Have them open their pseudocode and cross out any non-uniform entries, then restart with a clear type definition like 'int[] scores'.

• During Small Groups: Grid Puzzle Solver, watch for students who assume array indices start at 1 when accessing grid cells.

  Have the group trace their code on a drawn grid, numbering cells starting at 0. Ask them to predict the output for index 0 and index 4 in a 5x5 grid, then run the code to verify.

• During Scenario Array Builder, watch for students who treat 2D arrays as independent 1D arrays rather than an array of arrays.

  Ask students to draw their array as nested boxes on paper. Discuss how the outer array holds inner arrays as elements, then have them rewrite their code to reflect this structure.

---

Methods used in this brief

• Concept Mapping