15-mark question lab · start here

From a week of hourly readings to daily and weekly averages.

Build the solution in a sensible order: decode the six requirements, plan the three arrays, populate Days[], read and validate every hourly temperature, total each day and store its rounded average, average the week, then convert every figure to Fahrenheit and report. Learn the reasoning before revealing the complete program.

2D arrayRange validationTotallingCelsius-to-Fahrenheit conversionRounding to 1 dp15 marks

Learning targets

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

Lesson overview

01 · Understand

Identify the three arrays and their shared day index, the inclusive range −20.0 °C to +50.0 °C, and the six requirements hidden in the bullet list.

02 · Construct

Build the program in order: populate Days[], read and validate every hourly temperature in nested loops, total each day, and store each rounded daily average in AverageTemp[].

03 · Complete

Average the week from the stored daily values, convert every average with Fahrenheit = Celsius * 9 / 5 + 32, and output each day and the whole week in both scales, rounded to one decimal place.

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 shared day index, the inclusive temperature range and the two-scale outputs all affect the structure of your solution.

Question 11 · 15 marks

Cambridge IGCSE Computer Science · 0478/21 · Question 11

A one-dimensional (1D) array Days[] contains the names of the days of the week. A two-dimensional (2D) array Readings[] is used to store 24 temperature readings, taken once an hour, for each of the seven days of the week. A 1D array AverageTemp[] is used to store the average temperature for each day of the week.

The position of any day’s data is the same in all three arrays. For example, if Wednesday is in index 4 of Days[], Wednesday’s temperature readings are in index 4 of Readings[] and Wednesday’s average temperature is in index 4 of AverageTemp[]

The temperature readings are in Celsius to one decimal place. Temperatures can only be from –20.0 °C to +50.0 °C inclusive.

Write a program that meets the following requirements:

input and validate the hourly temperatures for one week
calculate and store the average temperature for each day of the week
calculate the average temperature for the whole week
convert all the average temperatures from Celsius to Fahrenheit by using the formula Fahrenheit = Celsius * 9 / 5 + 32
output the average temperature in Celsius and in Fahrenheit for each day
output the overall average temperature in Celsius and in Fahrenheit for the whole week.

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

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

All inputs and outputs must contain suitable messages.

All data output must be rounded to one decimal place.

You will need to initialise and populate the array Days[] at the start of the program.

Before you move on

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

Mark-scheme map

Input and store the hourly temperatures for every day of the week, with prompts and nested iteration over days and hours.

Validate each input against the range −20.0 °C to +50.0 °C inclusive, and re-ask until the value is valid.

Total each day’s readings and store the daily average in AverageTemp[], rounded to one decimal place.

Total the stored daily averages and calculate the weekly average, also rounded to one decimal place.

Convert all average temperatures with Fahrenheit = Celsius * 9 / 5 + 32 and output the daily and weekly figures in both scales with appropriate messages.

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

🧠 Step-by-step thinking

Identify the three arrays and their shared index. Days[] holds the day names, Readings[] holds 24 hourly readings for each of the seven days, and AverageTemp[] holds each day’s average — the same index points at the same day in all three.
Spot the two-level repetition. The program asks for a temperature once an hour for each of seven days — an outer loop over the days and an inner loop over the 24 readings of the current day.
Separate daily work from weekly work. Each day’s readings are validated, stored, totalled and averaged inside the day loop; the week’s average is calculated once, after all seven daily averages are stored.
Translate the command words. “Input and validate” demands prompts and a range test that re-asks; “calculate and store” demands a write into AverageTemp[]; “all the average temperatures” covers the seven daily values and the weekly value; “rounded to one decimal place” demands ROUND on every output.
Note the special closing line. “You will need to initialise and populate the array Days[] at the start of the program” — unlike the readings, the day names are your job to supply.
Build the order. populate Days[] → for each day: read and validate 24 readings, total them, store the rounded average → total the seven averages and average the week → convert every average to Fahrenheit and output the daily and weekly lines.

Inputs: 168 hourly temperaturesValidation: −20.0 to +50.0 inclusiveIteration: nested day and hour loopsOutput: daily and weekly, two scales

❓ Guiding questions – think before revealing

How many temperatures does the program input in total?
Why does the question say you must populate Days[] yourself?
Which averages must be converted to Fahrenheit?

Reveal suggested reasoning

How many temperatures does the program input in total? 24 readings × 7 days = 168 inputs. Each needs a prompt, a range check and a store into Readings[WeekLoop, DayLoop] — which is why the mark scheme names the iteration as nested.

Why does the question say you must populate Days[] yourself? The day names are needed for the prompts and the outputs, but no input supplies them. The closing line makes it explicit: Days[] must be initialised and populated at the start of the program — seven assignments or a loop both work.

Which averages must be converted to Fahrenheit? All of them: the seven daily averages in AverageTemp[] and the overall weekly average. The formula Fahrenheit = Celsius * 9 / 5 + 32 is given, and every output must appear in both scales.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Once: populate Days[] with the seven day names

// Every day: read, validate and store 24 hourly readings,
//            total them, then store the rounded daily average

// Once: total the seven daily averages and average the week

// Once: output each day and the week in Celsius AND Fahrenheit
//       — every value rounded to one decimal place

📖 Detailed explanation

“Input and validate the hourly temperatures for one week” is the R1 requirement: prompts, a −20.0 to +50.0 range check, re-entry on failure, and storage in Readings[] using nested loops.

“Calculate and store the average temperature for each day” means the daily average must be written into AverageTemp[WeekLoop], rounded to one decimal place — not just printed.

“Convert all the average temperatures” covers the seven daily averages and the weekly average — eight conversions in total, all with the same given formula.

“All data output must be rounded to one decimal place” applies to every Celsius and Fahrenheit figure in the output lines, so ROUND(…, 1) appears in each conversion.

⚠️ Common mistakes

Starting to code before listing the six bullet requirements in order.
Missing the closing line that makes populating Days[] your responsibility.
Printing daily averages without storing them in AverageTemp[].
Converting only the weekly average and forgetting the seven daily conversions.

💡 Exam hack / tip

Underline “input and validate”, “calculate and store” and “all the average temperatures”. Those phrases fix the validation loop, the write to AverageTemp[] and the eight Fahrenheit conversions — the parts the examiners look for first.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · algorithm designR1–R3 · 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 and arrays that store exactly what the algorithm needs.

Required data structures

🧠 Step-by-step thinking

Use the three array names exactly. Days[] (1D, seven day names), Readings[] (2D, 7 × 24 temperatures) and AverageTemp[] (1D, seven averages). The mark scheme requires these names as given.
Index the 2D array by day, then hour. Readings[WeekLoop, DayLoop] — the first index picks the day, the second picks one of that day’s 24 hourly readings. Both loops start at 1.
Add the loop and input variables. WeekLoop runs 1 to 7 for the days, DayLoop runs 1 to 24 for the readings of the current day, and InTemp holds the value being validated.
Add the accumulators. TotalDayTemp collects the current day’s readings and is reset for each new day; TotalWeekTemp collects the seven stored daily averages.
Add the result variable. AverageWeekTemp holds the week’s average, rounded to one decimal place.
Declarations are optional. The question says you may assume declaring has already been done — the published answer declares its identifiers anyway to show the data structures, and either approach is accepted.

Given: Days[], Readings[], AverageTemp[]Loops: WeekLoop 1 to 7, DayLoop 1 to 24Working: InTempAccumulators: TotalDayTemp, TotalWeekTemp

❓ Guiding questions – think before revealing

Why does Readings[] need two indexes?
Why are there two totals?
Does the answer need DECLARE statements?

Reveal suggested reasoning

Why does Readings[] need two indexes? It stores a grid: one row per day, one column per hourly reading. Readings[4, 17] is Wednesday’s 17th reading, because the same day position is used in every array — the question’s example puts Wednesday at index 4.

Why are there two totals? TotalDayTemp is reset to 0 at the start of each day and averages that day’s 24 readings; TotalWeekTemp is zeroed once and collects the seven stored daily averages for the weekly calculation.

Does the answer need DECLARE statements? No — the question says declaring has already been done. The published answer declares anyway to display its chosen data structures, which is acceptable; omitting the declarations is equally acceptable.

Reveal Cambridge pseudocode for Stage 2

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Given by the question — use these names exactly:
//   Days[]          1D, seven day names
//   Readings[]      2D, [day, hour] — 7 days × 24 readings
//   AverageTemp[]   1D, seven daily averages

// Loop and working variables:
WeekLoop          // current day, runs 1 to 7
DayLoop           // current reading, runs 1 to 24
InTemp            // the temperature being validated

// Accumulators and results:
TotalDayTemp      // current day's total, reset each day
TotalWeekTemp     // total of the seven daily averages
AverageWeekTemp   // the week's average, rounded to 1 dp

📖 Detailed explanation

The shared index is the question’s own example. Wednesday sits in index 4 of Days[], Readings[] and AverageTemp[] — one loop counter, WeekLoop, addresses all three at once.

Two totals for two levels of averaging. The daily average divides TotalDayTemp by 24; the weekly average divides TotalWeekTemp by 7 — dividing the wrong total by the wrong count is the classic slip.

InTemp exists because validation needs a holding variable. The value must be read, tested and only then stored in Readings[] — one variable does the holding while the validation loop decides.

Meaningful identifiers earn AO3 credit. TotalDayTemp and AverageWeekTemp say what they hold, and every name maps back to a phrase in the question.

⚠️ Common mistakes

Renaming the arrays — the mark scheme requires Days[], Readings[] and AverageTemp[] as given.
Swapping the indexes and writing Readings[DayLoop, WeekLoop], which stores hours as days.
Using one total for everything, so the weekly average divides a single day’s sum by 7.
Storing a raw input in AverageTemp[] instead of the calculated average.

💡 Exam hack / tip

Point at each name and ask “which phrase in the question does this store?” Readings answers “24 temperature readings, taken once an hour”, AverageTemp answers “the average temperature for each day” and TotalWeekTemp answers “the average temperature for the whole week”.

Reveal the Cambridge mark-scheme and rubric connection

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

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

Initialise the working values

Zero each total where it starts — and decide about declarations.

🧠 Step-by-step thinking

Reset TotalDayTemp for every day. The published answer sets TotalDayTemp ← 0 at the top of the day loop, so each day’s average is built from that day’s readings alone.
Zero TotalWeekTemp once. TotalWeekTemp ← 0 runs after the input loops, immediately before the seven stored averages are added to it.
Days[] is the real initialisation work. The question’s closing line — “You will need to initialise and populate the array Days[] at the start of the program” — is handled in the next stage, before any temperature is read.
Declarations are optional. The question says you may assume declaring has already been done; the published answer declares its arrays and variables anyway to display the data structures.
The averages need no seed. AverageTemp[] and AverageWeekTemp receive their values by calculation — only the two totals are initialised.

Reset per day: TotalDayTempZero once: TotalWeekTempPopulate: Days[]

❓ Guiding questions – think before revealing

Why is TotalDayTemp reset inside the day loop?
Where does TotalWeekTemp get zeroed?
What happens if you forget to initialise Days[]?

Reveal suggested reasoning

Why is TotalDayTemp reset inside the day loop? It must hold only the current day’s readings when it is divided by 24. Resetting it once at the top of the program would pile all seven days into one total, and every daily average would be wrong.

Where does TotalWeekTemp get zeroed? After the input loops and before the totalling loop. The published answer writes TotalWeekTemp ← 0 immediately before the FOR loop that adds the seven stored averages.

What happens if you forget to initialise Days[]? The prompts and the output lines would print empty day names — and the question explicitly makes populating Days[] your responsibility, so the examiners look for it.

Reveal Cambridge pseudocode for Stage 3

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// The question's special requirement — populate Days[] first
Days[1] ← "Sunday"
Days[2] ← "Monday"
Days[3] ← "Tuesday"
Days[4] ← "Wednesday"
Days[5] ← "Thursday"
Days[6] ← "Friday"
Days[7] ← "Saturday"

FOR WeekLoop ← 1 TO 7
    TotalDayTemp ← 0        // reset for each new day
    ...
NEXT WeekLoop

// After the input loops:
TotalWeekTemp ← 0           // zeroed once, before totalling

📖 Detailed explanation

The reset position is the whole trick. TotalDayTemp ← 0 sits inside the outer loop, so it runs seven times; TotalWeekTemp ← 0 sits outside, so it runs once.

Populating Days[] can be done three ways. Seven assignments, a loop that assigns from a second list, or input — the published answer uses assignments and the mark scheme accepts input and a loop as well.

Nothing else needs a starting value. The averages are calculated, not accumulated from a seed, so only the two totals are initialised.

⚠️ Common mistakes

Zeroing TotalDayTemp only once, so every day’s average includes the previous days’ readings.
Zeroing TotalWeekTemp inside the totalling loop, so only the last daily average survives.
Skipping the population of Days[] because the other arrays are supplied.
Reading temperatures before Days[] is populated, leaving prompts without day names.

💡 Exam hack / tip

Say it as a rule: reset what each day fills, zero what the week fills, populate what nothing else can supply. Only Days[] needs data — the totals need zero.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · correct starting stateR2 · totals zeroed in the right placesAO3 · follows the question’s instructions

Initialisation supports AO2 because the totals can genuinely accumulate the required data, and AO3 because the answer follows the question’s instructions. These are alignment notes, not separately allocated marks.

Populate the array Days[]

Seven day names, stored once at the start of the program.

Data structures

🧠 Step-by-step thinking

Read the special closing line again. “You will need to initialise and populate the array Days[] at the start of the program” — this is the only array the question asks you to fill yourself.
Assignments are the direct route. Days[1] ← “Sunday” down to Days[7] ← “Saturday” — seven lines, done once, before any temperature is read.
Input and a loop are also acceptable. The mark scheme explicitly allows reading the seven names in a loop; assignments are shorter and cannot be mistyped.
Choose an order and keep it everywhere. The published answer starts the week on Sunday, which puts Wednesday in index 4 — exactly matching the question’s own example.
The names are used twice. Days[WeekLoop] appears in every input prompt and again in every daily output line, so one population serves both.

Seven assignments, onceAlternative: input and a loopUsed in prompts and outputs

❓ Guiding questions – think before revealing

Why Sunday first?
Could you populate Days[] at the end instead?
Is a loop better than seven assignments?

Reveal suggested reasoning

Why Sunday first? The published answer chooses Sunday to Saturday, and the question’s example — Wednesday in index 4 — confirms that ordering. Any consistent order works, but the names must line up with the readings stored at the same index.

Could you populate Days[] at the end instead? No — the input prompts already print Days[WeekLoop], so the names must be in place before the first temperature is requested. That is why the question says “at the start of the program”.

Is a loop better than seven assignments? Both earn the credit. Seven explicit assignments are impossible to misalign; a loop with INPUT needs seven user entries before any temperature. The published answer uses the assignments.

Reveal Cambridge pseudocode for Stage 4

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// initial population of Days[] array
// input and a loop are also acceptable
Days[1] ← "Sunday"
Days[2] ← "Monday"
Days[3] ← "Tuesday"
Days[4] ← "Wednesday"
Days[5] ← "Thursday"
Days[6] ← "Friday"
Days[7] ← "Saturday"

📖 Detailed explanation

The published answer’s comment says it all. “Initial population of Days[] array — input and a loop are also acceptable”: the examiners accept any method that fills the array before it is used.

Index 4 must be Wednesday. The question fixes the example — if Wednesday is in index 4 of Days[], its readings are in index 4 of Readings[]. Sunday-first ordering satisfies it naturally.

One array, two customers. The prompts say “Enter temperature 5 for Thursday” and the outputs say “The average temperature on Thursday was …” — both read Days[WeekLoop].

⚠️ Common mistakes

Leaving Days[] empty because the other arrays are supplied by the question.
Starting the week on Monday, which pushes Wednesday to index 3 and breaks the question’s own example.
Populating Days[] after the input loop, so the prompts print blank day names.
Storing day numbers instead of day names, which the outputs would then print as digits.

💡 Exam hack / tip

The question hands you a self-check: Wednesday sits in index 4. Write your seven assignments, count to the fourth, and confirm it says “Wednesday” before moving on.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · data structures populatedR1 · R3 · day names for prompts and outputsAO3 · correct index alignment

Populating Days[] completes the data-structure evidence for AO2, and the index alignment is AO3 accuracy evidence. These are alignment notes, not separately allocated marks.

Record and validate a week of readings

A nested FOR loop with a WHILE validation loop inside it.

🧠 Step-by-step thinking

Loop over the days, then the hours. FOR WeekLoop ← 1 TO 7 wraps FOR DayLoop ← 1 TO 24; the inner loop reads the current day’s 24 hourly readings.
Prompt with the day name. OUTPUT “Enter temperature ”, DayLoop, “ for ”, Days[WeekLoop] — the question demands suitable messages on every input.
Validate with a WHILE loop. After each INPUT, WHILE InTemp < -20.0 OR InTemp > 50.0 prints an error message and reads again — the loop repeats until the value is inside the inclusive range.
Store only after validation. Readings[WeekLoop, DayLoop] ← InTemp sits after the ENDWHILE, so no rejected value ever reaches the array.
Total as you go. TotalDayTemp ← TotalDayTemp + ROUND(InTemp, 1) adds each accepted reading to the day’s running total, ready for the average.

Iteration: nested FOR loopsValidation: WHILE … ENDWHILEStore: Readings[WeekLoop, DayLoop]

❓ Guiding questions – think before revealing

Why WHILE rather than REPEAT … UNTIL here?
Why OR and not AND in the condition?
Are the boundary values themselves valid?

Reveal suggested reasoning

Why WHILE rather than REPEAT … UNTIL here? The published answer reads once, then loops WHILE the value is invalid. A REPEAT … UNTIL that re-prompts works equally well — the mark scheme only demands the range check and the re-ask, and both structures deliver them.

Why OR and not AND in the condition? The loop must run when the value is below −20.0 or above +50.0 — either failure alone makes the input invalid. Writing AND would only reject values that fail both tests at once, which is impossible, so nothing would ever be rejected.

Are the boundary values themselves valid? Yes — the range is −20.0 to +50.0 inclusive, so exactly −20.0 and exactly +50.0 pass. The condition InTemp < -20.0 OR InTemp > 50.0 correctly leaves both alone.

Reveal Cambridge pseudocode for Stage 5

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

FOR WeekLoop ← 1 TO 7
    TotalDayTemp ← 0
    FOR DayLoop ← 1 TO 24
        OUTPUT "Enter temperature ", DayLoop, " for ", Days[WeekLoop]
        INPUT InTemp
        // validation of input for between -20 and +50 inclusive
        WHILE InTemp < -20.0 OR InTemp > 50.0 DO
            OUTPUT "Your temperature must be between -20.0 and +50.0 inclusive. Please try again"
            INPUT InTemp
        ENDWHILE
        Readings[WeekLoop, DayLoop] ← InTemp
        TotalDayTemp ← TotalDayTemp + ROUND(InTemp, 1)
    NEXT DayLoop
NEXT WeekLoop

📖 Detailed explanation

The nesting is the R1 evidence. The mark scheme names “(nested) iteration” — the outer loop walks the week and the inner loop walks the hours, so all 168 readings are captured.

The store follows the ENDWHILE. Because Readings[WeekLoop, DayLoop] ← InTemp sits after validation, rejected attempts never pollute the array or the day’s total.

ROUND inside the totalling is harmless care. Inputs are already to one decimal place; the published answer still writes ROUND(InTemp, 1) before adding, which guards the total’s precision.

The error message names the valid range. “Your temperature must be between -20.0 and +50.0 inclusive. Please try again” tells the user exactly what went wrong — a suitable message in the question’s sense.

⚠️ Common mistakes

Writing AND instead of OR, so no input is ever rejected.
Storing the reading before the validation loop, so an invalid attempt reaches Readings[].
Resetting TotalDayTemp inside the inner loop, so only the last reading is totalled.
Prompting without the day name, which the question’s “suitable messages” line rules out.

💡 Exam hack / tip

Read the range aloud with the word inclusive: “from −20.0 to +50.0 inclusive” means the rejects are below −20.0 or above +50.0 — exactly the WHILE condition the published answer uses.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · validation, iteration and totallingR1 · prompts, range check, nested loopsAO3 · correct loop structureAO3 · comments explain purpose

This stage carries the R1 evidence for AO2 — prompts, range check and nested iteration — and the loop structure is AO3 logic evidence. These are alignment notes, not separately allocated marks.

Average each day, then the whole week

Round every average to one decimal place before storing it.

🧠 Step-by-step thinking

Average the day after its last reading. Once NEXT DayLoop runs, TotalDayTemp holds the day’s 24 readings, so AverageTemp[WeekLoop] ← ROUND(TotalDayTemp / 24, 1) stores the rounded daily average.
Store, do not just print. The question says “calculate and store” — the weekly calculation depends on the stored values, so AverageTemp[] must be filled.
Total the stored averages for the week. TotalWeekTemp ← TotalWeekTemp + AverageTemp[WeekLoop] in its own loop over the seven days — the week is averaged from the daily averages.
Round the weekly average too. AverageWeekTemp ← ROUND(TotalWeekTemp / 7, 1) — the same one-decimal-place rule applies.
Watch the two divisors. The daily average divides by 24; the weekly average divides by 7. Mixing them up is the classic slip on this question.

Daily: ROUND(total / 24, 1)Store: AverageTemp[WeekLoop]Weekly: ROUND(total / 7, 1)

❓ Guiding questions – think before revealing

Why average the stored daily averages instead of all 168 readings?
Where exactly does the daily average line go?
Why ROUND before storing the daily average?

Reveal suggested reasoning

Why average the stored daily averages instead of all 168 readings? The published answer reuses AverageTemp[] — the seven rounded values are already stored, and totalling them in a short second loop keeps the weekly calculation separate and simple. It also follows the question’s “calculate and store” order: store first, reuse after.

Where exactly does the daily average line go? Inside the outer FOR WeekLoop loop but after NEXT DayLoop — so it runs once per day, when that day’s readings are complete.

Why ROUND before storing the daily average? The question says all data output must be rounded to one decimal place, and the weekly total is built from the stored values — rounding at storage time keeps every later calculation and output consistent.

Reveal Cambridge pseudocode for Stage 6

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

    NEXT DayLoop
    // average temperature for the day
    AverageTemp[WeekLoop] ← ROUND(TotalDayTemp / 24, 1)
NEXT WeekLoop

// calculate the average temperature for the week
TotalWeekTemp ← 0
FOR WeekLoop ← 1 TO 7
    TotalWeekTemp ← TotalWeekTemp + AverageTemp[WeekLoop]
NEXT WeekLoop
AverageWeekTemp ← ROUND(TotalWeekTemp / 7, 1)

📖 Detailed explanation

Two loops, two levels. The first loop pairing produced the daily averages; this short second loop reduces the seven stored values to one weekly figure.

ROUND appears at both levels. ROUND(TotalDayTemp / 24, 1) for each day and ROUND(TotalWeekTemp / 7, 1) for the week — the one-decimal-place rule reaches every stored and printed value.

The stored averages are reused. Because the week is totalled from AverageTemp[], the array earns its keep: calculated once, read again for the weekly average and the output lines.

⚠️ Common mistakes

Dividing by 7 for a daily average or by 24 for the weekly average.
Printing the daily average without storing it in AverageTemp[].
Putting the daily average line inside the inner loop, so it runs 24 times per day.
Forgetting to zero TotalWeekTemp before totalling, so it starts from a leftover value.

💡 Exam hack / tip

Write the two divisors on your plan the moment you read the question: 24 for a day, 7 for a week. Every average on this paper is one of those two divisions wrapped in ROUND(…, 1).

Reveal the Cambridge mark-scheme and rubric connection

AO2 · iteration, totalling and roundingR2 · daily and weekly averagesAO3 · accurate calculations

This stage carries the R2 evidence for AO2 — iteration, totalling and rounding — and the accurate divisors support AO3. These are alignment notes, not separately allocated marks.

Convert to Fahrenheit and report

One formula for all eight averages, then the output lines.

🧠 Step-by-step thinking

Apply the given formula. Fahrenheit = Celsius * 9 / 5 + 32 — the question supplies it, so use it exactly as printed; no other conversion earns credit.
Convert every average. Seven daily conversions inside the output loop and one weekly conversion — “all the average temperatures” means all eight.
Round each Fahrenheit value. ROUND(AverageTemp[WeekLoop] * 9 / 5 + 32, 1) — the one-decimal-place rule applies to the converted scale as well.
Output both scales for each day. The day name from Days[WeekLoop], the day’s Celsius average and its own Fahrenheit conversion — held together by a suitable message.
Finish with the weekly line. The overall average in Celsius and Fahrenheit for the whole week completes the six requirements.

Formula: Celsius * 9 / 5 + 32Rounding: ROUND(…, 1)Output: 8 lines, both scales

❓ Guiding questions – think before revealing

Why convert inside the OUTPUT loop?
What must each daily output line contain?
Does the weekly line differ from the daily lines?

Reveal suggested reasoning

Why convert inside the OUTPUT loop? Each day needs its own Fahrenheit figure, and the conversion is a one-line expression — computing it at output time avoids a second array and keeps the calculation visible where it is used.

What must each daily output line contain? The day name from Days[WeekLoop], the day’s average in Celsius and the same average converted to Fahrenheit, each rounded to one decimal place, with a message that says what is being printed.

Does the weekly line differ from the daily lines? Only in the values: it prints AverageWeekTemp and its Fahrenheit conversion, with a message naming the whole week instead of a single day.

Reveal Cambridge pseudocode for Stage 7

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// outputs in Celsius and Fahrenheit
FOR WeekLoop ← 1 TO 7
    OUTPUT "The average temperature on ", Days[WeekLoop], " was ",
           AverageTemp[WeekLoop], " Celsius and ",
           ROUND(AverageTemp[WeekLoop] * 9 / 5 + 32, 1), " Fahrenheit"
NEXT WeekLoop

OUTPUT "The average temperature for the week was ",
       AverageWeekTemp, " Celsius and ",
       ROUND(AverageWeekTemp * 9 / 5 + 32, 1), " Fahrenheit"

📖 Detailed explanation

The formula is given — copy it faithfully. * 9 / 5 + 32 in that order; reordering the arithmetic changes the result and loses the accuracy marks.

Eight conversions, one expression. The same ROUND(… * 9 / 5 + 32, 1) shape serves every daily line and the weekly line — the mark scheme calls this “output and rounding”.

Suitable messages complete R3. Each line says what it is printing: which day, or the whole week, in which scales. The question’s closing lines ask for exactly that.

⚠️ Common mistakes

Converting with * 9 / 5 alone and forgetting the + 32.
Printing Celsius only, ignoring “in Celsius and in Fahrenheit”.
Rounding the Celsius values but outputting raw Fahrenheit decimals.
Printing the week’s Fahrenheit value on every daily line, so all seven days share one figure — each day needs its own conversion.

💡 Exam hack / tip

Memorise the shape Celsius × 9 ÷ 5 + 32 and wrap it in ROUND(…, 1) at output time. Check each daily line prints that day’s conversion — the week’s figure belongs to the week’s line alone.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · arithmetic and outputR3 · conversion and complete outputsAO3 · accurate expressions and messages

The conversions and output lines are the R3 evidence for AO2, and the correct formula and rounding support AO3 accuracy. 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–R3	Identifies the full set of required techniques, including the instruction to populate Days[].	Establishes logical order and comments the plan.
2 · Data	Required data structures	Uses Days[], Readings[] and AverageTemp[] as given, with appropriate working variables.	Meaningful identifiers throughout.
3 · Initialise	R2	Zeros TotalDayTemp for each day and TotalWeekTemp once, in the right places.	Clean starting state that follows the question’s instructions.
4 · Days	Data structures	Populates Days[] with the seven day names before any input happens.	Index 4 holds Wednesday, matching the question’s own example.
5 · Record	R1	Prompts for every reading, validates −20.0 to +50.0 inclusive and stores in Readings[].	Correct nested loops with the store placed after validation.
6 · Averages	R2	Stores each day’s rounded average in AverageTemp[] and averages the week from the stored values.	Accurate divisors — 24 for a day, 7 for the week.
7 · Convert	R3	Converts all eight averages with Celsius * 9 / 5 + 32 and outputs both scales.	Accurate expressions, suitable messages, one-decimal-place rounding.

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

Read this carefully: this mirrors the official published mark scheme answer for 0478/21 May/June 2023 Question 11. The published answer opens by declaring its arrays and variables to display the chosen data structures, even though the question allows you to assume this has already been done. It populates Days[] with seven assignments, reads and validates all 24 hourly readings for each day in a nested loop with a WHILE range check, stores each daily average rounded to one decimal place in AverageTemp[], builds the weekly average from those stored values, and converts with Fahrenheit = Celsius * 9 / 5 + 32 in the output lines. One published slip is corrected here: the paper prints the week’s Fahrenheit value inside every daily output line, so this version converts AverageTemp[WeekLoop] itself, giving each day its own figure.

QUESTION 11 · PUBLISHED MARK SCHEME ANSWERCambridge 0478 style · 1-based indexing

// meaningful identifiers and appropriate data structures for
// all data required
DECLARE Days : ARRAY[1:7] OF STRING
DECLARE Readings : ARRAY[1:7, 1:24] OF REAL
DECLARE AverageTemp : ARRAY[1:7] OF REAL
DECLARE WeekLoop : INTEGER
DECLARE DayLoop : INTEGER
DECLARE InTemp : REAL
DECLARE TotalDayTemp : REAL
DECLARE TotalWeekTemp : REAL
DECLARE AverageWeekTemp : REAL
// initial population of Days[] array
// input and a loop are also acceptable
Days[1] ← "Sunday"
Days[2] ← "Monday"
Days[3] ← "Tuesday"
Days[4] ← "Wednesday"
Days[5] ← "Thursday"
Days[6] ← "Friday"
Days[7] ← "Saturday"
// input temperatures inside nested loop
FOR WeekLoop ← 1 TO 7
    TotalDayTemp ← 0
    FOR DayLoop ← 1 TO 24
        OUTPUT "Enter temperature ", DayLoop, " for ", Days[WeekLoop]
        INPUT InTemp
        // validation of input for between -20 and +50 inclusive
        WHILE InTemp < -20.0 OR InTemp > 50.0 DO
            OUTPUT "Your temperature must be between -20.0 and +50.0 inclusive. Please try again"
            INPUT InTemp
        ENDWHILE
        Readings[WeekLoop, DayLoop] ← InTemp
        // totalling of temperatures during the day
        TotalDayTemp ← TotalDayTemp + ROUND(InTemp, 1)
    NEXT DayLoop
    // average temperature for the day
    AverageTemp[WeekLoop] ← ROUND(TotalDayTemp / 24, 1)
NEXT WeekLoop
// calculate the average temperature for the week
TotalWeekTemp ← 0
FOR WeekLoop ← 1 TO 7
    TotalWeekTemp ← TotalWeekTemp + AverageTemp[WeekLoop]
NEXT WeekLoop

AverageWeekTemp ← ROUND(TotalWeekTemp / 7, 1)
// outputs in Celsius and Fahrenheit
FOR WeekLoop ← 1 TO 7
    OUTPUT "The average temperature on ", Days[WeekLoop], " was ", AverageTemp[WeekLoop], " Celsius and ",
           ROUND(AverageTemp[WeekLoop] * 9 / 5 + 32, 1), " Fahrenheit"
NEXT WeekLoop

OUTPUT "The average temperature for the week was ",
       AverageWeekTemp, " Celsius and ", ROUND(AverageWeekTemp * 9 / 5 + 32, 1), " Fahrenheit"

Why this is a complete response

It covers the three mark-scheme requirements. R1: every hourly temperature is prompted for with its reading number and day name, stored in Readings[WeekLoop, DayLoop] and validated by the WHILE loop, which rejects anything below -20.0 or above +50.0 and re-asks. R2: each day’s readings are totalled in TotalDayTemp and the daily average is rounded to one decimal place and stored in AverageTemp[WeekLoop]; the weekly average is calculated from the seven stored values with ROUND(TotalWeekTemp / 7, 1). R3: every average temperature is converted with Fahrenheit = Celsius * 9 / 5 + 32, and the daily and weekly output lines report both scales with suitable messages, rounded to one decimal place.

What to check before submitting

Check that the WHILE condition joins its two tests with OR, that Readings[WeekLoop, DayLoop] is written only after the ENDWHILE, that TotalDayTemp is reset to 0 for each new day, that the daily average divides by 24 and the weekly average by 7, that every ROUND uses one decimal place, and that the comments explain how the code works.

Remember: the mark scheme awards AO2 a maximum of 9 marks and AO3 a maximum of 6 marks, giving 15 in total, judged by best fit across the whole response. R1, R2 and R3 are the technique requirements the examiners look for, not a fixed per-item mark split.

Interactive execution trace

Visualisation: watch the program work.

Step through one complete sample week, shrunk to six readings per day. Watch the WHILE validation reject 55.0 and take the reading again, the exact boundary values −20.0 and +50.0 pass straight through, each day’s total collapse into a rounded average, and the seven stored averages combine into the weekly figure — reported in Celsius and Fahrenheit.

Last tab · Trace player

Sample input → expected results

The demonstration shrinks the authentic question to seven days × six readings per day, so each daily average divides by 6 — the real paper records 24 hourly readings per day for seven days and divides by 24. The sample deliberately tests the validation and the rounding: Sunday’s first attempt of 55.0 is rejected and 12.5 is accepted; Monday opens with exactly −20.0 and Tuesday with exactly +50.0, both accepted because the range is inclusive; Monday and Wednesday include negative temperatures; Thursday’s six readings total 124.5 °C and 124.5 / 6 = 20.75, which rounds up to 20.8 °C, and its Fahrenheit conversion 69.44 rounds to 69.4 °F. The weekly average is calculated from the seven stored daily averages, exactly as the published answer does. This is the authentic 0478/21 Summer 2023 Question 11. These are illustrative values, not data supplied by the examination question.

Input array Readings[] · 7 days × 6 readings

Day	Reading 1	Reading 2	Reading 3	Reading 4	Reading 5	Reading 6

The row number is the day’s position in all three arrays — row 4 of Readings[] is Wednesday’s data, the same index 4 used by Days[] and AverageTemp[].

Reveal expected daily and weekly results

Expected results AverageTemp[] and the week average

Day	Average °C	Average °F

Execution trace

Step 1 of 1

Initialisation

The program begins.

Program output so far

(No output yet)

Live variable values

Week counters

Ready

Tip: use Next step slowly and watch WeekLoop, DayLoop and TotalDayTemp. WeekLoop advances one day at a time, DayLoop runs 1 to 6 inside each day, and TotalDayTemp returns to 0 at the start of each day before climbing reading by reading — and watch Sunday’s first reading reject 55.0 before accepting 12.5.

Trace colours: blue row = current day; amber cell = current reading; green cells = readings already processed.

Boundary example: Monday’s first reading is exactly −20.0 °C — the range is inclusive, so the WHILE test −20.0 < −20.0 is FALSE and the value is accepted. Sunday’s first attempt, 55.0, fails because 55.0 > 50.0 is TRUE, so it is rejected and re-entered as 12.5. Rounding example: Thursday’s readings total 124.5 °C and 124.5 / 6 = 20.75, which rounds up to 20.8 °C; converting gives 20.8 * 9 / 5 + 32 = 69.44, which rounds to 69.4 °F.

From a week of hourly readings to daily and weekly averages.

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 working values

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Populate the array Days[]

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Record and validate a week of readings

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Average each day, then the whole week

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Convert to Fahrenheit and report

🧠 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 array Readings[] · 7 days × 6 readings

Expected results AverageTemp[] and the week average

Execution trace

Initialisation

Live variable values

Week counters