Decomposition: Breaking Problems into Sub-Problems

This lesson covers decomposition in detail, as required by OCR J277 Section 2.1. Decomposition is one of the four key components of computational thinking and is often the first step in solving any complex problem.

---

What Is Decomposition?

Decomposition is the process of breaking a complex problem down into smaller, more manageable sub-problems. Each sub-problem can then be understood, solved, and tested individually before being combined into a complete solution.

Think of decomposition like building a house:

• You do not try to build an entire house in one step.
• You break it into sub-tasks: foundations, walls, roof, plumbing, electrics, decoration.
• Each sub-task can be assigned to specialists and completed independently.
• When all sub-tasks are complete, the house is finished.

---

Why Is Decomposition Important?

Reason	Explanation
Makes problems manageable	Smaller sub-problems are easier to understand and solve than one large, complex problem
Enables teamwork	Different people or teams can work on different sub-problems simultaneously
Facilitates testing	Each sub-problem can be tested independently, making it easier to find and fix errors
Promotes code reuse	Solutions to common sub-problems can be reused in other projects
Improves clarity	A decomposed problem is easier to communicate to others

OCR Exam Tip: When asked why decomposition is important, always mention that it makes complex problems easier to solve by breaking them into smaller parts. Also mention that it allows different sub-problems to be worked on independently and tested separately.

---

Decomposition in Practice

Example 1: Creating a Computer Game

A student wants to create a simple quiz game. Without decomposition, this is one big, overwhelming task. With decomposition:

Sub-Problem	Detail
User interface	Design the screen layout, buttons, and text display
Question storage	Decide how to store questions and answers (list, file, database)
Displaying questions	Write code to show questions one at a time
Getting user input	Write code to accept the user's answer
Checking answers	Compare the user's answer to the correct answer
Scoring	Keep track of the score and display it
Feedback	Tell the user if they are right or wrong
End of game	Display the final score and offer to play again

Each of these sub-problems can be solved independently and then combined to create the complete game.

Example 2: Online Shopping System

Main Problem	Sub-Problems
Build an online shop	Browse products, search products, add to basket, manage basket, create account, log in, enter delivery address, process payment, confirm order, send email confirmation, update stock levels

Example 3: School Registration System

Main Problem	Sub-Problems
Build a registration system	Take the register (present/absent/late), store attendance data, calculate attendance percentages, generate reports for form tutors, send alerts for persistent absence, display attendance on student profiles

---

Levels of Decomposition

The following tree diagram illustrates how a complex problem is decomposed into sub-problems:

graph TD
    A["Create a Quiz Game"] --> B["User Interface"]
    A --> C["Question Handling"]
    A --> D["Scoring"]
    B --> B1["Design question screen"]
    B --> B2["Design results screen"]
    B --> B3["Design main menu"]
    C --> C1["Load questions from file"]
    C --> C2["Randomise order"]
    C --> C3["Display question"]
    D --> D1["Track correct answers"]
    D --> D2["Calculate percentage"]
    D --> D3["Display final score"]

Decomposition can happen at multiple levels. A sub-problem can itself be decomposed further:

Level 1: Create a quiz game

• Level 2: User interface
  • Level 3: Design question screen
  • Level 3: Design results screen
  • Level 3: Design main menu
• Level 2: Question handling
  • Level 3: Load questions from file
  • Level 3: Randomise question order
  • Level 3: Display question and options
• Level 2: Scoring
  • Level 3: Track correct answers
  • Level 3: Calculate percentage
  • Level 3: Display final score

This hierarchical decomposition can be represented as a structure diagram (which we will cover in a later lesson).

---

Decomposition and Subprograms

In programming, decomposition leads naturally to the use of subprograms (functions and procedures):

Decomposed Sub-Problem	Subprogram
Display a question	displayQuestion()
Check the answer	checkAnswer()
Update the score	updateScore()
Show the final result	showResult()

Each subprogram handles one specific task, making the code:

• Easier to read — Each subprogram has a clear purpose
• Easier to test — Each subprogram can be tested independently
• Easier to debug — Errors are isolated to specific subprograms
• Reusable — Subprograms can be used in other programs

---

How to Decompose a Problem

Follow these steps:

1. Understand the problem — What is the overall goal? What are the inputs and outputs?
2. Identify the main tasks — What are the major steps needed to solve the problem?
3. Break each task into sub-tasks — Can each main task be broken down further?
4. Identify dependencies — Which sub-tasks depend on others? What order should they be completed in?
5. Consider reusable components — Are any sub-tasks similar to problems you have solved before?

OCR Exam Tip: In the exam, you may be given a scenario and asked to decompose it into sub-problems. List each sub-problem clearly and make sure they are specific (not vague). For example, "process payment" is better than "do the money bit." If appropriate, show multiple levels of decomposition.

---

Common Exam Question: Decompose This Problem

Question: A school wants to create a system to manage library book loans. Decompose this problem into sub-problems.

Answer:

1. Search for a book (by title, author, or ISBN)
2. Check if the book is available (in stock or already on loan)
3. Record a loan (link the book to the borrower with the loan date)
4. Set a return date (calculate the due date)
5. Record a return (update the system when a book is returned)
6. Send overdue reminders (check for loans past the return date)
7. Manage borrower accounts (add, edit, delete borrower records)
8. Generate reports (most popular books, overdue books, borrower history)

---

Summary

Decomposition is the process of breaking complex problems into smaller, manageable sub-problems. It is the essential first step in computational thinking and leads directly to well-structured programs. Each sub-problem can be solved, tested, and debugged independently. For the OCR J277 exam, practise decomposing real-world problems into clear, specific sub-problems.

---

Worked Example: Decomposing a Cinema Ticket Booking System

Scenario: A small independent cinema wants to build a web-based ticket booking system. Customers should be able to browse films, choose a showing, select seats, pay, and receive a digital ticket. Staff should be able to add films, set showing times, and view sales reports. The owner has never commissioned a piece of software before and has given the developers only this one paragraph of description — so the first job is to turn that paragraph into a structured decomposition that the team can actually build from.

Step 1 — State the overall goal clearly. Build a ticket booking system for a cinema, usable by both customers and staff, that handles browsing, booking, payment, and reporting.

Step 2 — Identify the top-level sub-systems. Before listing tasks, split the system by major responsibility: