OCR GCSE Computer Science Paper 2Computational thinking, algorithms and programming — every question, answered

What it’s really asking

Trace an algorithm that builds a staff ID by casting a year to a string, concatenating it onto a surname, then padding the result with x characters in a while loop until it reaches 10 characters long.

What the mark scheme rewarded

• Kofi2021 appearing as staffID on line 03, Kofi2021x appearing as staffID on the first pass through line 05, Kofi2021xx appearing as staffID on the second pass through line 05, and ID Kofi2021xx being the one and only output, on line 07

Traps examiners saw

• Forgetting the loop runs twice, not once, since 8 then 9 are both still less than 10
• Writing three x characters instead of two, which would take staffID to 11 characters and never actually satisfy the while condition at exactly 10

Full-mark self-check 0 of 3

What it’s really asking

Trace a DO UNTIL loop that starts a counter at 3, prints it, decrements it by 1 each pass, and keeps going until the counter reaches -1, then prints Finished.

What the mark scheme rewarded

• Start set to 3 with 3 output on line 03, the values 2, 1 and 0 output on the next three passes with start correctly updated to 2, 1, 0 and -1 on the matching lines, and Finished output once on line 06

Traps examiners saw

• Checking UNTIL start == -1 before the first print, which is how a WHILE loop works, not a DO UNTIL loop
• Printing an extra row once start equals -1, when the loop should have already stopped

Full-mark self-check 0 of 3

What it’s really asking

Trace a nested selection algorithm that awards a javelin score based on distance thrown, then doubles that score if the student is not in year 11.

What the mark scheme rewarded

• javelinThrow and yearGroup set correctly on lines 01 and 02, score set to 2 on line 06, score set to 4 on line 11, and The score is 4 output once on line 13 with no additional output

Traps examiners saw

• Doubling the score before the first IF chain has actually set it, which would double the wrong starting value
• Adding a comma into the printed output, which the mark scheme specifically does not credit

Full-mark self-check 0 of 3

What it’s really asking

Draw the three logic gates, an OR gate, a NOT gate, and a final AND gate, needed to build the circuit for the expression P = (A OR B) AND NOT C, in the correct arrangement.

What the mark scheme rewarded

• An OR gate combining A and B, a NOT gate inverting C with a correctly drawn inversion circle, and a final AND gate combining the outputs of the first two gates to produce P, with no other gate carrying an inversion circle

Traps examiners saw

• Putting an inversion circle on the AND gate instead of the NOT gate, which produces the wrong logic entirely
• Feeding C directly into the final AND gate instead of feeding in the output of the NOT gate

Full-mark self-check 0 of 3

What it’s really asking

Work out which single logic gate, OR or AND, produced each of two given two-input truth tables, by reading the pattern of 0s and 1s in each output column.

What the mark scheme rewarded

• Truth table 1 correctly identified as an OR gate and truth table 2 correctly identified as an AND gate, based on the genuine output pattern each table shows

Traps examiners saw

• Swapping the two answers around, since the tables look superficially similar at a glance if not read row by row
• Naming a two-input gate as NOT, which only ever takes a single input and cannot produce either of these tables

Full-mark self-check 0 of 3

What it’s really asking

Work out the output P for all eight possible combinations of three Boolean inputs A, B and C, by evaluating (A AND B) first and then combining that result with C using OR.

What the mark scheme rewarded

• The correct P value for every pair of rows in the eight-row table, one mark per pair, evaluating (A AND B) first and then combining with C using OR

Traps examiners saw

• Assuming the table is grouped with all four C equals 0 rows first and all four C equals 1 rows after, when OCR's actual layout alternates C every single row within each A, B pair
• Evaluating (A AND B) OR C as if it were A AND (B OR C), which changes which rows come out as 1

Full-mark self-check 0 of 3

What it’s really asking

Find and fix two bugs in a program meant to total how many people are staying in a nine-room hotel: a FOR loop that starts at 1 instead of 0, skipping room 0 entirely, and a total that gets reset to 0 inside the loop on every single pass.

What the mark scheme rewarded

• Changing the loop bounds so it starts at 0 rather than 1, and moving total = 0 so it only runs once, before the loop, rather than on every pass

Traps examiners saw

• Fixing only the loop bounds and missing that total is still being wiped on every pass
• Moving total = 0 to after the loop instead of before it, which is still a logic error since it discards the whole calculation

Full-mark self-check 0 of 3

What it’s really asking

Find and fix two bugs in an algorithm meant to total every element of a 0-indexed array scores: a FOR loop that starts at 1 instead of 0, skipping the first element, and a line that overwrites scores[scoreCount] with total plus total instead of adding scores[scoreCount] onto the running total.

What the mark scheme rewarded

• Line 02 correctly identified and fixed to start the loop at 0, and line 03 correctly identified and fixed so total accumulates each array element rather than the array being overwritten with total doubled

Traps examiners saw

• Fixing the loop bound but leaving line 03's assignment backwards, which still corrupts the array and never produces a correct total
• Fixing the accumulation formula but forgetting scoreCount must start at 0 for the total to be fully correct

Full-mark self-check 0 of 3

What it’s really asking

Find and fix two bugs in an algorithm meant to add two input numbers and report success or warning depending on whether the total falls between 10 and 20 inclusive: a copy-paste typo that adds num1 to itself instead of to num2, and a boundary condition that only checks the lower bound, never the upper one.

What the mark scheme rewarded

• Line 03 correctly identified and fixed so total genuinely adds num1 and num2, and line 04 correctly identified and fixed so the condition checks both the 10 and the 20 boundary using AND, not just the lower one

Traps examiners saw

• Fixing the addition on line 03 but leaving the boundary check on line 04 only testing the lower limit
• Writing total >= 10 and total >= 20, which is logically impossible to combine into a sensible upper bound and never fires correctly

Full-mark self-check 0 of 3

What it’s really asking

Write a function taking nights and room as parameters that works out the total cost using the stated nightly rates, 60 pounds for a basic room, 80 pounds for a premium room, and returns that total, without validating the parameters.

What the mark scheme rewarded

• A function header correctly named newPrice with both nights and room as parameters, a correct calculation using the two real nightly rates for whichever room type was passed in, and the calculated price returned rather than printed

Traps examiners saw

• Asking for fresh input inside the function instead of using the nights and room parameters that were already passed in
• Printing the price instead of returning it, which fails the specification even if the calculation itself is correct

Full-mark self-check 0 of 3

What it’s really asking

Write a procedure taking a string of data and a filename as parameters that opens the named text file, writes the data string into it, and closes the file again.

What the mark scheme rewarded

• A genuine procedure definition, not a call, named SaveLogs with two parameters, opening a file using the filename parameter, writing the data parameter into the open file, and closing the file afterwards

Traps examiners saw

• Writing code that calls SaveLogs() rather than defining it, which earns no marks for the definition itself
• Hard-coding a fixed filename instead of using the filename parameter that was actually passed in

Full-mark self-check 0 of 3

What it’s really asking

Complete a function taking direction and position as parameters that moves the character 5 places left or right, then clamps the result back into the valid range of 1 to 512 inclusive before returning the new position.

What the mark scheme rewarded

• Correct use of both parameters with no extra input, a correct move of 5 in the direction actually passed in, position correctly clamped to 1 if it would go below 1 or to 512 if it would go above 512, and the updated position returned

Traps examiners saw

• Checking the bounds before applying the move, which clamps the wrong, old position
• Re-inputting direction or position inside the function instead of using the two parameters that were already passed in

Full-mark self-check 0 of 3

What it’s really asking

Fix a broken SQL statement, which uses SELECT ALL and an IF clause instead of proper syntax, so that it correctly displays every field for bookings staying more than one night from the table TblBookings.

What the mark scheme rewarded

• A genuine field list or SELECT * replacing the invalid SELECT ALL, FROM TblBookings kept correct, WHERE replacing the invalid IF keyword, and the condition itself correctly reading nights greater than 1, not less than 1

Traps examiners saw

• Keeping the broken IF keyword instead of replacing it with WHERE, which is not valid SQL
• Writing nights < 1, which is the exact comparison direction the broken version wrongly used, filtering for almost no bookings instead of the ones actually wanted

Full-mark self-check 0 of 3

What it’s really asking

Write a SELECT statement against the events table that displays only the SensorID field, filtered to rows where SensorType is Door and Length is more than 20, combining both conditions.

What the mark scheme rewarded

• SensorID selected as the only displayed field, the correct table name events, and a WHERE clause combining Length > 20 and SensorType = Door with AND, in either order

Traps examiners saw

• Joining the two conditions with OR instead of AND, which would also return every long trigger of any sensor type
• Selecting every field with SELECT * when the question specifically asks only for the sensor IDs

Full-mark self-check 0 of 3

What it’s really asking

Complete a partially given SELECT statement so it displays TeamName alongside the already-shown StudentID field, from the correct table, filtered to rows where YearGroup equals 11.

What the mark scheme rewarded

• TeamName correctly added to the already-given StudentID field list, the table named exactly TblResult, and a WHERE clause correctly filtering to YearGroup = 11

Traps examiners saw

• Selecting every field with * instead of the two specifically asked for
• Misspelling the table name as TblResults, with an extra s, which the mark scheme specifically penalises

Full-mark self-check 0 of 3

What it’s really asking

Write a program that checks three separate rules on a hotel booking, firstName and surname are not empty, room is basic or premium, nights is between 1 and 5 inclusive, and outputs ALLOWED only if all three pass, or NOT ALLOWED if any one fails.

What the mark scheme rewarded

• A genuine attempt at all three stated checks, presence check on the names, look-up check on room, range check on nights covering both 1 and 5 inclusive, and correct output logic that only prints ALLOWED when every check has genuinely passed

Traps examiners saw

• Using nights <= 1 or nights >= 5 for the range check, which would wrongly reject the two valid boundary values themselves
• Printing ALLOWED as soon as one check passes, rather than only once every check has passed

Full-mark self-check 0 of 4

What it’s really asking

Name two real validation techniques and explain, specifically for this addition game which asks the player to add two random whole numbers between 1 and 10, how each one would actually be applied to the player's typed answer.

What the mark scheme rewarded

• Two genuinely different validation methods named correctly, each with an explanation of how it applies specifically to the addition game's own real rules, not a generic description unconnected to the game

Traps examiners saw

• Naming a validation method but only describing what it means in general, without tying it to this specific game's real numbers
• Naming two methods that are really the same idea under different names, such as range check and boundary check used to describe an identical rule twice

Full-mark self-check 0 of 3

What it’s really asking

Write an algorithm that inputs a high jump height in centimetres and outputs VALID only if it falls between 40.0 and 180.0 inclusive, or NOT VALID otherwise.

What the mark scheme rewarded

• The height correctly input and stored, both the minimum, 40, and maximum, 180, boundaries checked, and VALID or NOT VALID correctly output depending on whether the height genuinely satisfies both boundaries

Traps examiners saw

• Using > and < instead of >= and <=, which would wrongly reject a height of exactly 40.0 or exactly 180.0
• Checking only one of the two boundaries, which would wrongly accept an impossibly large or negative height

Full-mark self-check 0 of 3

What it’s really asking

Write an algorithm that first asks how many numbers to add up, then loops that many times taking a number each pass and adding it to a running total, then outputs both the total and the average once the loop finishes.

What the mark scheme rewarded

• An input step with a message that stores the quantity, total initialised to 0 before the loop, the loop correctly repeating that many times using the input quantity, the running total correctly accumulating each new number, and both total and average correctly calculated and output after the loop finishes

Traps examiners saw

• Initialising total inside the loop, which wipes it back to 0 on every single pass, the same bug this paper tests directly as a logic error elsewhere
• Calculating the average using a fixed number instead of the actual quantity num the user entered

Full-mark self-check 0 of 4

What it’s really asking

Write an algorithm that asks the player three addition questions, each adding two random whole numbers between 1 and 10, adds 1 to a running score for each correct answer, and displays the final score once all three rounds are done.

What the mark scheme rewarded

• score initialised to 0 before the loop, a loop repeating exactly three times, two genuinely new random numbers generated each round, the player's input checked against the real sum with 1 added to score on a correct answer, and score output once at the end

Traps examiners saw

• Generating the two random numbers once before the loop and reusing the same pair for all three questions
• Outputting score after every single question instead of once, at the end, after all three rounds

Full-mark self-check 0 of 4

What it’s really asking

Write an algorithm that keeps asking for a team name and score until the user types stop, keeps track of the highest score seen so far and which team it belongs to, and outputs the winning team's name and score once input stops.

What the mark scheme rewarded

• A genuine sentinel-controlled loop that repeats until stop is entered, a team name and score input and stored on every pass, the highest score correctly tracked and updated alongside its matching team name, and both the winning team name and score output once the loop has finished

Traps examiners saw

• Using a FOR loop with a fixed number of repeats instead of a WHILE loop controlled by the sentinel value stop
• Updating highscore without also updating highteam in the same branch, which would leave the winning name pointing at the wrong team

Full-mark self-check 0 of 4

What it’s really asking

Show the real steps a merge sort takes on the eight-number list 45, 12, -99, 100, -13, 0, 17, -27: merging the eight single-item lists into sorted pairs of two, then into sorted groups of four, then into one final sorted list of eight.

What the mark scheme rewarded

• Merging into correctly sorted lists of size 2, then correctly merging those into sorted lists of size 4, then correctly merging those into the one final sorted list of size 8

Traps examiners saw

• Sorting the final list correctly but skipping the intermediate size-2 and size-4 merge steps the question specifically asks to see
• Merging lists in the wrong original order, rather than the adjacent pairs the initial split actually produced

Full-mark self-check 0 of 3

What it’s really asking

State one genuine, specific difference in how an insertion sort and a bubble sort actually move data, rather than a vague claim that one is better than the other.

What the mark scheme rewarded

• One genuine, specific mechanical difference between how insertion sort and bubble sort move data, such as insertion sort inserting values into a growing sorted section versus bubble sort only ever swapping adjacent pairs

Traps examiners saw

• Giving only a vague efficiency claim, bubble sort is worse, with no real mechanism described
• Describing a similarity, both use loops, both compare values, when the question specifically asks for a difference

Full-mark self-check 0 of 2

What it’s really asking

Trace a binary search for the number 10 across the seven-item sorted list 1, 2, 5, 6, 7, 10, 20, showing which middle value gets picked and discarded on each real comparison until 10 is found.

What the mark scheme rewarded

• The correct middle value, 6, picked from the real given list, the correct half, the left half, since 10 is larger than 6, discarded, and the correct second middle value, 10, picked from the real remaining list, matching the target

Traps examiners saw

• Picking the wrong middle value when a remaining list has an even number of items, though this specific list stays an odd length throughout its own trace
• Continuing to compare after the target has already been found on the second comparison

Full-mark self-check 0 of 3