15-mark question lab · start here

From daily screen minutes to a class screen-time report.

Build the solution in a sensible order: understand which data is given and which is input, plan the two loops, initialise the trackers, let every student enter their week, total the minutes and count the days over 300, convert each total to hours and minutes, then report the class average and the lowest-week student. Learn the reasoning before revealing the complete program.

2D array inputNested loopsStrict boundary testDIV and MODMinimum tracking15 marks

Learning targets

By the end, you should be able to explain the algorithm before writing it.

Lesson overview

01 · Understand

Identify the two arrays, their shared student index, and why ScreenTime[] is filled by input rather than supplied data.

02 · Construct

Use nested loops to input each student's seven daily minutes, total the week and count the days with strictly more than 300 minutes.

03 · Complete

Convert every weekly total to hours and minutes with DIV and MOD, calculate the class average, and output the student with the lowest weekly screen time.

How Cambridge awards the marks: the mark scheme gives AO2 a maximum of 9 marks and AO3 a maximum of 6 marks. It lists requirements R1–R5, but does not assign a separate fixed mark total to each R requirement. The stage-to-mark links in this guide show alignment, not invented stage marks.

Source question

Read the whole question first

Do not begin coding after the first paragraph. The input requirement, the strictly-more-than-300 boundary, the hours-and-minutes conversion and the lowest-week tracker all shape the structure of your solution.

Question 11 · 15 marks

Cambridge IGCSE Computer Science · 0478/22 · Question 11

Students in a class are recording the amount of time in minutes spent in front of a screen for each day of the week.

The one-dimensional (1D) array StudentName[] contains the names of the students in the class. The two-dimensional (2D) array ScreenTime[] is used to input the number of minutes on each day spent in front of a screen.

The position of each student’s data in the two arrays is the same. For example, the student stored at index 10 in StudentName[] and ScreenTime[] is the same.

The variable ClassSize contains the number of students in the class.

Write a program that meets these requirements:

allows all the students to enter their daily minutes of screen times for the past week
calculates the total number of minutes of screen time for each student in the week
counts, for each student, the number of days with more than 300 minutes of screen time
calculates the average weekly minutes of screen time for the whole class
finds the student with the lowest weekly minutes of screen time
outputs for each student:
- name
- total week’s screen time in hours and minutes
- number of days with more than 300 minutes of screen time
outputs the average weekly minutes of screen time for the whole class
outputs the name of the student with the lowest weekly screen time.

You must use pseudocode or program code and add comments to explain how your code works.

All inputs and outputs must contain suitable messages.

Assume that the array StudentName[] and the variable ClassSize already contain the required data.

You do not need to declare any arrays or variables; you may assume that this has already been done.

Before you move on

These are the five required techniques identified by the Cambridge mark scheme.

Mark-scheme map

Allow every student to input their daily minutes for the past week, using nested iteration and suitable messages.

Total each student's minutes for the week and convert the total to hours and minutes with DIV and MOD.

Count, for each student, the days with more than 300 minutes, testing strictly > 300.

Output each student's name, hours-and-minutes total and high-day count, then the class average weekly minutes.

Track the student with the lowest weekly minutes across the class and output that student's name.

Use the tabs along the top to work through the seven stages. The complete solution is kept in its own tab, and the interactive visualisation is the final tab.

Decode the requirements

Turn the question wording into a sequence of tasks.

R1 · R2 · R3 · R4 · R5

🧠 Step-by-step thinking

Identify the repeated unit. The program must serve every student in the class, so the outer loop runs from student 1 to ClassSize.
Identify the work inside each student. Every student enters seven daily figures, so an inner loop over the seven days fills ScreenTime[StudentCounter, DayCounter].
Separate per-student results from class results. Total, hours-and-minutes conversion and high-day count belong to one student. The class average and the lowest-week student are produced once for the whole class.
Translate command words. “Allows… to enter” means INPUT with messages; “calculates the total” means totalling; “more than 300” means a strictly-greater test; “in hours and minutes” means DIV and MOD; “lowest” means minimum tracking.
Build the order. initialise class trackers → input loop (every student, every day) → student loop → reset → day loop (total, high-day test) → class total and lowest test → convert and output → class summary.

Outer loop: studentsInner loop: seven daysSelection: strictly > 300Tracking: lowest week

❓ Guiding questions – think before revealing

Which phrases tell you the screen times are input, not given?
Which results are per student, and which are for the whole class?
Why is “more than 300” not the same as “300 or more”?

Reveal suggested reasoning

Which phrases tell you the screen times are input, not given? “Is used to input the number of minutes” and “allows all the students to enter their daily minutes” mean your program must contain INPUT statements that fill ScreenTime[,]. Only StudentName[] and ClassSize already hold data.

Which results are per student, and which are for the whole class? The weekly total, the hours-and-minutes conversion and the days-over-300 count are per student. The average weekly minutes and the lowest-week student are class-wide and are output once.

Why is “more than 300” not the same as “300 or more”? “More than” is a strictly-greater test: a day of exactly 300 minutes does not count. Writing >= 300 would wrongly include it and lose the boundary mark.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Let every student enter their week
FOR StudentCounter ← 1 TO ClassSize
    FOR DayCounter ← 1 TO 7
        INPUT ScreenTime[StudentCounter, DayCounter]
    NEXT DayCounter
NEXT StudentCounter

// Process each student's week:
// total, days over 300, hours and minutes
// Track the lowest week across the class

// Output the class summary:
// average weekly minutes, lowest-week student

📖 Detailed explanation

“Is used to input” tells you the 2D array starts empty. The input loop must run before any totals are calculated.

“The position of each student's data is the same” means StudentName[3] owns row 3 of ScreenTime — one student index drives both arrays.

“More than 300” sets the counting boundary at strictly greater, so the operator is >, never >=.

“In hours and minutes” is a conversion requirement: DIV gives the whole hours, MOD gives the leftover minutes.

⚠️ Common mistakes

Treating ScreenTime[] as supplied data and never writing any INPUT statements.
Starting to total while the input phase is still running, before every student has entered their week.
Using >= 300 for the high-day test, which wrongly counts a day of exactly 300 minutes.
Outputting the class average and the lowest-week student inside the student loop, printing them repeatedly.

💡 Exam hack / tip

Underline “is used to input”, “more than 300”, “in hours and minutes” and “lowest”. Those four phrases reveal the whole structure: an input phase, a strictly-greater counting test, a DIV/MOD conversion and a minimum tracker.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · algorithm designR1–R5 · full requirement coverageAO3 · logical orderAO3 · comments explain purpose

This planning stage supports AO2 by identifying the full range of techniques required. It supports AO3 by establishing a logical sequence. These are alignment notes, not separately allocated marks.

Plan the data and identifiers

Choose variables that store exactly what the algorithm needs.

Required data structures

🧠 Step-by-step thinking

Use the given names. StudentName[], ScreenTime[] and ClassSize are supplied by the question — your program must use them exactly.
Note what the question says about declarations. The final bullet says you do not need to declare anything, so spend the time on logic and comments instead.
Add two loop counters. StudentCounter walks the students; DayCounter walks the seven days inside each student's week.
Add the per-student working values. TotalMinutes and HighDays hold the current student's results while their days are processed; Hours and Minutes hold the conversion.
Add the class-wide trackers. ClassTotal, AverageMinutes, LowestTotal and LowestStudent remember results that must survive from student to student.

Given: StudentName[] and ScreenTime[]Counters: two INTEGER loop variablesTrackers: lowest week

❓ Guiding questions – think before revealing

Why do the two arrays share an index?
Which variables must survive from student to student?
Do you need an array to store the per-student results?

Reveal suggested reasoning

Why do the two arrays share an index? The question states that the position of each student's data is the same, so StudentName[i] names the student whose seven figures sit in row i of ScreenTime.

Which variables must survive from student to student? ClassTotal and the lowest-week trackers. They are initialised once, before any student is processed.

Do you need an array to store the per-student results? No. Each student's results are converted and output as soon as their week is finished, so simple variables are enough — the totals are never needed again.

Reveal Cambridge pseudocode for Stage 2

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Given by the question:
// StudentName[]  ScreenTime[,]  ClassSize

// Working variables — no DECLARE needed:
// StudentCounter, DayCounter  // loop counters
// TotalMinutes, HighDays      // per-student results
// Hours, Minutes              // conversion results
// ClassTotal, AverageMinutes  // class totals
// LowestTotal, LowestStudent  // lowest-week trackers

📖 Detailed explanation

The 2D array is addressed with two indexes. ScreenTime[StudentCounter, DayCounter] means “the current student's minutes for the current day” — row first, then column.

Meaningful identifiers earn AO3 credit. HighDays and LowestTotal make the counting test and the minimum tracker impossible to confuse.

Scope follows purpose. Per-student values are reset inside the processing loop; class values are set once outside it. Deciding that now prevents the classic reset-in-the-wrong-place mistake.

⚠️ Common mistakes

Renaming the given arrays or variables, which the mark scheme treats as not using the supplied data.
Writing a long block of declarations the question explicitly says is unnecessary.
Reusing one counter variable for both loops, which breaks the nesting immediately.
Storing the student's name in a separate variable instead of reading it from StudentName[].

💡 Exam hack / tip

Borrow the question's own words for identifiers: TotalMinutes, HighDays, ClassTotal, LowestStudent. An examiner should be able to map every variable back to a phrase in the question.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · appropriate data structuresR1–R5 · given names reusedAO3 · meaningful identifiers

The data plan supports AO2 because the chosen variables store exactly the required data, and AO3 because every identifier is meaningful. These are alignment notes, not separately allocated marks.

Initialise the totals and trackers

Give every accumulator and champion a known starting value.

R2 · R4 · R5

🧠 Step-by-step thinking

Initialise class values once. ClassTotal ← 0 before any student is processed, because it accumulates across the whole class.
Seed the lowest tracker above any possible total. LowestTotal ← 99999 is larger than any week could reach, so the first student always takes the title on the first comparison.
Remember the champion's position. LowestStudent stores the index, and the name is looked up through StudentName[] when it is output.
Reset per-student values inside the processing loop. TotalMinutes ← 0 and HighDays ← 0 at the top of each student's pass.
Check the reset positions twice. A total reset too early or too late silently corrupts every following result.

Once: class totalsEvery pass: student totalsSentinel: LowestTotal ← 99999

❓ Guiding questions – think before revealing

Why is LowestTotal seeded with a huge value instead of 0?
Which variables must never be reset inside the student loop?
Why is AverageMinutes not initialised here?

Reveal suggested reasoning

Why is LowestTotal seeded with a huge value instead of 0? A minimum tracker seeded at 0 could never be beaten — no weekly total is below zero — so LowestStudent would never be set. A value larger than any possible week (seven days can hold at most 7 × 1440 = 10080 minutes) guarantees the first student's total takes the title.

Which variables must never be reset inside the student loop? ClassTotal, LowestTotal and LowestStudent — resetting them would erase the class-wide results gathered from earlier students.

Why is AverageMinutes not initialised here? It is a single calculated result, not an accumulator: ClassTotal ÷ ClassSize is computed once, after the processing loop has finished.

Reveal Cambridge pseudocode for Stage 3

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Class-wide values — initialised ONCE
ClassTotal ← 0
LowestTotal ← 99999   // sentinel above any possible week
LowestStudent ← 0

FOR StudentCounter ← 1 TO ClassSize
    // Per-student values — reset EVERY pass
    TotalMinutes ← 0
    HighDays ← 0
    ...
NEXT StudentCounter

📖 Detailed explanation

“Once” versus “every pass” is the heart of this stage: class accumulators live outside the loop, student accumulators are reborn inside it.

The sentinel 99999 is larger than any possible weekly total (seven days can hold at most 10080 minutes), so the first comparison always succeeds and the champion variables are always assigned.

The champion stores an index. LowestStudent remembers where the lowest week lives; the name is translated through StudentName[] at the end.

⚠️ Common mistakes

Seeding LowestTotal with 0, so no student can ever become the lowest-week champion.
Resetting ClassTotal inside the student loop, so only the last student's minutes survive.
Initialising per-student totals before the loop instead of inside it, so every student adds to the previous student's total.
Forgetting LowestStudent and outputting LowestTotal where the question asks for a name.

💡 Exam hack / tip

Say it as a rule: reset inside what you repeat; initialise once what you accumulate. Then point at each variable and ask — does this belong to one student or to the whole class?

Reveal the Cambridge mark-scheme and rubric connection

AO2 · correct starting stateR4 · R5 · trackers start safelyAO3 · reliable logic

Initialisation supports AO2 because the accumulators can genuinely store the required data, and AO3 because the logic starts from a reliable state. These are alignment notes, not separately allocated marks.

Input every student's week

Fill ScreenTime[,] with nested INPUT loops and suitable messages.

🧠 Step-by-step thinking

Nest the day loop inside the student loop. For each student, the inner loop runs from day 1 to day 7.
Input into the 2D array directly. INPUT ScreenTime[StudentCounter, DayCounter] stores each entered figure in the correct cell — no intermediate variable is needed.
Wrap every prompt in a suitable message. The question demands suitable messages: name the student and the day, so entries cannot be made for the wrong person.
Output the student's name from the given array. StudentName[StudentCounter] names the student whose week is being entered.
Complete the input phase before processing. Every student enters their week first; the totals begin afterwards.

Nested iterationINPUT into ScreenTime[,]Suitable messages

❓ Guiding questions – think before revealing

Why is there no boundary check on the entered minutes?
What does a “suitable” input message look like?
How many times does the inner INPUT run in total?

Reveal suggested reasoning

Why is there no boundary check on the entered minutes? The question sets no validation requirement, so the marks are for correct input, totalling, counting and output — adding validation costs time and cannot earn extra credit here.

What does a “suitable” input message look like? It identifies the student and the day, for example “Day 3 minutes for Amara:”. A bare INPUT with no prompt fails the stated message requirement.

How many times does the inner INPUT run in total? ClassSize × 7 times — every cell of the 2D array is filled exactly once.

Reveal Cambridge pseudocode for Stage 4

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

FOR StudentCounter ← 1 TO ClassSize
    OUTPUT "Enter the daily minutes for ",
        StudentName[StudentCounter]
    FOR DayCounter ← 1 TO 7
        OUTPUT "Day ", DayCounter, " minutes: "
        INPUT ScreenTime[StudentCounter, DayCounter]
    NEXT DayCounter
NEXT StudentCounter

📖 Detailed explanation

The input loop mirrors the data layout. Rows are students and columns are days, so the outer counter indexes rows and the inner counter indexes columns.

Input happens through the array itself. Storing straight into ScreenTime[StudentCounter, DayCounter] avoids a temporary variable and makes the cell being filled obvious to the examiner.

The messages are part of the requirement. “All inputs and outputs must contain suitable messages” is a stated requirement, so the prompts are worth writing carefully, not rushing.

⚠️ Common mistakes

Writing INPUT ScreenTime[DayCounter, StudentCounter], which fills the array across the grain and mixes students' data.
Prompting with no message, or a message that does not say which student and day are expected.
Inputting into a second 2D array with a new name instead of the given ScreenTime[].
Totalling the minutes inside the input loop, then totalling again in the processing loop and double-counting.

💡 Exam hack / tip

Say the array access aloud as a sentence: “student StudentCounter, day DayCounter”. If the sentence does not name the cell you want, the indexes are the wrong way round.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · iteration and inputR1 · every student inputs a weekAO3 · suitable messages

The input loop is the clearest AO2 evidence of iteration filling the 2D array, and the prompts are AO3 communication evidence. These are alignment notes, not separately allocated marks.

Total the week and count the days over 300

One inner loop does both jobs for the current student.

R2 · R3 · R5

🧠 Step-by-step thinking

Reset, then visit all seven days. TotalMinutes and HighDays start at zero, then the day loop adds each figure and tests the boundary.
Accumulate with two indexes. TotalMinutes ← TotalMinutes + ScreenTime[StudentCounter, DayCounter] adds one day per pass.
Test the boundary with >. A day counts only when the minutes are strictly more than 300, so the test is > 300 — exactly 300 does not count.
Update the class total after the day loop. ClassTotal ← ClassTotal + TotalMinutes adds the finished week once.
Test the lowest champion on the finished total. IF TotalMinutes < LowestTotal updates both champion variables together.

TotallingBoundary: > 300 strictlyMinimum tracking

❓ Guiding questions – think before revealing

Why is the test > rather than >=?
Why can the lowest test use the finished TotalMinutes?
Why update ClassTotal here rather than in a third loop?

Reveal suggested reasoning

Why is the test > rather than >=? “More than 300” excludes 300 itself. A day of exactly 300 minutes is not a high day, so >= would produce a wrong count whenever the boundary value appears.

Why can the lowest test use the finished TotalMinutes? The champion comparison needs the student's complete week, so it runs once per student, after NEXT DayCounter — comparing a part-finished total would be meaningless.

Why update ClassTotal here rather than in a third loop? The weekly total is complete at the end of the student's pass, so adding it immediately needs no second pass over the array — and no extra storage of per-student totals.

Reveal Cambridge pseudocode for Stage 5

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Inside the processing loop
FOR DayCounter ← 1 TO 7
    TotalMinutes ← TotalMinutes +
        ScreenTime[StudentCounter, DayCounter]
    IF ScreenTime[StudentCounter, DayCounter] > 300
    THEN
        HighDays ← HighDays + 1
    ENDIF
NEXT DayCounter

ClassTotal ← ClassTotal + TotalMinutes

IF TotalMinutes < LowestTotal
THEN
    LowestTotal ← TotalMinutes
    LowestStudent ← StudentCounter
ENDIF

📖 Detailed explanation

One visited-cell pattern serves three requirements. The same loop that totals the week also runs the high-day test, and the finished total feeds the class accumulator and the lowest tracker — visit each cell once, do all the work.

Boundary wording is a mark-scheme trap. “More than” and “over” translate to >; “300 or more” and “at least” would translate to >=.

Champion updates are atomic. Updating LowestTotal but forgetting LowestStudent loses exactly the information the final output needs.

⚠️ Common mistakes

Using >= 300, which wrongly counts a day of exactly 300 minutes.
Adding the day's minutes outside the inner loop, so only one day per student is ever totalled.
Comparing the lowest champion inside the day loop, where TotalMinutes is still growing.
Forgetting ClassTotal ← ClassTotal + TotalMinutes, which leaves the class average at zero.

💡 Exam hack / tip

Write the operator in the margin as soon as you read the bullet: more than 300 means > 300, never >=. Cambridge boundary questions reward candidates who spot the difference.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · totalling, selection and min trackingR2 · R3 · R5 · all three steps correctAO3 · correct boundary and branches

This stage supplies the totalling, boundary-selection and minimum-tracking evidence for AO2, and the strictly-greater boundary for AO3 accuracy. These are alignment notes, not separately allocated marks.

Convert to hours and minutes and output each student

DIV and MOD turn the weekly minutes into the required format.

R2 · R4

🧠 Step-by-step thinking

Convert with DIV and MOD. Hours ← TotalMinutes DIV 60 gives the whole hours; Minutes ← TotalMinutes MOD 60 gives the remainder.
Check the arithmetic on a real value. 1985 minutes: 1985 DIV 60 = 33 and 1985 MOD 60 = 5, so the output reads “33 hours 5 minutes”.
Output the three per-student results. Name through StudentName[StudentCounter], the hours-and-minutes total, and the high-day count — each with a suitable message.
Keep the outputs inside the loop. Every student's results are printed as their week is finished, before the next student is processed.
Order the statements carefully. Convert first, then output — the variables must hold their final values before they are printed.

DIV and MODOutput: three results per studentSuitable messages

❓ Guiding questions – think before revealing

Why DIV and MOD rather than a division?
What is output for a student with 855 weekly minutes?
Why must the conversion sit after NEXT DayCounter?

Reveal suggested reasoning

Why DIV and MOD rather than a division? TotalMinutes / 60 would give a decimal such as 33.08. Cambridge pseudocode provides DIV for the whole-number part and MOD for the remainder, and together they produce exactly the “hours and minutes” the bullet demands.

What is output for a student with 855 weekly minutes? 855 DIV 60 = 14 hours and 855 MOD 60 = 15 minutes, so the message reads “Weekly screen time: 14 hours 15 minutes”, alongside the name and the days-over-300 count.

Why must the conversion sit after NEXT DayCounter? TotalMinutes is only complete once all seven days have been added. Converting earlier would report a part-week.

Reveal Cambridge pseudocode for Stage 6

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// After the day loop has finished
Hours ← TotalMinutes DIV 60
Minutes ← TotalMinutes MOD 60
OUTPUT "Student: ", StudentName[StudentCounter]
OUTPUT "Weekly screen time: ", Hours, " hours ",
    Minutes, " minutes"
OUTPUT "Days with more than 300 minutes: ", HighDays

📖 Detailed explanation

DIV and MOD are a matching pair. x DIV 60 answers “how many whole hours?” and x MOD 60 answers “how many minutes are left over?” — the two results recombine as Hours × 60 + Minutes.

The name comes from the given array. StudentName[StudentCounter] converts the row number into the name the question asks you to print.

The outputs sit inside the student loop. One pass of the loop converts and prints one student's three results — the class-wide outputs wait until after the loop.

⚠️ Common mistakes

Using TotalMinutes / 60 and outputting a decimal such as 33.08 instead of hours and minutes.
Swapping the operators, so MOD reports the hours and DIV the minutes.
Outputting the student number instead of looking up StudentName[].
Forgetting the third output line — the days-over-300 count is a named requirement.

💡 Exam hack / tip

Memorise the pair as whole hours DIV, leftover minutes MOD. For any minutes value, DIV 60 is the hours and MOD 60 is the minutes — test it on 1985 before you write it.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · arithmetic with DIV and MODR2 · R4 · conversion and outputsAO3 · accurate messages

The DIV/MOD conversion and the three labelled outputs are the R2 and R4 evidence, and accurate expressions support AO3. These are alignment notes, not separately allocated marks.

Close the loop and output the class summary

Calculate the average once, then report the class-wide results.

R4 · R5

🧠 Step-by-step thinking

Close the loop after the outputs. NEXT StudentCounter ends each student's processing only when every per-student job is done.
Calculate the average once. AverageMinutes ← ClassTotal / ClassSize after the loop, when ClassTotal holds every student's minutes.
Output the average with a message. The bullet asks for “the average weekly minutes of screen time for the whole class” — a single labelled output.
Output the lowest-week student by name. StudentName[LowestStudent] translates the stored index into the name the question asks for.
Place all summary outputs after the loop. Each class result is displayed exactly once, after every student has been processed.

Loop closureAverage: ClassTotal / ClassSizeName lookup through StudentName[]

❓ Guiding questions – think before revealing

Why must the average be calculated after NEXT StudentCounter?
Which summary outputs need an array lookup?
How do you know the summary is complete?

Reveal suggested reasoning

Why must the average be calculated after NEXT StudentCounter? ClassTotal is only complete once every student's week has been added. Dividing earlier would average a part-finished total that no later step can repair.

Which summary outputs need an array lookup? The lowest-week student: LowestStudent stores a position, and the question asks for the name, so StudentName[LowestStudent] provides it.

How do you know the summary is complete? Check it against the question's final bullets: the average weekly minutes for the whole class, then the name of the student with the lowest weekly screen time.

Reveal Cambridge pseudocode for Stage 7

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

NEXT StudentCounter

// Class summary — after the student loop
AverageMinutes ← ClassTotal / ClassSize
OUTPUT "Class average weekly minutes: ", AverageMinutes
OUTPUT "Lowest weekly screen time: ",
    StudentName[LowestStudent]

📖 Detailed explanation

Loop closure is part of the logic. Everything that belongs to one student — totalling, counting, the lowest test, conversion, outputs — must sit between FOR and NEXT StudentCounter.

Indexes are not names. The lowest tracker stores a position; the final output must translate it through StudentName[].

The summary is the last thing the program does. No further processing follows it, which is a quick visual check that nothing was left inside the loop by mistake.

⚠️ Common mistakes

Placing the class summary inside the student loop, printing the average once per student.
Dividing by 7 (the days) instead of ClassSize, which produces a per-day figure rather than a weekly average.
Outputting LowestStudent as a raw number instead of looking up the name.
Forgetting one of the two class-wide outputs — both the average and the lowest-week name are named requirements.

💡 Exam hack / tip

End-of-question checklist: loop closed, total complete, average divided by ClassSize, lowest name looked up, every output printed once. Five ticks in the margin prevent the most common last-line losses.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · complete outputsR4 · R5 · class results reportedAO3 · logical loop closure

The summary delivers the remaining R4 and R5 outputs, and its position after the loop is AO3 logic evidence. These are alignment notes, not separately allocated marks.

Cambridge assessment criteria

What does a high-level response look like?

The mark scheme assesses the answer across AO2 and AO3. Use these descriptors to check the whole program, not just one isolated code section.

9 AO2 + 6 AO3 = 15

AO2 · Apply knowledge and understandingMaximum 9 marks · programming techniques and data structures

Band	What the descriptor means
0	No creditable response.
1–3	At least one programming technique is used. Some data is stored, but not appropriately. Any use of iteration, selection, counting, totalling, input or output may be credited.
4–6	Some programming techniques are appropriate to the problem, with more than one technique applied. Some data structures are appropriate and store some of the required data.
7–9	The full range of techniques needed by the scenario is used appropriately. The chosen data structures are appropriate and store all the required data.

AO3 · Provide solutions to problemsMaximum 6 marks · comments, identifiers, logic and accuracy

Band	What the descriptor means
0	No creditable response.
1–2	Program seen without relevant comments. Some identifier names and some data-structure names are appropriate. The solution may be illogical or inaccurate in many places, but attempts at least one requirement.
3–4	Program seen with some relevant comments. The majority of identifiers and most data-structure names are meaningful. Parts may be illogical or inaccurate, but most requirements are met.
5–6	The program is fully commented. Suitable identifiers are meaningful throughout, and all data structures have meaningful names. The program is logical and accurate and meets all requirements; minor syntax errors are ignored.

How the seven stages contribute

These are links to the assessment criteria, not separate mark allocations.

R1–R5

Stage	Mark-scheme link	AO2 evidence	AO3 evidence
1 · Decode	R1–R5	Identifies the full set of required techniques.	Establishes logical order and comments plan.
2 · Data	Required data structures	Appropriate counters, totals and lowest-week trackers.	Meaningful identifiers throughout.
3 · Initialise	R2, R4, R5	Class totals and lowest tracker correctly initialised; per-student values reset.	Clear comments and reliable starting state.
4 · Input	R1	Nested input loops fill ScreenTime[,] with suitable messages.	Accurate two-index array access.
5 · Totals	R2, R3, R5	Weekly totalling, strict > 300 counting, class total and lowest tracking.	Correct > boundary and champion branches.
6 · Convert	R2, R4	DIV and MOD conversion and three per-student outputs.	Accurate DIV/MOD expressions and messages.
7 · Summary	R4, R5	Close the loop and output class average and lowest-week name.	Average divided by ClassSize; name lookup.

Consolidated Cambridge pseudocode

Complete solution

The full answer is presented in one place after the seven stages. Try to construct it yourself before opening this tab during revision.

15-mark exemplar style

QUESTION 11 · FULL PSEUDOCODECambridge 0478 style · 1-based indexing

// StudentName[] and ClassSize already contain the required data.
// ScreenTime[,] is filled by this program; the question says that
// no arrays or variables need to be declared.

// Initialise the class-wide values once
ClassTotal ← 0
LowestTotal ← 99999      // larger than any possible weekly total
LowestStudent ← 0

// Phase 1: allow every student to enter their week of daily minutes
OUTPUT "This program records the screen times for the class"
FOR StudentCounter ← 1 TO ClassSize
    OUTPUT "Enter the daily minutes for ", StudentName[StudentCounter]
    FOR DayCounter ← 1 TO 7
        OUTPUT "Day ", DayCounter, " minutes for ",
            StudentName[StudentCounter], ": "
        INPUT ScreenTime[StudentCounter, DayCounter]
    NEXT DayCounter
NEXT StudentCounter

// Phase 2: process each student's finished week
FOR StudentCounter ← 1 TO ClassSize

    // Reset this student's running values
    TotalMinutes ← 0
    HighDays ← 0

    // Total the week and count the days over 300 minutes
    FOR DayCounter ← 1 TO 7
        TotalMinutes ← TotalMinutes +
            ScreenTime[StudentCounter, DayCounter]
        IF ScreenTime[StudentCounter, DayCounter] > 300
        THEN
            HighDays ← HighDays + 1
        ENDIF
    NEXT DayCounter

    // Add the finished week to the class total
    ClassTotal ← ClassTotal + TotalMinutes

    // Track the student with the lowest weekly minutes
    IF TotalMinutes < LowestTotal
    THEN
        LowestTotal ← TotalMinutes
        LowestStudent ← StudentCounter
    ENDIF

    // Convert the total to hours and minutes and output it
    Hours ← TotalMinutes DIV 60
    Minutes ← TotalMinutes MOD 60
    OUTPUT "Student: ", StudentName[StudentCounter]
    OUTPUT "Weekly screen time: ", Hours, " hours ", Minutes, " minutes"
    OUTPUT "Days with more than 300 minutes: ", HighDays

NEXT StudentCounter

// Output the class-wide summary
AverageMinutes ← ClassTotal / ClassSize
OUTPUT "Class average weekly minutes: ", AverageMinutes
OUTPUT "Lowest weekly screen time: ", StudentName[LowestStudent]

Why this is a complete response

It covers the five mark-scheme requirements: every student inputs their week with suitable messages (R1), weekly totalling with the hours-and-minutes conversion (R2), high-day counting with the correct strictly-more-than boundary (R3), the three per-student outputs plus the class average (R4), and the lowest-week tracker with its named output (R5).

What to check before submitting

Check the two-index array accesses, the > 300 boundary, the DIV/MOD conversion, the reset positions of the per-student values, the division by ClassSize, and the comments explaining the program.

Remember: The AO2 and AO3 marks are awarded by judging the whole response. The individual R1–R5 labels are the technique requirements, not a fixed per-item mark split.

Interactive execution trace

Visualisation: watch the program work.

Step through a sample class of four. Watch the input loop fill ScreenTime, the totals build, the 300-minute boundary reject an exactly-300 day, DIV and MOD convert each week, and the lowest-week champion take the title.

Last tab · Trace player

Sample input → expected results

Four sample students record seven days of screen minutes (ClassSize = 4; seven days). The sample deliberately tests a day of exactly 300 minutes (Aisha, day 3 — not a high day, because the test is strictly more than 300), a week of 1985 minutes that converts to 33 hours 5 minutes, a clear lowest week (Dana, 855 minutes) and a class average of 1671.25 minutes that forces a rounding decision. These are illustrative values, not data supplied by the examination question.

Input arrays StudentName[] and ScreenTime[,]

Student	Day 1	Day 2	Day 3	Day 4	Day 5	Day 6	Day 7

The row number is the student position used by both arrays.

Reveal expected student results and class summary

Expected student results After all calculations

Student	Total (min)	Hours and minutes	Days over 300	Lowest week

Execution trace

Step 1 of 1

Initialisation

The program begins.

Program output so far

(No output yet)

Live variable values

Class counters

Ready

Tip: use Next step slowly and watch StudentCounter, DayCounter and TotalMinutes. The day counter returns to 1 for each new student, but ClassTotal and the lowest-week tracker never reset.

Trace colours: blue row = current student; amber cell = current day's minutes; green cells = days already processed.

Boundary examples: Aisha's day 3 is exactly 300 minutes and 300 > 300 is FALSE, so it is not a high day — using >= would wrongly count it. Chen's 1985 minutes give 1985 DIV 60 = 33 hours and 1985 MOD 60 = 5 minutes. The class average is 6685 ÷ 4 = 1671.25, and INT(1671.25 + 0.5) reports it as 1671 minutes if you round to the nearest whole minute.

From daily screen minutes to a class screen-time report.

Learning targets

01 · Understand

02 · Construct

03 · Complete

Read the whole question first

Before you move on

Decode the requirements

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Plan the data and identifiers

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Initialise the totals and trackers

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Input every student's week

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Total the week and count the days over 300

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Convert to hours and minutes and output each student

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Close the loop and output the class summary

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

What does a high-level response look like?

How the seven stages contribute

Final self-check

Complete solution

Why this is a complete response

What to check before submitting

Visualisation: watch the program work.

Sample input → expected results

Input arrays StudentName[] and ScreenTime[,]

Expected student results After all calculations

Execution trace

Initialisation

Live variable values

Class counters