15-mark question lab · start here

From student marks to class grade statistics.

Build the solution in a sensible order: understand the data, plan the loops, initialise the counters, calculate totals and averages, select grades, and present the results. Learn the reasoning before revealing the complete program.

2D arrayNested iterationRoundingSelection and counting15 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 matching student positions, and the values already supplied.

02 · Construct

Use nested loops to total each student’s subject marks, then calculate the rounded average.

03 · Complete

Award the correct grade, count class grades, and output every required result.

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 data layout, grade boundaries and output requirements all affect the structure of your solution.

Question 13 · 15 marks

Cambridge IGCSE Computer Science · 0478/02 · Question 13

The one-dimensional (1D) array StudentName[] contains the names of students in a class.
The two-dimensional (2D) array StudentMark[] contains the mark for each subject, for each student. The position of each student’s data in the two arrays is the same, for example, the student in position 10 in StudentName[] and StudentMark[] is the same.

The variable ClassSize contains the number of students in the class. The variable SubjectNo contains the number of subjects studied. All students study the same number of subjects.

The arrays and variables have already been set up and the data stored.

Students are awarded a grade based on their average mark.

Average mark	Grade awarded
greater than or equal to 70	distinction
greater than or equal to 55 and less than 70	merit
greater than or equal to 40 and less than 55	pass
less than 40	fail

Write a program that meets the following requirements:

calculates the combined total mark for each student for all their subjects
calculates the average mark for each student for all their subjects, rounded to the nearest whole number
outputs for each student:
- name
- combined total mark
- average mark
- grade awarded
calculates, stores and outputs the number of distinctions, merits, passes and fails for the whole class.

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

You do not need to initialise the data in the array.

Before you move on

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

Mark-scheme map

Calculate each student’s total using iteration and totalling.

Calculate the average and round it to the nearest whole number.

Select the correct grade for each student.

Output each student’s name, total, average and grade.

Count, store and output the whole-class totals for all four grades.

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 process every student, so an outer loop must repeat from student 1 to ClassSize.
Identify the repeated work inside each student. Every student has SubjectNo marks, so an inner loop must visit each subject for the current student.
Separate individual results from class results. Name, total, average and grade are produced for each student. The four grade counts are produced once for the whole class.
Translate command words. “Calculates” means processing; “rounded” means a rounding operation; “awarded” means selection; “number of” means counting; “outputs” means display.
Build the order: initialise → total → average → output name, total and average → select/count grade → NEXT StudentCounter → class summary.

Outer loop: studentsInner loop: subjectsSelection: gradeCounting: class totals

❓ Guiding questions – think before revealing

Which phrases tell you how many loops are needed?
Which results are per student, and which are for the whole class?
What order must the algorithm follow?

Reveal suggested reasoning

Which phrases tell you how many loops are needed? “For each student” signals the outer loop; “for all their subjects” signals the inner loop.

Which results are per student, and which are for the whole class? Name, total, average and grade are per student. The four grade counts are class-wide and are output once.

What order must the algorithm follow? Initialise, total the marks, calculate the average, output the name/total/average, select and count the grade, finish the student loop, then output the class summary.

Reveal Cambridge pseudocode for Stage 1

CODE PLAN · STRUCTURE ONLYBuild this before filling in the details

// Process every student in the class
FOR StudentCounter ← 1 TO ClassSize
    // Calculate this student's combined total
    // Calculate the rounded average
    // Output name, total and average
    // Select and output the grade; increment its counter
NEXT StudentCounter

// Output the four grade counts for the whole class

📖 Detailed explanation

“For each student” tells you where the outer loop belongs. One pass through that loop should produce one student’s result.

“For all their subjects” tells you that the current student’s row in StudentMark must be processed repeatedly.

“For the whole class” tells you that the grade counters must not be reset inside the student loop.

The order matters: you cannot calculate an average before the total is complete, or award a grade before the average is known.

⚠️ Common mistakes

Starting to write code before identifying the five required outcomes.
Using only one loop and therefore failing to visit every subject for each student.
Putting the final class-count outputs inside the outer student loop, causing repeated class summaries.
Forgetting that the input arrays are already populated.

💡 Exam hack / tip

Underline “for each student”, “for all their subjects” and “for the whole class”. Those phrases reveal the loop structure: outer student loop, inner subject loop, and class counters that survive until the end.

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 and arrays that store exactly what the algorithm needs.

AO2 · Data structures

🧠 Step-by-step thinking

Use the given structures. StudentName stores one name per student. StudentMark stores several subject marks per student.
Keep the same student index. StudentName[StudentCounter] and StudentMark[StudentCounter, SubjectCounter] refer to the same student.
Store each student’s calculations. Use TotalMark and AverageMark arrays if you want to retain the values for every student. The mark scheme says these may be seen but do not have to be stored.
Use four class counters. DistinctionNo, MeritNo, PassNo and FailNo store the number of students in each grade.
Use constants for fixed boundaries. The thresholds are 70, 55 and 40, so meaningful constants avoid unexplained values in the selection statements.

❓ Guiding questions – think before revealing

Why does StudentMark need two indexes?
Which arrays and variables are already supplied?
Must TotalMark and AverageMark be stored in arrays?

Reveal suggested reasoning

Why does StudentMark need two indexes? The first index identifies the student; the second identifies that student’s subject.

Which arrays and variables are already supplied? StudentName, StudentMark, ClassSize and SubjectNo are already set up and populated.

Must TotalMark and AverageMark be stored in arrays? No. The mark scheme says these arrays may be seen, but there is no requirement to store them. The exemplar does store them.

Given by the question

Array	`StudentName[]`
2D array	`StudentMark[,]`
Variables	`ClassSize`, `SubjectNo`

These are already set up and contain data. Do not initialise them again.

Additional identifiers

Arrays	`TotalMark[]`, `AverageMark[]`
Loop counters	`StudentCounter`, `SubjectCounter`
Grade counts	`DistinctionNo`, `MeritNo`, `PassNo`, `FailNo`
Constants	`Distinction`, `Merit`, `Pass`

Reveal Cambridge pseudocode for Stage 2

CAMBRIDGE PSEUDOCODE · DECLARATIONSBased on the specimen mark scheme

DECLARE TotalMark : ARRAY[1:50] OF INTEGER
DECLARE AverageMark : ARRAY[1:50] OF INTEGER
DECLARE SubjectCounter : INTEGER
DECLARE StudentCounter : INTEGER
DECLARE DistinctionNo : INTEGER
DECLARE MeritNo : INTEGER
DECLARE PassNo : INTEGER
DECLARE FailNo : INTEGER

CONSTANT Distinction = 70
CONSTANT Merit = 55
CONSTANT Pass = 40

📖 Detailed explanation

StudentMark[StudentCounter, SubjectCounter] uses two indexes: the first chooses a student and the second chooses one of that student’s subjects.

TotalMark and AverageMark use one position per student. This makes it easy to refer to the calculated result using the same student index.

The specimen exemplar declares the calculation arrays with positions 1:50. It does not require you to store the input arrays again.

The identifiers describe their purpose. This helps the examiner understand the logic and supports the AO3 requirement for meaningful identifiers.

⚠️ Common mistakes

Using a 1D index for StudentMark and accidentally omitting the subject index.
Using different student indexes for StudentName and StudentMark.
Renaming identifiers that the scenario says must be used as provided.
Declaring or initialising the supplied input arrays as though they were empty.

💡 Exam hack / tip

Write a tiny index reminder beside the question: StudentCounter = row; SubjectCounter = column. For every 2D array access, check that you have both indexes in the correct order.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · appropriate data structuresAO2 · store all required dataR1–R5 · counters and calculationsAO3 · meaningful identifiers

The AO2 7–9 descriptor requires appropriate data structures that store all data required by the scenario. The mark scheme explicitly lists the given arrays and the suggested calculation arrays, counters and constants.

Initialise the counters and running totals

Give every accumulator a known starting value before it is used.

R1 · R5

🧠 Step-by-step thinking

Ask what is being counted. At the beginning, no student has been classified, so all four grade counters must start at zero.
Ask what is being added. Each student’s total starts at zero before their subject marks are added.
Initialise each student total. Loop from 1 to ClassSize and set TotalMark[StudentCounter] to zero.
Do not reset class counters for each student. They must keep accumulating until all students have been processed.
Do not initialise the question’s input arrays. The question explicitly says their data is already stored.

❓ Guiding questions – think before revealing

Which values must start at zero before counting begins?
Why is TotalMark initialised for every student?
Should StudentName and StudentMark be initialised?

Reveal suggested reasoning

Which values must start at zero before counting begins? DistinctionNo, MeritNo, PassNo and FailNo.

Why is TotalMark initialised for every student? Each student has a separate running total, so every TotalMark element must have a known starting value.

Should StudentName and StudentMark be initialised? No. The question states that both arrays already contain data.

Reveal Cambridge pseudocode for Stage 3

CAMBRIDGE PSEUDOCODE · INITIALISATIONBefore the main processing loop

// Initialise the class grade counters
DistinctionNo ← 0
MeritNo ← 0
PassNo ← 0
FailNo ← 0

// Set each student's running total to zero
FOR StudentCounter ← 1 TO ClassSize
    TotalMark[StudentCounter] ← 0
NEXT StudentCounter

📖 Detailed explanation

Grade counters: they count the number of students who receive each grade. Starting at zero means the first student increments a count to one.

Running total: the total must start at zero; otherwise the first mark would be added to an unknown or leftover value.

Loop range: the specimen mark scheme uses 1 to ClassSize, matching the Cambridge pseudocode indexing used in this question.

AverageMark does not need to be initialised in this exemplar because it is assigned a value before it is read.

⚠️ Common mistakes

Forgetting to initialise one of the four grade counters.
Initialising TotalMark once only, rather than giving each student’s array element a starting value.
Setting the grade counters to zero inside the outer student loop. That would erase earlier students’ counts.
Adding unnecessary code to initialise StudentName or StudentMark, even though the question says they already contain data.

💡 Exam hack / tip

Use the rule “reset accumulators before the loop that uses them”. A student total is reset for each student; a class grade count is reset only once for the entire program.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · initialisation and totallingR1 · total accumulatorR5 · grade countersAO3 · comments explain purpose

The mark scheme exemplar explicitly shows all four grade counters initialised to zero and a loop that initialises each TotalMark element. Initialising the supplied input arrays is not required.

Calculate the combined total mark

Use an outer loop for students and an inner loop for subjects.

R1 · Iteration and totalling

🧠 Step-by-step thinking

Select one student. The outer loop sets StudentCounter to the current student position.
Visit every subject for that student. The inner loop changes SubjectCounter from 1 to SubjectNo.
Read the correct cell. Use StudentMark[StudentCounter, SubjectCounter].
Add it to the current student’s total. Update TotalMark[StudentCounter] each time the inner loop runs.
Finish the inner loop before moving to the next student. When all subjects have been added, the total for the current student is complete.

Worked example · Ali

80 + 75 + 90 + 75 = 320. The running total becomes 80 → 155 → 245 → 320.

❓ Guiding questions – think before revealing

Which loop should change the student position?
Which loop should change the subject position?
Why does the total appear on both sides of the assignment?

Reveal suggested reasoning

Which loop should change the student position? The outer loop changes StudentCounter from 1 to ClassSize.

Which loop should change the subject position? The inner loop changes SubjectCounter from 1 to SubjectNo.

Why does the total appear on both sides of the assignment? The previous running total is added to the current subject mark; otherwise the assignment would overwrite earlier marks.

Reveal Cambridge pseudocode for Stage 4

CAMBRIDGE PSEUDOCODE · NESTED LOOPSCore R1 operation

FOR StudentCounter ← 1 TO ClassSize
    FOR SubjectCounter ← 1 TO SubjectNo
        TotalMark[StudentCounter] ← TotalMark[StudentCounter] +
            StudentMark[StudentCounter, SubjectCounter]
    NEXT SubjectCounter
    // Continue with Stage 5 and Stage 6 before NEXT StudentCounter

📖 Detailed explanation

The outer loop chooses a row in the 2D array. It stays on that student while the inner loop visits all the subject columns.

The expression reads one mark and adds it to the accumulator. It does not replace the total with the current mark.

NEXT SubjectCounter completes the inner loop. The outer StudentCounter loop remains open while the current student’s average, outputs and grade are processed; it closes in Stage 7.

For the sample class, ClassSize = 5 and SubjectNo = 4, so 20 subject marks are visited in total.

⚠️ Common mistakes

Adding StudentMark[SubjectCounter] instead of using both array indexes.
Putting StudentCounter in the subject position or SubjectCounter in the student position.
Using TotalMark[StudentCounter] ← StudentMark[...], which overwrites the previous running total.
Closing the outer loop immediately after NEXT SubjectCounter, before the current student’s average, output and grade have been processed.

💡 Exam hack / tip

Say the array access aloud: “student row, subject column.” Then check the update contains the accumulator on both sides: old total + current mark. That is the key evidence of totalling.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · nested iterationAO2 · totallingR1 · combined total per studentAO3 · logical and accurate loop order

This stage directly addresses R1 in the mark scheme: calculate the total mark for each student using iteration and totalling. A suitable nested loop is the appropriate technique for the given 2D array.

Calculate the rounded average

Round the completed total, then output the name, total and average before grade selection.

R2 · R4 (part)

🧠 Step-by-step thinking

Wait until all marks have been added. The inner subject loop must finish before calculating the average.
Divide by the number of subjects. Every student studies the same number, stored in SubjectNo.
Round to the nearest whole number. The Cambridge exemplar uses INT((total / SubjectNo) + 0.5).
Store the result for the current student. Save the rounded value in AverageMark[StudentCounter].
Use the rounded value for grading. The next stage must compare the integer average with the grade boundaries.

❓ Guiding questions – think before revealing

What value should be used as the divisor?
Why is 0.5 added before INT?
Which individual details are output at this point?

Reveal suggested reasoning

What value should be used as the divisor? SubjectNo, because the average is across the current student’s subjects, not across students.

Why is 0.5 added before INT? For positive marks, adding 0.5 before truncation with INT rounds to the nearest whole number.

Which individual details are output at this point? The student name, combined total and rounded average. The grade is output in the following selection stage.

Reveal Cambridge pseudocode for Stage 5

CAMBRIDGE PSEUDOCODE · ROUNDINGAfter NEXT SubjectCounter

AverageMark[StudentCounter] ←
    INT((TotalMark[StudentCounter] / SubjectNo) + 0.5)

// Output the student's name and calculated marks
OUTPUT "Name ", StudentName[StudentCounter]
OUTPUT "Combined total mark ", TotalMark[StudentCounter]
OUTPUT "Average mark ", AverageMark[StudentCounter]

📖 Detailed explanation

TotalMark[StudentCounter] / SubjectNo calculates the mean mark for the current student.

Adding 0.5 before applying INT rounds a positive value to the nearest integer: values with a fractional part of .5 or more move up.

Boundary example: Eva’s total is 278 across 4 subjects. 278 ÷ 4 = 69.5; 69.5 + 0.5 = 70.0; INT(70.0) gives 70.

This matters because 69.5 rounds to 70 and therefore reaches the distinction boundary.

Output order: the Cambridge exemplar outputs the student name, combined total and rounded average immediately after calculating the average, before entering the grade-selection IF structure in Stage 6.

⚠️ Common mistakes

Calculating the average inside the inner loop, before the total is complete.
Dividing by ClassSize instead of SubjectNo.
Forgetting to round the average to a whole number.
Adding 0.5 after applying INT, which cannot round the original decimal correctly.
Using the total itself for grade selection instead of the average.

💡 Exam hack / tip

Memorise the sequence total ÷ number of values → add 0.5 → INT. Test your formula with a value ending in .5. In Python, do not assume round() always behaves like this Cambridge pseudocode expression at exact half values.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · arithmetic processingR2 · nearest whole numberAO3 · accuracyAO3 · comments explain the calculationR4 · name, total and average output

R2 is explicitly described in the mark scheme as calculating each student’s average mark rounded to the nearest whole number. The exemplar formula is reproduced here.

Select the grade and update its counter

Use the rounded average to award exactly one grade and increment its class counter.

R3 · R5

🧠 Step-by-step thinking

Start with the highest grade. If average is at least 70, award distinction.
Otherwise check merit. The ELSE branch means the average is already below 70, so test whether it is at least 55.
Otherwise check pass. If it is at least 40, award pass.
If none of those conditions is true, award fail. This covers averages below 40.
Increment one counter only. Each branch increases the counter for the grade it awards.

≥ 70 · distinction≥ 55 · merit≥ 40 · pass< 40 · fail

❓ Guiding questions – think before revealing

Why should the highest boundary be tested first?
What happens at exactly 70, 55 and 40?
How many class counters should increase for one student?

Reveal suggested reasoning

Why should the highest boundary be tested first? The nested ELSE structure ensures that once a higher grade is ruled out, only the next lower grade is considered.

What happens at exactly 70, 55 and 40? They qualify for Distinction, Merit and Pass respectively because each condition is inclusive (greater than or equal to).

How many class counters should increase for one student? Exactly one: the counter in the branch that awards that student’s grade.

Reveal Cambridge pseudocode for Stage 6

CAMBRIDGE PSEUDOCODE · NESTED SELECTIONGrade choice and grade counting

IF AverageMark[StudentCounter] >= Distinction
THEN
    DistinctionNo ← DistinctionNo + 1
    OUTPUT "Grade Distinction"
ELSE
    IF AverageMark[StudentCounter] >= Merit
    THEN
        MeritNo ← MeritNo + 1
        OUTPUT "Grade Merit"
    ELSE
        IF AverageMark[StudentCounter] >= Pass
        THEN
            PassNo ← PassNo + 1
            OUTPUT "Grade Pass"
        ELSE
            FailNo ← FailNo + 1
            OUTPUT "Grade Fail"
        ENDIF
    ENDIF
ENDIF

📖 Detailed explanation

Boundary 70: 70 is a distinction because the question says “greater than or equal to 70”.

Boundary 55: a value of 55 that did not qualify for distinction is a merit.

Boundary 40: a value of 40 that did not qualify for merit is a pass.

The final ELSE covers every remaining value below 40. Because the branches are nested, one student cannot be counted in two grades.

⚠️ Common mistakes

Checking the lowest boundary first with separate independent IF statements, allowing more than one grade to be awarded.
Using > instead of >=, which mishandles exact boundary values 70, 55 and 40.
Using ELSE IF in a way that does not match the pseudocode structure expected; the exemplar uses nested IF statements.
Outputting a grade but forgetting to increment its counter, or incrementing the wrong counter.

💡 Exam hack / tip

For ranges with upper limits, test from highest to lowest using >=. The nested ELSE branches automatically exclude the higher grades, so you do not need to repeat “less than 70” and “less than 55” in every condition. The comparison is inclusive: 70, 55 and 40 enter the higher grade at that boundary.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · selectionR3 · correct gradeR5 · increment grade countAO3 · all boundary cases handledR4 · grade output

This stage addresses R3 by selecting one grade, the counting component of R5 by incrementing the matching class counter, and the grade-output component of R4 by displaying the awarded grade with an appropriate message.

Finish the student loop and output the class summary

Close the outer loop only after grade selection, then display the four whole-class counts once.

R4 · R5

🧠 Step-by-step thinking

Finish the current student. The current student’s name, total, average and grade have now been output.
Close the outer loop. NEXT StudentCounter completes this student’s iteration and moves to the next student, until ClassSize is reached.
Wait until the loop has ended. Only after NEXT StudentCounter has finished should the program output the class summary.
Output all four counters. Display DistinctionNo, MeritNo, PassNo and FailNo with appropriate messages.
Check the position. The final four OUTPUT statements must be outside the outer student loop, so they appear once for the whole class.

❓ Guiding questions – think before revealing

Where does NEXT StudentCounter belong?
When should the four class totals be output?
Why must the summary be outside the loop?

Reveal suggested reasoning

Where does NEXT StudentCounter belong? After the current student’s total, average, individual outputs and grade selection have all been completed.

When should the four class totals be output? After NEXT StudentCounter has finished the outer loop.

Why must the summary be outside the loop? The values are whole-class totals; placing them inside the loop would display incomplete counts repeatedly.

Reveal Cambridge pseudocode for Stage 7

CAMBRIDGE PSEUDOCODE · OUTPUTUse inside and after the student loop

// Finish processing the current student and continue the outer loop
NEXT StudentCounter

// Output the final whole-class grade counts once
OUTPUT "Number of Distinctions ", DistinctionNo
OUTPUT "Number of Merits ", MeritNo
OUTPUT "Number of Passes ", PassNo
OUTPUT "Number of Fails ", FailNo

📖 Detailed explanation

NEXT StudentCounter: this is placed after the grade-selection structure, so every student is fully processed before the next iteration begins.

R5 – class summary: the four counters have been incremented during grade selection. After the student loop ends, they contain the final class totals.

Output placement: the four class-count OUTPUT statements appear after NEXT StudentCounter, so the summary is displayed once rather than once per student.

R4 – individual details: the name, combined total and rounded average were output in Stage 5; the grade is output within the relevant branch in Stage 6.

⚠️ Common mistakes

Placing the class-summary outputs inside the student loop, which prints partial counts repeatedly.
Forgetting NEXT StudentCounter or placing it before the grade-selection structure.
Leaving out one of the four class counters, especially FailNo.
Using the wrong counter beside an output label, such as MeritNo beside “Number of Distinctions”.

💡 Exam hack / tip

Draw a horizontal line after NEXT StudentCounter. Everything above it happens once per student; the four class-count outputs below it happen once for the whole class.

Reveal the Cambridge mark-scheme and rubric connection

AO2 · class-summary outputR5 · whole-class countsAO3 · logical loop closureAO3 · complete solution

This stage completes the output component of R5. The mark scheme requires all four class grade counts to be stored and output with appropriate messages after the student-processing loop.

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 arrays, counters and constants.	Meaningful identifiers throughout.
3 · Initialise	R1, R5	Running total and class counters correctly initialised.	Clear comments and reliable starting state.
4 · Total	R1	Nested iteration and totalling.	Accurate index use and loop nesting.
5 · Average	R2, R4 (part)	Rounded average; output name, total and average.	Accurate arithmetic and appropriate messages.
6 · Grade	R3, R4 (grade), R5	Grade selection, grade output and increment exactly one counter.	Correct boundaries and logical branches.
7 · Output	R5 (class summary)	Close the student loop and output four class totals.	Logical loop closure and complete class output.

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 13 · FULL PSEUDOCODECambridge 0478 style · 1-based indexing

// Meaningful identifiers and appropriate data structures are used
// to store the data required by the question
DECLARE TotalMark : ARRAY[1:50] OF INTEGER
DECLARE AverageMark : ARRAY[1:50] OF INTEGER
DECLARE SubjectCounter : INTEGER
DECLARE StudentCounter : INTEGER
DECLARE DistinctionNo : INTEGER
DECLARE MeritNo : INTEGER
DECLARE PassNo : INTEGER
DECLARE FailNo : INTEGER

CONSTANT Distinction = 70
CONSTANT Merit = 55
CONSTANT Pass = 40

// Initialise the grade counters for the whole class
DistinctionNo ← 0
MeritNo ← 0
PassNo ← 0
FailNo ← 0

// Initialise each student's running total
FOR StudentCounter ← 1 TO ClassSize
    TotalMark[StudentCounter] ← 0
NEXT StudentCounter

// Process every student in the class
FOR StudentCounter ← 1 TO ClassSize

    // Calculate the combined total for this student
    FOR SubjectCounter ← 1 TO SubjectNo
        TotalMark[StudentCounter] ← TotalMark[StudentCounter] +
            StudentMark[StudentCounter, SubjectCounter]
    NEXT SubjectCounter

    // Calculate the average rounded to the nearest whole number
    AverageMark[StudentCounter] ←
        INT((TotalMark[StudentCounter] / SubjectNo) + 0.5)

    // Output the student's name and calculated marks
    OUTPUT "Name ", StudentName[StudentCounter]
    OUTPUT "Combined total mark ", TotalMark[StudentCounter]
    OUTPUT "Average mark ", AverageMark[StudentCounter]

    // Select the grade and increment the matching class counter
    IF AverageMark[StudentCounter] >= Distinction
    THEN
        DistinctionNo ← DistinctionNo + 1
        OUTPUT "Grade Distinction"
    ELSE
        IF AverageMark[StudentCounter] >= Merit
        THEN
            MeritNo ← MeritNo + 1
            OUTPUT "Grade Merit"
        ELSE
            IF AverageMark[StudentCounter] >= Pass
            THEN
                PassNo ← PassNo + 1
                OUTPUT "Grade Pass"
            ELSE
                FailNo ← FailNo + 1
                OUTPUT "Grade Fail"
            ENDIF
        ENDIF
    ENDIF

NEXT StudentCounter

// Output the grade totals for the whole class
OUTPUT "Number of Distinctions ", DistinctionNo
OUTPUT "Number of Merits ", MeritNo
OUTPUT "Number of Passes ", PassNo
OUTPUT "Number of Fails ", FailNo

Why this is a complete response

It covers the five mark-scheme requirements: totals (R1), rounded averages (R2), grade selection (R3), per-student output (R4), and whole-class grade counts (R5).

What to check before submitting

Check the nested loop indexes, the rounding expression, the order of the grade boundaries, the position of the final outputs, 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. Watch the inner loop add marks, the average round, a grade get selected, and the class counters increase.

Last tab · Trace player

Sample input → expected results

Five sample students study four subjects (ClassSize = 5; SubjectNo = 4). The sample deliberately tests all four grade outcomes, exact 55 and 40 boundaries, and Eva’s 69.5 average rounding up to 70. These are illustrative values, not data supplied by the examination question.

Input arrays StudentName[] and StudentMark[,]

Student	Subject 1	Subject 2	Subject 3	Subject 4

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

Reveal expected student results and class totals

Expected student results After all calculations

Student	Total	Average	Grade

Distinction2

Merit1

Pass1

Fail1

Execution trace

Step 1 of 1

Initialisation

Initialise the counters

The program begins by setting each grade counter to zero.

DistinctionNo ← 0
MeritNo ← 0
PassNo ← 0
FailNo ← 0

Program output so far

(No student output yet)

Live variable values

Class counters

Distinction0

Merit0

Pass0

Fail0

Ready

Tip: use Next step slowly and watch StudentCounter, SubjectCounter and TotalMark. The subject counter returns to 1 for each new student.

Trace colours: blue row = current student; amber cell = current subject mark; green cells = marks already processed.

Rounding example: Eva’s total is 278, so 278 ÷ 4 = 69.5. The expression INT(69.5 + 0.5) produces 70, which is a distinction.

From student marks to class grade statistics.

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

Given by the question

Additional identifiers

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Initialise the counters and running totals

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Calculate the combined total mark

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Calculate the rounded average

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Select the grade and update its counter

🧠 Step-by-step thinking

❓ Guiding questions – think before revealing

📖 Detailed explanation

⚠️ Common mistakes

💡 Exam hack / tip

Finish the student 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 StudentMark[,]

Expected student results After all calculations

Execution trace

Initialise the counters

Live variable values

Class counters