Teacher mode

Decomposition means breaking a big problem into smaller problems. Each small problem is easier to understand and solve on its own. Solve all the small ones and the big problem is solved too.

1. Which steps are about getting things out, before anything is cut?
2. Washing, slicing and grating all change the food itself. They belong together.
3. Pixel has put one step in the right place for you. Find the others like it.

Gather: bread, cheese and tomato, knife and plate. Prepare: wash the tomato, slice it, grate the cheese. Put together: lay the fillings, add the top slice, cut in half.

A big task like getting ready for school is made of smaller tasks. Some small tasks depend on others, so those must happen first. Others can go in any order.

1. Which task has to come before every other task?
2. Look for pairs: shower before getting dressed, breakfast before brushing your teeth.
3. Pixel has put one task in its place. Work outwards from it.

One correct order: wake up, shower, get dressed, breakfast, brush teeth, pack bag, shoes and coat, leave. Packing can go anywhere after waking and before leaving.

When something complicated breaks, split the problem by its parts. Each part can then be tested and fixed on its own. Engineers call this working on one sub-system at a time.

1. Look at the robot picture: which part does each job touch?
2. Cameras, microphones and distance sensors are how a robot senses the world.
3. Pixel has sorted one job. Batteries, fuses and cables all bring power.

Sensors: camera lens, distance sensor, microphone. Power: battery, fuse, cable. Movement: wheel, motor, axle.

A structure diagram shows a problem at the top and its sub-problems underneath. Each sub-problem splits into smaller tasks below it. Reading across can also show the order the work happens in.

1. What has to be built first, so the house does not sink?
2. Painting and carpets come last, once the walls, pipes and wires are in.
3. Pixel has placed one card for you. Look for the card that goes with it.

Ground work: dig trenches, pour foundations. Walls and roof: brick walls, roof. Pipes and wires: water pipes, electric cables. Finishing: paint, carpets. Leave out the holiday and the goldfish.

Big projects are split into sub-problems that different people can work on. Each person focuses on one part, at the same time as everyone else. The parts still fit back together into one plan.

1. Which jobs are about getting there, which about money, and which about keeping everyone safe?
2. Consent forms and allergy checks keep students safe. A budget and payments are about money.
3. Pixel has sorted one job for you. Each part has exactly three jobs.

Transport: coach, journey time, where the coach stops. Money: cost, payments, lunch budget. Safety: consent forms, medical needs, risk assessment. Timetable: galleries, lunch, leaving time. Answer: different people can work on smaller problems at the same time.

A car factory decomposes making a car into stations along a line. Each station does one smaller job, in an order that works. If one station gets its job wrong, the car comes out wrong.

1. What has to exist before you can paint it?
2. The engine and wheels go in after painting. Testing always comes last.
3. Pixel has placed one card for you. Every station gets two jobs.

Order: body shop, paint shop, engine and wheels, quality check. Body: weld panels, doors and bonnet. Paint: base coat, clear coat. Engine and wheels: engine, wheels. Check: brakes and lights, paint inspection.

A tricky mission is easier as a list of sub-goals, solved one after another. Each sub-goal is a small problem with a clear finish line. Some sub-goals must come before others, so the order matters.

1. Look at the map: what is stopping you from reaching Pixel?
2. The gate needs the key, and you can only lead Pixel out after you have reached Pixel.
3. Pixel has put the first sub-goal in place. What does that let you do next?

Plan: get the key, unlock the gate, reach Pixel, lead Pixel to the exit. Leave out the coins and visiting every room.

Real games are made by teams, each working on one part. The game is decomposed into parts like graphics, sound and code. Each part is then given to the person with the right skills.

1. Which cards are parts of a game, and which are just distractions?
2. Every part has exactly two tasks. Jump physics and scoring are both programming.
3. Pixel has placed one card for you.

Graphics: player, scenery (artist). Sound: theme tune, sound effects (sound designer). Level design: platforms, enemies and coins (level designer). Game code: jump physics, scoring (programmer). Testing: play-test, fix bugs (tester).

Complex missions are decomposed into sub-problems, and those into smaller tasks. Each team solves its sub-problem, and the mission runs them in order. If a sub-problem is missing, the mission fails at that point.

1. What has to happen first in any space mission?
2. Parachutes and landing rockets belong to one sub-problem. Antennas and photos belong to another.
3. Pixel has placed one card for you. Every sub-problem needs three tasks.

Launch: countdown, boosters, orbit. Navigation: route, thrusters, stars. Landing: parachute, landing rockets, touch down. Communication: antenna, photos, commands. Leave out the paint job, party, theme song and souvenirs.

Expert decomposition means choosing the sub-problems yourself. A good sub-problem is a meaningful part of the goal, and every task sits under exactly one of them. Anything that does not help solve the problem is left out.

1. Think about before, during and after the run: what has to be organised?
2. The four big parts are safety, money, publicity and the day itself.
3. Pixel has placed one card for you.

Route and safety: route, first aiders, marshals. Raising money: sponsorship forms, online page, bank the money. Publicity: posters, assembly, newsletter. On the day: start line, water, medals. Leave out the minibus, timetable, staff room, juggling, textbooks and goalposts.

Abstraction means hiding the details you do not need, so you can focus on the ones that matter. Which details matter depends on the job you are doing. The same scene can be simplified in different ways for different jobs.

1. Read the job again. Would the job still work without this detail?
2. Each job needs only two of the details. Everything else is extra.
3. Pixel has sorted one detail for you. Use it as a clue for the rest.

League table: keep the team names and the final score. A new fan: keep the ground and the kick-off time. Every other detail is removed both times.

A good description keeps only the details that make one thing different from all the others. Saying a teddy is soft does not help, because every teddy is soft. Choosing the few details that matter is abstraction.

1. Look at the line-up. Which details does your teddy share with lots of other teddies?
2. A detail only helps if some of the teddies do not have it.
3. Pixel has put one useful detail on the poster for you.

Biscuit: brown fur, a red bow and a patch over one eye (all three are needed). Pickle: a blue scarf with either brown fur or the eye patch.

A map is an abstraction of a real place. It keeps what helps you find your way, like roads and landmarks, and leaves out cars, people and clouds. Map makers also swap real buildings for simple symbols.

1. Will this thing still be in the same place tomorrow?
2. A walking map needs the start, the finish and a way between them, including any crossing.
3. Pixel has sorted one layer for you.

Keep the roads, the station, the library, and the river with its bridge. Remove cars, people, trees, clouds, birds and adverts. The library's symbol is a simple open book.

An app icon is tiny, so it must keep only the shapes that say what the app does. Small details like writing, scratches and shine turn into blurry dots when the icon shrinks. Designers abstract a real object down to one or two bold shapes.

1. Look at the 16-pixel preview. Which parts have turned into blur?
2. Keep only the shapes you would draw if you had three seconds.
3. Pixel has removed one detail for you.

Camera app: keep the body and the lens, and remove the brand name, dials, strap, scratches, reflections and shadow. Music app: keep only the musical note.

A robot cannot see the world as you do: it only knows the readings its sensors give it. Those readings are an abstraction of the real object. Good sensor choices keep exactly the readings that tell things apart.

1. Find two items in different bins that your sensors cannot tell apart.
2. The red cup and the red can look the same to a camera. What is really different about them?
3. Pixel has fitted one of the right sensors for you.

Fit the metal detector, the water drop test and the squash test. Mystery items: beeps means metal, goes soggy means paper, stays rigid means glass, and the rest is plastic.

A satnav does not store every house and tree. It stores junctions, the roads between them and how many minutes each road takes: an abstraction called a graph. With just that, it can work out the quickest route.

1. Add up the minutes on each road you use. The lowest total wins.
2. A route that looks short on screen is not always quick. Trust the minutes, not the distance.
3. Pixel has driven the first road of the quickest route for you.

Round 1: Home, A, B, C, Cinema (17 minutes). Round 2, with B to C closed: Home, Park, C, Cinema (18 minutes). Round 3, via School: Home, A, School, E, Cinema (22 minutes).

Weather stations record lots of measurements, but each decision only needs a few of them. Hiding the columns you do not need is abstraction for data. It makes the pattern easier to see and the decision quicker.

1. Read the rule word by word. Which columns does each part of it talk about?
2. Careful: 'pressure falling' is about the trend, not the number, and 'temperature' is not 'feels like'.
3. Pixel has done one step for you.

Rain rule: pressure trend and humidity; rain on Monday and Friday only. Sports day rule: wind speed and temperature; called off on Wednesday, Thursday and Friday.

A model is a simplified version of a real thing that keeps only what matters for its purpose. A phone designed to do everything ends up perfect for no one. Designers start from the user's real needs and leave out everything else.

1. Match each need on the card to one feature. If a feature matches no need, leave it out.
2. Look for the feature that solves the problem directly, not one that is just nice to have.
3. Pixel has fitted one feature for you.

Grandad Joe: big text and buttons, extra-loud speaker, three-day battery, SOS button. Zara: gaming processor, pro video camera, fast charging, drop-proof case.

A database can hold hundreds of records, each with many fields. To answer a question, you use only the fields the question mentions and filter out everything else. Ignoring the rest is abstraction at work.

1. Find the facts in the clue. Each fact is one filter.
2. Ignore the columns the clue does not mention, like the cover colour on the first door.
3. Pixel has set a filter for you.

Door 1: Year 8, Monday, March leaves The Silent Server, 198 pages. Door 2: red, Ms Green, March leaves Codebreakers, 251. Door 3: Year 7, sorted by pages, gives Pixel Pirates, 225.

Abstraction lets you build a model: a simple version of a real system that still gives useful answers. You keep the details that change the answer and drop the ones that do not. Then you test whether the same model works in other places too.

1. For each detail, ask: would the answer change if this detail changed?
2. A model works somewhere else if the same few details decide the answer there too.
3. Pixel has done one step of this stage for you.

Stage 1: use the queue, riders per go and minutes per go; waits are Dragon Coaster 20, Log Splash 15, Space Spinner 10 and Ghost Train 25 minutes. Stage 2: the checkout, lunch queue, car wash and lift fit the same model. Stage 3: keep hunger, energy and happiness.

A pattern is something that repeats or changes in a regular way. Once you spot the part that repeats, you can predict what comes next. Computer scientists look for patterns so one rule can solve many problems.

1. Say the pattern out loud: star, moon, star, moon...
2. Find the smallest group that repeats, then keep repeating it.
3. Pixel has filled one gap for you.

Round 1: star, moon. Round 2: apple, banana. Round 3: square, square. The part that repeats is triangle, square, square.

Patterns can be made of colours, sounds or moves, not just shapes. If you know how long the repeating part is, you can work out any position without drawing them all. That saves a lot of work.

1. Count how many beads are in the part that repeats.
2. For a far-away bead, divide its number by the length of the repeating part and look at what is left over.
3. Pixel has filled in one bead for you.

Round 1: yellow, blue, red. Round 2: red and red. Round 3: the repeat is 4 beads long and 20 ÷ 4 = 5, so bead 20 is green.

Number patterns follow a rule, such as 'add 3' or 'double it'. Find the rule by comparing each number with the one before it. Once you have the rule, you can carry on the pattern for ever.

1. Work out the difference between each number and the next.
2. If the differences keep growing, try multiplying instead of adding.
3. Pixel has typed one number for you.

Round 1: 15, 18 (add 3). Round 2: 35, 25 (take away 5). Round 3: 16, 32 (double). The rule is double each time.

Things that share the same key features belong to the same group. Spotting the shared pattern lets you sort things you have never seen before. Look for the features that matter, not the ones that only look similar.

1. Ignore where the animal lives. Look at its body: fur, feathers, gills or scales?
2. A whale and a bat are tricky. What do they feed their babies?
3. Pixel has sorted one animal for you.

Mammals: dog, whale, bat. Birds: penguin, eagle, parrot. Fish: shark, clownfish. Reptiles: snake, crocodile, turtle. The platypus is a mammal.

Dances are full of patterns: the same moves repeat again and again. Spot the repeating moves and you can describe a long dance in a few words, like 'do this 3 times'. Programmers call that a loop.

1. Watch the dance again and say the moves out loud.
2. Find the shortest group of moves that repeats.
3. Pixel has programmed one move for you.

Round 1: lean left, lean right, arms up. Round 2: spin, spin. Round 3: repeat 3 times: lean left, lean left, spin.

The snake's body shows the order it has eaten its fruit, and that order is a pattern. Spot what repeats, then eat the fruit that keeps the pattern going. Eat the wrong fruit and the pattern breaks!

1. Read the snake's body from its tail to its head. Which fruits repeat?
2. The strip above the board shows the fruit eaten so far. What comes after the last one?
3. Pixel has lit up the next fruit for you.

Round 1: banana, apple, banana, apple. Round 2: cherry, grapes, grapes, cherry. Round 3: apple, banana, cherry, apple.

UK traffic lights follow a fixed cycle: red, red and amber, green, amber, then red again. Because the cycle repeats, you can work out what the light will show at any time. A step that breaks the cycle means the light is faulty.

1. Say the cycle out loud: red, red and amber, green, amber, red...
2. One full cycle takes 60 seconds. Take away whole cycles first.
3. Pixel has done one step for you.

Round 1: red and amber, amber, green. Round 2: green (95 seconds is 35 seconds into a 60-second cycle). Round 3: step 7 is the fault; it should be green.

When a program's output should follow a pattern, a value that breaks the pattern points to a bug. Debugging means finding where the pattern breaks, then working out which line caused it. Testing against the pattern you expect catches bugs fast.

1. Compare each value with the one before it. Where does the pattern change?
2. In the code, find the line that makes or controls the numbers. Bugs in a pattern usually live there.
3. Pixel has done one step for you.

Round 1: 26 should be 25. Round 2: the sixth flash should be blue. Round 3: line 2 should be print(i * 2). Round 4: line 2 should be while n > 0.

When lines of code repeat with only a small change, that is a pattern a loop can replace. Find what stays the same and what changes, and use the loop counter for the part that changes. One short loop is easier to read and to fix than many copied lines.

1. Compare the lines. Which part stays the same, and which part changes each time?
2. Use the loop counter i wherever the number changes. To count down, the step is negative.
3. Pixel has filled one gap for you.

Round 1: for i = 1 to 5. Round 2: for i = 1 to 5 with print(7 * i). Round 3: for i = 10 to 6 step -1.

Pattern recognition works everywhere: in shapes, numbers, cycles and code. A pattern master spots the rule, tests it, and uses it to predict. Open the three locks of the Pattern Vault to prove it.

1. Find the rule first: what repeats, or how each item changes from the one before.
2. For the 10th number, count how many steps of the rule it takes to get there from the 1st.
3. Pixel has done one step for you.

Shape lock: orange, orange, then the sixth shape should be yellow. Number lock: 31, then 162. Code lock: for i = 1 to 4 with print(3 * i).

An algorithm is a precise set of steps that solves a problem. The steps must be in the right order, or the result goes wrong. A flowchart shows the steps as boxes joined by arrows, from Start to End.

1. Which step has to happen before all the others?
2. Read your steps from top to bottom like a robot would. Does each step make sense at that moment?
3. Pixel has moved one step into place.

Seed: pot, hole, seed, cover, water. Log in: open, username and password (either order), click Log in, home page. Hands: wet, soap, scrub, rinse, dry.

Computers follow instructions exactly, one at a time, in order. A program for a robot is a sequence of moves, and one wrong move sends it the wrong way. Planning the whole route before you run it is algorithmic thinking.

1. Trace the route with your finger first, one square at a time.
2. Count the squares in each straight line. Each square is one arrow.
3. Pixel has added the next move for you.

Round 1: right, right, down, down, right, right, down. Round 2: down, down, right × 4, down. Round 3: right × 4 (fish), down, down, left × 4, down.

Robots usually turn and move forward rather than moving up, down, left and right. A repeat loop runs the same commands several times, which makes programs shorter. Count carefully: the robot does exactly what you say.

1. Stand up and act it out: which way are you facing after each turn?
2. Look for a group of commands that repeats, and put it inside one repeat block.
3. Pixel has added the next command for you.

Round 1: F, F, R, F, F, L, F, F. Round 2: repeat 4 [F, F, R]. Round 3: repeat 4 [F, R, F, L], then F.

Flowcharts use standard symbols: an oval for Start and End, a parallelogram for input and output, a rectangle for a process, and a diamond for a decision. A decision has two exits, labelled Yes and No, and a loop is an arrow that goes back to a decision.

1. Inputs and outputs use parallelograms, calculations use rectangles, and questions use diamonds.
2. Follow the arrows from Start with a test value. What happens at each box?
3. Pixel has placed one card for you.

Odd or even: Input number, remainder = number MOD 2, decision remainder == 0?, Yes: Output "Even", No: Output "Odd". Count: count = 1, loop while count <= 5?, Output count, count = count + 1.

A pelican crossing is controlled by an algorithm: it waits for the button, then changes the traffic lights and the green man in a safe order. A loop keeps checking the button until someone presses it. If the steps are in the wrong order, people could get hurt, so the order matters.

1. Think about safety: what must happen to the cars before people are told to cross?
2. The loop at box 1 keeps waiting until something happens. What is the crossing waiting for?
3. Pixel has placed one card for you.

Box 1: Button pressed? Box 2: Lights: amber. Box 3: Lights: red. Box 4: Man: green. Box 5: Man: red.

A self-driving car repeats the same check again and again: is there road ahead? A while loop repeats until the car reaches the finish, and if, elseif and else choose what to do each time. One good algorithm should work on every track, not just one.

1. The loop should keep going while the car is NOT at the finish.
2. Check for road ahead first. If there is none, check one side and turn that way; otherwise turn the other way.
3. Pixel has filled one gap for you.

while NOT atFinish(): if roadAhead() then forward() elseif roadOnLeft() then turnLeft() else turnRight(). Checking roadOnRight() and turning right, else left, also works.

Testing means running an algorithm with chosen data and comparing what it does with what it should do. When a test fails, follow the path the data took through the flowchart to find the step that went wrong. Boundary values, like exactly 18, are where bugs often hide.

1. Run the tests first. Which test fails, and what did it output instead?
2. Follow the failing test's data through the flowchart, box by box. Where does it go the wrong way?
3. Pixel has pointed to the broken step for you.

Ticket: change the decision to age >= 18? Count: change the loop to count <= 5? Total: change total = n to total = total + n.

Pseudocode is an algorithm written in structured English that looks like code. OCR's version uses words like if, then, else, endif, for, next, while and endwhile, and = to store a value in a variable. A trace table follows a program line by line to record what each variable holds.

1. Read the pseudocode line by line, as the computer would.
2. In a trace table, change one value at a time, in the order the lines run.
3. Pixel has done one step of this stage for you.

Stage 1: the two inputs (either order), if a > b then, print(a), else, print(b), endif. Stage 2: line 2 should be for i = 1 to 4. Stage 3: x goes 3, 2, 1, 0; total goes 0, 3, 5, 6; the output is 6.

A snake that hunts by itself needs an algorithm: look for food ahead, to the left and to the right, then move. The same few rules, repeated in a loop, can clear any trail of food, but a snake that turns more than twice in a row gets dizzy. Write it once, then test it on every board.

1. Keep looping while NOT all the food is eaten.
2. If there is food ahead, move forward. If not, check one side and turn towards the food.
3. Pixel has filled one gap for you.

while NOT allEaten(): if foodAhead() then forward() elseif foodOnLeft() then turnLeft() else turnRight(). Checking foodOnRight() and turning right, else left, also works.

Good programmers do not just write algorithms: they test them with normal, boundary, invalid and erroneous data, trace them to check every step, and debug anything that goes wrong. This final challenge asks you to do all of that.

1. Use the tests and the trace to see exactly where an algorithm goes wrong.
2. Boundary data sits exactly on the edge of the rule; invalid data is the right type but out of range; erroneous data is the wrong type.
3. Pixel has done one step of this stage for you.

Stage 1: change the decision to mark >= 50? Stage 2: normal 45 and 72; boundary 0 and 100; invalid -5 and 150; erroneous "abc" and "twelve". Stage 3: count goes 0, 0, 2, 2, 6 and the output is 6. Stage 4: line 2 should be if n MOD 2 == 0 then.