L1 Comprehension Questions

1. Short Answer: Define abstraction in your own words and explain why it is important in problem-solving.

2. Short Answer: List two examples of abstraction in user interface design and explain their significance.

3. Long Answer: Describe how abstraction is used in sat-navs. Include examples of what is shown and what is omitted.

4. Short Answer: Explain how flowcharts demonstrate abstraction in program design.

5. Long Answer: Discuss how abstraction simplifies the use of variables and calculations in programming. Why is this helpful for programmers?

L2 Comprehension Questions

1. Short Answer: Define decomposition and explain why it is important in computational thinking.

2. Short Answer: Provide two examples of decomposition in daily life and describe how they simplify tasks.

3. Long Answer: Explain how decomposition can be applied to designing a game like "Breakout." Include at least four sub-tasks.

4. Short Answer: List two advantages of decomposition in programming and explain why they are beneficial.

5. Long Answer: Discuss how decomposition allows teams to work more efficiently and speeds up development time. Provide an example to illustrate your answer.

Lesson Activities

Activity 1: Identify Inputs, Processes, and Outputs

For each of the following scenarios, identify the inputs, processes, and outputs:

1. A program calculates the area of a rectangle given its length and width.

2. A program takes a number as input and determines whether it is even or odd.

3. A program collects daily temperatures for a week and calculates the average temperature.

Activity 2: Design and Analyze

Write short, logical explanations (not code) for these tasks:

1. Design a program that asks the user for the dimensions of a cylindrical water tank and calculates its volume.

2. Create a process for collecting students’ test scores and reporting the highest score.

3. Explain the steps involved in creating a program that converts temperature from Celsius to Fahrenheit.

Comprehension Questions

1. Short Answer:

   • Define inputs, processes, and outputs in your own words.

   • Why is it important to identify inputs, processes, and outputs before writing a program?

2. Scenario-Based Question:

   • Given the task of calculating the area of a circle, describe the inputs, processes, and outputs required.

3. Long Answer:

   • Discuss the importance of clearly identifying inputs, processes, and outputs in the context of exam scenarios. Provide an example to illustrate your point.

Challenge Activity

Write a structured plan (inputs, processes, outputs) for a program that:

• Asks the user for three exam scores.

• Calculates the average of the scores.

• Outputs a message indicating if the average score is above or below a pass mark of 50%.

Reflection

Why do you think breaking a problem into inputs, processes, and outputs makes programming easier? Write 2-3 sentences summarizing your thoughts.

Extension Task for L3: Inputs, Processes & Outputs 

1. Imagine you are designing a program for a beachside dive shop to help customers rent scuba diving equipment. The program will calculate the total cost of equipment rental based on the customer's requirements. This is a planning task not a programming task.

2. Using your knowledge of inputs, processes, and outputs, create a structured plan for this program.

3. Steps to Complete:

   • Identify the inputs the program will need. Think about the types of equipment, rental duration, and customer information.

   • Define the processes the program must perform. Include calculations for total cost based on the equipment type and rental duration.

   • Determine the outputs the program will produce.This might be a total cost summary and rental details.

4. Write Your Plan:

   • Inputs: List all the data the user will provide.

   • Processes: Explain what the program will calculate or determine.

   • Outputs: Describe the results the user will see.

5. After I have approved your plan, you can begin programming your idea.

Note-taking Guide

1. Title Section

   • Add the title: L4 - Representing Algorithms.

2. Key Terms Section

   • Create a section titled Key Terms.

   • Define each of the following: Algorithm, Pseudocode, Flowchart.

   • Add a small example or illustration for each term.

3. Pseudocode Section

   • Title this section Pseudocode.

   • Write what pseudocode is and why it’s useful.

   • Copy a pseudocode example and break it down in your own words.

4. Flowchart Section

   • Title this section Flowchart.

   • Using shapes in your slide, draw flowchart symbols (oval, rectangle, parallelogram, diamond) and label their purposes.

   • Include an example flowchart for a simple algorithm and explain it.

5. Comparison Section

   • Create a section titled Pseudocode vs. Flowchart.

   • Make a table comparing the two methods (e.g., how they’re written, how they’re used).

6. Reflection Section

   • Add a section titled Reflection.

   • Answer these questions:

     • Which method do you find easier to understand?

     • When might you use a flowchart instead of pseudocode?

Lesson Activities

Activity 1: Explore Real-Life Algorithms

• Think of a real-life process you do daily (e.g., brushing your teeth, getting dressed).

• Identify the input, process, and output of that activity.

Comprehension Questions

1. Why is it important to represent algorithms visually or in text form?

2. How do flowchart symbols help make algorithms easier to understand?

Rewrite this pseudocode to include additional temperature descriptions (cool, warm, very hot):

START  

INPUT temperature  

IF temperature < 0 THEN  

    OUTPUT "Freezing"  

IF temperature > 30 THEN  

    OUTPUT "Hot"  

ELSE  

    OUTPUT "Moderate"  

STOP  

Extension Tasks

1. Group Challenge

Work in pairs to design an algorithm and a flowchart for a vending machine:

• Input: Money and item selection.

• Process: Check if enough money is inserted and dispense the item.

• Output: The selected item and change (if any).

2. Reflection

1. How would you explain the steps of creating a flowchart to a younger student?

2. Which algorithm representation (pseudocode or flowchart) would you use if you were designing a new app? Why?

3. Program Design

Create an algorithm and a flowchart for a program that calculates the area of different shapes (e.g., circle, square, rectangle).

• Ask the user which shape they want to calculate.

• Use a decision step to choose the correct formula for the shape.

• Output the calculated area.

L5 Note-taking Guide

Create a clear and comprehensive set of revision notes on linear and binary search algorithms using Google Slides. 

1. Title Section

   • Add the title: Lesson 5 - Searching Algorithms.

2. Key Terms Section

   • Create a section titled Key Terms.

   • Define the following terms in your own words: Searching Algorithm, Linear Search, Binary Search, Dataset, Efficiency.

3. Linear Search Section

   • Title this section Linear Search.

   • Describe how linear search works.

   • Include a simple example of a linear search in a list, explaining each step.

4. Binary Search Section

   • Title this section Binary Search.

   • Describe how binary search works.

   • Explain why binary search only works on sorted datasets.

   • Include a simple example of a binary search and show the steps to find a number.

5. Comparison Section

   • Create a section titled Linear vs. Binary Search.

   • Make a table comparing the two algorithms (e.g., speed, dataset type, ease of use).

6. Example Section

   • Title this section Searching Example.

   • Create a simple list of numbers (e.g., [3, 7, 12, 19, 23]).

   • Write out the steps of both a linear search and a binary search to find the number 12.

7. Reflection Section

   • Add a section titled Reflection.

   • Answer the following questions:

     • Which search algorithm do you think is better for large datasets? Why?

     • When might you choose linear search instead of binary search?

     • What is the most important thing you learned in this lesson?

L5 Activities

Comprehension Questions

Use these questions to check and reinforce understanding of linear search and binary search, as well as general algorithmic thinking.

1. What is the difference between linear search and binary search?

2. Why can binary search only be used on sorted data?

3. Which search algorithm is generally faster for large datasets and why?

4. Explain the terms input, process, and output in the context of a search algorithm.

5. When would you choose linear search over binary search.

Extension Activities

Each activity focuses on producing and visualizing an algorithm in different formats. The goal is to understand and communicate how searching algorithms work.

Activity 1: Text-Based Description of the Algorithm

1. Choose either linear search or binary search (or both).

2. Write a short paragraph that explains how the algorithm works step by step, in your own words (no code, just a plain English explanation).

   • For example, describe how you would find 12 in the list [3, 7, 12, 19, 23] using linear search.

   • Include what happens when the target is found (or when the list ends without finding it).

Activity 2: Pseudocode

1. Using standard pseudocode conventions, write the algorithm you chose in a structured, step-by-step format.

2. Your pseudocode should include:

   • Start and Stop (or Begin/End)

   • Inputs (target and dataset)

   • Loops and Conditions (e.g., IF, ELSE, WHILE, etc.)

   • Outputs (“Found” or “Not Found”)

Activity 3: Flowchart

1. Create a flowchart to represent either linear or binary search.

2. Use standard flowchart symbols (oval for start/end, parallelogram for input/output, rectangle for process, diamond for decisions).

3. Ensure your flowchart clearly shows:

   • The decision points (e.g., “Is dataset[mid] = target?”)

   • The looping (going back to keep searching)

   • The output (“Found” or “Not Found”)

Tip: Draw the flowchart using shapes in your Slide. Focus on making it easy to follow.

Activity 4:

1. Write a short program (in pseudocode or a real language like Python) that does the following:

   1. Asks the user for a list of numbers (ensure the list is sorted).

   2. Asks the user for a target number to search for.

   3. Implements both linear search and binary search to find the target.

   4. Counts how many steps each search took.

   5. Outputs one of the following:

      • “Linear Search: Found in X steps”

      • “Binary Search: Found in Y steps”

      • “Not Found” (if the target doesn’t exist in the list)

2. Reflect on which algorithm found the target faster and why.

1. Design a Lost Item Finder

Objective: Use abstraction, decomposition, and searching algorithms to solve a real-world problem.

Scenario: You lost your favorite book in your house, and you need a way to find it quickly. Design an algorithm to locate the book.

Instructions:

1. Abstraction

   • What are the key details? (e.g., the rooms to search, the book's description)

   • Ignore unnecessary details like what other items are in the rooms.

2. Decomposition

   • Break the task into smaller steps (e.g., "Check one room at a time").

3. Algorithm Representation

   • Create a flowchart or write pseudocode to show the steps in your algorithm.

4. Searching Algorithm:

   • Decide if you will use a linear search (searching one room at a time) or a binary search (if rooms are numbered and sorted).

5. Test the Algorithm:

   • Use an input-process-output table to show how your algorithm works step by step.

2. Create a Grocery Shopping Helper

Objective: Represent a process with pseudocode, flowcharts, and IPO tables.

Scenario:
Your friend keeps forgetting groceries when shopping. They want a program that checks their list to see if they bought all the items.

Instructions:

1. Inputs:

   • The grocery list (input from the user).

   • Items purchased.

2. Processes:

   • Compare the items purchased to the grocery list.

   • Identify missing items.

3. Outputs:

   • List of items still needed.

4. Tasks:

   • Draw a flowchart to represent the steps.

   • Write pseudocode to describe the algorithm.

   • Use an input-process-output table to show how the algorithm will work with sample data.

3. Plan a School Timetable Generator

Objective: Apply abstraction and decomposition to design a solution.

Scenario:
The school needs a program to generate a timetable for students with no overlapping lessons.

Instructions:

1. Abstraction:

   • Focus on the key details: classes, times, and available rooms.

2. Decomposition:

   • Break the problem into smaller tasks:

     • Collect inputs (class names, times, rooms).

     • Assign classes to times and rooms.

     • Check for overlaps.

3. Algorithm Representation:

   • Write pseudocode to represent the solution.

   • Use a flowchart to visualize the steps.

4. Final Task:

   • Create a small test with two students and two overlapping lessons.

   • Use an IPO table to show how the algorithm resolves the conflict.

4. Emergency Call Sorting

Objective: Practice binary and linear search.

Scenario:
An emergency call center needs to quickly find a caller's location based on a sorted list of addresses.

Instructions:

1. Binary Search:

   • Write pseudocode for a binary search algorithm to find a specific address.

   • Draw a flowchart to illustrate the steps.

2. Linear Search:

   • Write pseudocode for a linear search to achieve the same goal.

3. Compare Efficiency:

   • Explain when each search method would be better (e.g., for small or large datasets).

4. Test the Algorithm:

   • Use an input-process-output table to test both algorithms with a sample list of addresses.

5. Solve a Travel Planner Problem

Objective: Use algorithms to plan a trip.

Scenario:
You need to visit 5 cities and want the shortest route. Plan an algorithm to calculate this.

Instructions:

1. Abstraction:

   • Focus only on cities, distances, and a starting point.

2. Decomposition:

   • Break the task into smaller steps:

     • Input cities and distances.

     • Compare routes.

     • Choose the shortest.

3. Algorithm Representation:

   • Write pseudocode to solve the problem.

   • Use a flowchart to visualize the steps.

4. Bonus Challenge:

   • How could you improve this algorithm if there were more cities?