Problem Solving and Programming - Worksheets, Questions and Revision

13 original exam-style questions - 10 pages of questions with a full mark scheme - free printable PDF.

Download PDF Jump to mark scheme (page 11)Read the revision guide

Next in this strand

Revision Library

revisionlibrary.co.uk

A-Level · Computer Science - Problem Solving and Programming

A2.2 Problem Solving and Programming

OCR H446 · Calculators not allowed · about 170 minutes

Total Marks

Name: _______________________________ Date: ____ / ____ / ______

Answer ALL questions. Show all your working.

A local library is developing a simple program to manage overdue book fines.

(a)State the most appropriate primitive data type for storing each of the following:
(i) the number of books a member has borrowed
(ii) whether a book is currently overdue
(iii) the title of a book(3)

(b)A variable is declared as:

DECLARE bookPrice : REAL

Explain why REAL is a more appropriate data type than INTEGER for storing the price of a book in pounds.(2)

(c)A librarian writes the following algorithm to find the average fine charged, ignoring members with no fine:

count <- 0
total <- 0
FOR i <- 1 TO 5
    INPUT fine
    total <- total + fine
    IF fine > 0 THEN
        count <- count + 1
    ENDIF
NEXT i
average <- total / count
OUTPUT average

The five values entered for fine, in order, are: 0, 2.50, 0, 1.20, 3.30

Complete the trace table below and state the final value output for average.

i	fine	total	count
1	0	___	___
2	2.50	___	___
3	0	___	___
4	1.20	___	___
5	3.30	___	___

(5)

(Total for Question 1 is 10 marks)

A game awards a bonus based on a player's grade, using the following CASE statement:

CASE OF grade
    "A" : bonus <- 50
    "B" : bonus <- 30
    "C" : bonus <- 10
    OTHERWISE : bonus <- 0

ENDCASE

(a)State the value assigned to bonus when grade = "B".(1)

(b)Rewrite the CASE statement above as an equivalent structure using nested IF...THEN...ELSE statements.(4)

(c)Explain one advantage of using a CASE statement rather than nested IF statements in this situation.(2)

(d)A trainee programmer writes this version of the CASE statement:

CASE OF grade
    "A" : bonus = 50
    "B" : bonus <- 30
    OTHERWISE : bonus <- 0

ENDCASE

Identify the error in this code and state how to fix it.(2)

(Total for Question 2 is 9 marks)

A weather station program reads temperatures until a sentinel value of -999 is entered, and finds the maximum temperature recorded:

maxTemp <- -999
INPUT temp
WHILE temp <> -999
    IF temp > maxTemp THEN
        maxTemp <- temp
    ENDIF
    INPUT temp
ENDWHILE
OUTPUT maxTemp

The values entered, in order, are: 14, 21, 9, 18, -999

(a)Complete a trace table showing the value of maxTemp after each temperature is processed, and state the final value output.(5)

(b)Explain what would happen if the very first value entered was -999, and why the output produced would be unhelpful.(2)

(c)A programmer rewrites the loop using REPEAT...UNTIL instead of WHILE. Write a correct REPEAT...UNTIL version of this algorithm, and explain one adjustment that had to be made compared with the WHILE version.(3)

(d)State the name given to the special value (-999) used to end the input loop.(1)

(Total for Question 3 is 11 marks)

A teacher stores the test scores of 3 students, each having sat 4 tests, in a 2D array scores[1:3, 1:4]:

Test1 Test2 Test3 Test4
Student1: 55 62 70 48
Student2: 80 75 90 85
Student3: 40 55 60 65

(a)Write a pseudocode DECLARE statement for the 2D array scores, capable of holding this data.(2)

(b)Write an algorithm to calculate and output the average score for Student2 (row 2) only.(4)

(c)This nested loop sums every score in the array:

total <- 0
FOR row <- 1 TO 3
    FOR col <- 1 TO 4
        total <- total + scores[row, col]
    NEXT col
NEXT row
OUTPUT total

Complete the trace table below, showing the cumulative value of total after each row is fully processed, and state the final value output.

After row 1: total = ___
After row 2: total = ___
After row 3: total = ___(4)

(d)State the value stored in scores[2, 3].(1)

(Total for Question 4 is 11 marks)

A stock system uses product codes in the format "AB-1234": exactly 7 characters, with the first two characters being letters, the third character a hyphen, and the last four characters digits.

(a)Write a function ValidateCode(code : STRING) RETURNS BOOLEAN that checks a product code matches this format, using string handling functions such as LEN, MID and ASC.(6)

(b)State the value returned by MID("AB-1234", 4, 4).(1)

(c)State the value returned by UCASE(LEFT("ab-1234", 2)).(1)

(d)Explain why passing the validation in part (a) does not guarantee that a product code entered is accurate.(2)

(Total for Question 5 is 10 marks)

A programmer writes the following subroutines and main program:

PROCEDURE DoubleValue(BYREF x : INTEGER)
    x <- x * 2
ENDPROCEDURE

FUNCTION AddFive(y : INTEGER) RETURNS INTEGER
    y <- y + 5
    RETURN y
ENDFUNCTION

num1 <- 10
num2 <- 10

DoubleValue(num1)

num2 <- AddFive(num2)
OUTPUT num1
OUTPUT num2

(a)State the values output for num1 and num2.(2)

(b)Explain the difference between passing a parameter by reference and by value, using num1 and num2 as examples.(4)

(c)Rewrite DoubleValue as a function, DoubleValueFunc, that takes its parameter by value and returns the doubled value, without modifying the original argument.(3)

(d)State one reason a programmer might choose to write a subroutine as a procedure rather than a function.(1)

(Total for Question 6 is 10 marks)

A sorted array holds 8 integers with indices 1 to 8:

list = [3, 8, 15, 19, 24, 31, 42, 50]

The function below performs a binary search for a target value:

FUNCTION BinarySearch(list : ARRAY[1:8] OF INTEGER, target : INTEGER) RETURNS INTEGER
    lower <- 1
    upper <- 8
    WHILE lower <= upper
        mid <- (lower + upper) DIV 2
        IF list[mid] = target THEN
            RETURN mid
        ELSE IF list[mid] < target THEN
            lower <- mid + 1
        ELSE
            upper <- mid - 1
        ENDIF
    ENDWHILE
    RETURN -1
ENDFUNCTION

BinarySearch(list, 24) is called.

(a)Complete a trace table showing the values of lower, upper, mid and list[mid] for each iteration of the WHILE loop, until the target 24 is found.(5)

(b)State the number of comparisons with list[mid] needed to locate the value 24.(1)

(c)Explain why binary search cannot reliably be used on the unsorted array [8, 3, 19, 15, 24, 31, 42, 50].(2)

(d)State the time complexity of binary search in Big O notation, and explain why it is more efficient than linear search, O(n), for very large data sets.(3)

(e)Write pseudocode for a function LinearSearch(list : ARRAY[1:8] OF INTEGER, target : INTEGER) RETURNS INTEGER that returns the index of target in list, or -1 if it is not present.(3)

(Total for Question 7 is 14 marks)

The array [8, 3, 6, 1] is to be sorted into ascending order using a bubble sort.

(a)Complete the trace table below, showing the state of the array after each full pass of a standard bubble sort (comparing and swapping adjacent elements left to right), and the number of swaps made in that pass.

Start: [8, 3, 6, 1]
After pass 1: [___] , swaps = ___
After pass 2: [___] , swaps = ___
After pass 3: [___] , swaps = ___
After pass 4: [___] , swaps = ___(4)

(b)State how a bubble sort can be made more efficient by detecting that the array is already sorted, and explain how this is recognised.(2)

(c)Write a procedure BubbleSort(BYREF arr : ARRAY[1:n] OF INTEGER, n : INTEGER) that sorts arr into ascending order, including the early-exit optimisation from part (b).(6)

(d)State the worst-case time complexity of bubble sort in Big O notation.(1)

(Total for Question 8 is 13 marks)

A stack is implemented using an array stack[1:5] with an integer pointer top, initially 0 (empty stack).

(a)State the names of the two operations used to add data to, and remove data from, a stack.(2)

(b)The following sequence of operations is carried out on the empty stack:
Push(5), Push(9), Pop(), Push(3), Push(7), Pop()
Complete a trace table showing the value of top and the contents of the stack after each operation.(5)

(c)Explain why a stack, rather than a queue, is an appropriate data structure for checking that brackets in an expression such as ((a+b)*(c-d)) are balanced.(3)

(d)State one real-world application of a queue in a computer system.(1)

(Total for Question 9 is 11 marks)

The following recursive function is defined:

FUNCTION Mystery(n : INTEGER) RETURNS INTEGER
    IF n = 1 THEN
        RETURN 1
    ELSE
        RETURN n * Mystery(n - 1)
    ENDIF
ENDFUNCTION

(a)State what Mystery(n) calculates.(1)

(b)Complete a trace of the recursive calls made, and the value returned at each stage, for the call Mystery(4).(5)

(c)Explain, using the term "base case", why calling Mystery(0) would cause a runtime error, and state the name commonly given to this type of error.(3)

(d)Rewrite Mystery as an iterative (non-recursive) function, MysteryIterative, using a FOR loop, that calculates the same result for positive integer values of n.(4)

(Total for Question 10 is 13 marks)

A computer system uses 8-bit binary representation for integers.

(a)Convert the denary number 179 to 8-bit binary.(2)

(b)Convert the binary number 10110011 to hexadecimal.(2)

(c)A system stores signed integers using 8-bit two's complement. State the denary value represented by 11101001.(3)

(d)Explain why overflow occurs when adding the 8-bit two's complement numbers 01111111 and 00000001, and state the effect this has on the result.(3)

(e)State the number of distinct values that can be represented using 8-bit two's complement.(1)

(Total for Question 11 is 11 marks)

A program is required to input 10 integer temperature readings (in degrees Celsius) and output: the number of days above 20 degrees Celsius, and whether the average of all 10 readings is a whole number.

(a)Write pseudocode for a complete program that performs this task, including reading 10 temperatures, counting the number above 20 degrees Celsius, calculating the average, and outputting whether the average is a whole number.(8)

(b)The program validates each temperature reading using the rule -50 ≤ temperature ≤ 50. Identify one appropriate test value for each of: normal data, boundary data, and erroneous data, for this validation rule.(3)

(c)Explain why boundary test data is important when testing this validation rule.(2)

(Total for Question 12 is 13 marks)

A software company is developing a mobile app that manages a large, frequently-updated contact list (contacts are regularly added, deleted and searched for). The developers are deciding between using linear search or binary search, and between using a bubble sort or a merge sort, to organise and search the contact data.

Discuss the factors the company should consider when choosing appropriate algorithms and data structures for this application. Your answer should refer to time complexity, the need to keep data sorted for binary search, and the trade-offs of maintaining a sorted list when data changes frequently.

(Total for Question 13 is 8 marks)

Mark scheme · A2.2 Problem Solving and Programming

Question 1

(a) B1 (i) INTEGER
(a) B1 (ii) BOOLEAN
(a) B1 (iii) STRING
(a) Answer: (i) INTEGER (ii) BOOLEAN (iii) STRING
(b) B1 book prices can include a fractional/decimal part (pence), oe
(b) B1 an INTEGER can only store whole numbers, so a price such as 4.99 would be stored inaccurately (e.g. truncated/rounded), oe
(b) Answer: REAL is needed because prices such as GBP 4.99 have a decimal (pence) component that INTEGER cannot store accurately.
(c) B1 i = 1: total = 0, count = 0
(c) B1 i = 2: total = 2.50, count = 1
(c) B1 i = 3 and i = 4: total = 2.50 then 3.70, count = 1 then 2
(c) B1 i = 5: total = 7.00, count = 3
(c) B1 average = 7.00 / 3 = awrt 2.33 (accept 7/3 exact), cao
(c) Answer: average = awrt 2.33

Question 2

(a) B1 bonus = 30, cao
(a) Answer: 30
(b) M1 IF grade = "A" THEN bonus <- 50
(b) M1 nested ELSE IF grade = "B" THEN bonus <- 30
(b) M1 nested ELSE IF grade = "C" THEN bonus <- 10
(b) A1 final ELSE bonus <- 0, with all IF structures correctly closed with ENDIF; any correct logic, ignore minor syntax

(b) Answer:

IF grade = "A" THEN
    bonus <- 50
ELSE
    IF grade = "B" THEN
        bonus <- 30
    ELSE
        IF grade = "C" THEN
            bonus <- 10
        ELSE
            bonus <- 0
        ENDIF
    ENDIF
ENDIF

(c) B1 identifies benefit, e.g. CASE is more readable/easier to follow when testing many discrete values of the same variable, oe
(c) B1 expands the point, e.g. avoids deeply nested IF statements, which are harder to trace, maintain and debug, oe
(c) Answer: CASE is clearer than deeply nested IF statements when checking several discrete values of one variable, reducing the chance of logic errors.
(d) B1 identifies that the "A" branch uses "=" instead of the assignment operator
(d) B1 states the correction: bonus <- 50
(d) Answer: The line "A" : bonus = 50 uses "=" (comparison) instead of "<-" (assignment); it should read "A" : bonus <- 50

Question 3

(a) B1 temp = 14: maxTemp becomes 14
(a) B1 temp = 21: maxTemp becomes 21
(a) B1 temp = 9: maxTemp stays 21
(a) B1 temp = 18: maxTemp stays 21
(a) B1 loop ends at temp = -999; OUTPUT is 21, cao
(a) Answer: 21
(b) B1 the WHILE condition is false immediately, so the loop body never executes, oe
(b) B1 maxTemp remains at its initial value of -999, which is output but is not a real/possible temperature reading, oe
(b) Answer: The loop would never run and -999 (an invalid placeholder, not a real temperature) would be output.
(c) M1 correct REPEAT structure with INPUT temp inside the loop and UNTIL temp = -999
(c) M1 an IF guard added so the sentinel value itself is not compared/assigned to maxTemp, e.g. IF temp <> -999 THEN ... ENDIF around the comparison
(c) A1 correct explanation that REPEAT checks its condition after the body has run at least once (post-condition loop), unlike WHILE (pre-condition loop), so extra logic is needed to avoid processing the sentinel

REPEAT
    INPUT temp
    IF temp <> -999 THEN
        IF temp > maxTemp THEN
            maxTemp <- temp
        ENDIF
    ENDIF
UNTIL temp = -999
OUTPUT maxTemp

Adjustment: REPEAT always executes at least once, so an IF guard is needed to stop the sentinel value being treated as a real temperature.

(d) B1 sentinel value (accept rogue value)
(d) Answer: Sentinel value

Question 4

(a) B1 correct 2D array syntax with bounds [1:3, 1:4], oe equivalent bounds
(a) B1 correct data type OF INTEGER
(a) Answer: DECLARE scores : ARRAY[1:3, 1:4] OF INTEGER
(b) M1 total <- 0 initialised before the loop
(b) M1 FOR col <- 1 TO 4 loop
(b) M1 total <- total + scores[2, col] inside the loop, correctly indexing row 2
(b) A1 average <- total / 4 and OUTPUT average, correct value 82.5; any correct logic, ignore minor syntax

(b) Answer:

total <- 0
FOR col <- 1 TO 4
    total <- total + scores[2, col]
NEXT col
average <- total / 4
OUTPUT average

Output = 82.5

(c) B1 after row 1: total = 235
(c) B1 after row 2: total = 565
(c) B1 after row 3: total = 785
(c) B1 final OUTPUT value = 785, cao
(c) Answer: 785
(d) B1 90, cao
(d) Answer: 90

Question 5

(a) M1 checks LEN(code) = 7 and sets valid to false if not
(a) M1 checks position 3 equals "-" using MID(code, 3, 1)
(a) M1 loop/checks over positions 1-2, confirming each is a letter (e.g. using ASC ranges for "A" to "Z")
(a) M1 loop/checks over positions 4-7, confirming each is a digit (e.g. using ASC ranges for "0" to "9")
(a) M1 correct use of MID to extract each character being tested
(a) A1 returns a single BOOLEAN value combining all checks correctly; any correct logic, ignore minor syntax

(a) Answer:

FUNCTION ValidateCode(code : STRING) RETURNS BOOLEAN
    valid <- true
    IF LEN(code) <> 7 THEN
        valid <- false
    ELSE
        IF MID(code, 3, 1) <> "-" THEN
            valid <- false
        ENDIF
        FOR i <- 1 TO 2
            letter <- MID(code, i, 1)
            IF (ASC(letter) < ASC("A")) OR (ASC(letter) > ASC("Z")) THEN
                valid <- false
            ENDIF
        NEXT i
        FOR i <- 4 TO 7
            digit <- MID(code, i, 1)
            IF (ASC(digit) < ASC("0")) OR (ASC(digit) > ASC("9")) THEN
                valid <- false
            ENDIF
        NEXT i
    ENDIF
    RETURN valid
ENDFUNCTION

(b) B1 "1234", cao
(b) Answer: "1234"
(c) B1 "AB", cao
(c) Answer: "AB"
(d) B1 validation only checks that data conforms to a set of format rules (length, character types, hyphen position), oe
(d) B1 it does not check the data represents a real/correct product, e.g. "ZZ-9999" could pass validation without being an actual issued code, oe
(d) Answer: Validation checks the code's format, not whether it corresponds to a real product; a well-formatted but invented code would still pass.

Question 6

(a) B1 num1 = 20
(a) B1 num2 = 15
(a) Answer: num1 = 20, num2 = 15
(b) B1 passing by reference passes the memory address/reference of the actual variable into the subroutine, oe
(b) B1 so changes made to the parameter (x <- x * 2) directly change the original variable, num1, giving 20, oe
(b) B1 passing by value copies the value of the argument into a new, separate local variable, oe
(b) B1 so changes to y inside AddFive do not directly change num2; num2 only changes because the returned value is explicitly assigned back to it, oe
(b) Answer: By reference links the parameter directly to the caller's variable, so DoubleValue permanently changes num1. By value copies the data, so AddFive cannot change num2 directly; num2 is only updated because its new value is returned and reassigned.
(c) M1 correct FUNCTION header with a by-value parameter (no BYREF) and RETURNS INTEGER
(c) M1 correct calculation, e.g. RETURN x * 2 or result <- x * 2
(c) A1 correct RETURN statement, and the original argument is not modified since the parameter is passed by value; any correct logic, ignore minor syntax

FUNCTION DoubleValueFunc(x : INTEGER) RETURNS INTEGER
    RETURN x * 2
ENDFUNCTION

(d) B1 a procedure is appropriate when the subroutine performs an action (e.g. output, or modifying data via reference parameters) and does not need to return a single value, oe
(d) Answer: Procedures are used when no value needs to be returned, e.g. the subroutine only needs to perform an action or modify parameters passed by reference.

Question 7

(a) B1 iteration 1: lower=1, upper=8, mid=4, list[4]=19; 19<24 so lower becomes 5
(a) B1 iteration 2: lower=5, upper=8, mid=6, list[6]=31; 31>24 so upper becomes 5
(a) B1 iteration 3: lower=5, upper=5, mid=5, list[5]=24; match found
(a) B1 correct comparison/decision applied at each step (equal / less than / greater than target)
(a) B1 final index returned = 5, cao
(a) Answer: Index 5 (list[5] = 24)
(b) B1 3, cao
(b) Answer: 3
(c) B1 binary search relies on the data being sorted so that comparing the middle value with the target tells you which half to discard, oe
(c) B1 on unsorted data this less-than/greater-than comparison is not reliable, so a whole half of the array could be discarded even though it contains the target, oe
(c) Answer: Binary search assumes ordering to eliminate half the search space each time; on unsorted data that assumption fails and the target could be discarded incorrectly.
(d) B1 O(log n)
(d) B1 explains that binary search halves the search space at each step, whereas linear search may check every item, oe
(d) B1 as n grows very large, log n grows far more slowly than n, so binary search needs far fewer comparisons in the worst case, oe
(d) Answer: O(log n); it is faster than O(n) linear search for large n because each comparison eliminates half the remaining data rather than checking one item at a time.
(e) M1 loop through each index of the array, e.g. FOR i <- 1 TO 8
(e) M1 compares list[i] to target and returns i as soon as a match is found
(e) A1 returns -1 after the loop completes with no match found; any correct logic, ignore minor syntax

(e) Answer:

FUNCTION LinearSearch(list : ARRAY[1:8] OF INTEGER, target : INTEGER) RETURNS INTEGER
    FOR i <- 1 TO 8
        IF list[i] = target THEN
            RETURN i
        ENDIF
    NEXT i
    RETURN -1
ENDFUNCTION

Question 8

(a) B1 pass 1: [3, 6, 1, 8], swaps = 3
(a) B1 pass 2: [3, 1, 6, 8], swaps = 1
(a) B1 pass 3: [1, 3, 6, 8], swaps = 1
(a) B1 pass 4: [1, 3, 6, 8], swaps = 0 (array already sorted)
(a) Answer: Sorted array: [1, 3, 6, 8]
(b) B1 use a boolean flag (e.g. swapped) that is reset to false at the start of each pass, oe
(b) B1 if no swaps occur during a full pass, the flag stays false, meaning the array is fully sorted, so the algorithm can stop early instead of running further unnecessary passes, oe
(b) Answer: Use a flag that records whether any swap occurred in a pass; if a whole pass completes with no swaps, the array is sorted and the algorithm can terminate early.
(c) M1 outer loop controlled by a swapped flag, e.g. WHILE swapped = true
(c) M1 swapped is reset to false at the start of each pass
(c) M1 inner FOR loop comparing each pair of adjacent elements, e.g. FOR j <- 1 TO n - 1
(c) M1 correct swap of arr[j] and arr[j+1] using a temporary variable when arr[j] > arr[j+1]
(c) M1 swapped is set to true whenever a swap occurs
(c) A1 algorithm correctly terminates once a full pass makes no swaps; any correct logic, ignore minor syntax

PROCEDURE BubbleSort(BYREF arr : ARRAY[1:n] OF INTEGER, n : INTEGER)
    DECLARE i, j, temp : INTEGER
    DECLARE swapped : BOOLEAN
    swapped <- true
    WHILE swapped = true
        swapped <- false
        FOR j <- 1 TO n - 1
            IF arr[j] > arr[j + 1] THEN
                temp <- arr[j]
                arr[j] <- arr[j + 1]
                arr[j + 1] <- temp
                swapped <- true
            ENDIF
        NEXT j
    ENDWHILE
ENDPROCEDURE

(d) B1 O(n²)
(d) Answer: O(n²)

Question 9

(a) B1 Push (add data)
(a) B1 Pop (remove data)
(a) Answer: Push and Pop
(b) B1 Push(5): top=1, stack=[5]
(b) B1 Push(9): top=2, stack=[5,9]
(b) B1 Pop() returns 9: top=1, stack=[5]
(b) B1 Push(3) then Push(7): top=3, stack=[5,3,7]
(b) B1 Pop() returns 7: top=2, stack=[5,3] (final state)
(b) Answer: Final state: top = 2, stack contents [5, 3]
(c) B1 a stack is LIFO (last in, first out), oe
(c) B1 each opening bracket is pushed onto the stack, and each closing bracket should match (pop) the most recently pushed, still-unmatched opening bracket, oe
(c) B1 if the stack is empty at the end (and never needed to pop from empty) the brackets are balanced; a queue's FIFO order would not correctly match the most recent unmatched bracket, oe
(c) Answer: A stack's LIFO behaviour naturally matches each closing bracket with the most recently opened, still-unclosed bracket; a FIFO queue would match brackets in the wrong order.
(d) B1 any valid example, e.g. a print queue, a task/process scheduling queue, a keyboard input buffer
(d) Answer: Example: a print queue, where documents are printed in the order they were sent.

Question 10

(a) B1 n factorial (n!), for positive integer n
(a) Answer: n factorial
(b) B1 Mystery(4) calls Mystery(3), which calls Mystery(2), which calls Mystery(1), correctly shown in sequence
(b) B1 Mystery(1) is the base case (n=1) and returns 1
(b) B1 Mystery(2) returns 2 * 1 = 2
(b) B1 Mystery(3) returns 3 * 2 = 6
(b) B1 Mystery(4) returns 4 * 6 = 24, cao
(b) Answer: Mystery(4) = 24
(c) B1 the base case is n = 1, but starting from n = 0 and repeatedly subtracting 1 gives 0, -1, -2, ... which never exactly equals 1, oe
(c) B1 so the base case is never reached and the function calls itself indefinitely (infinite recursion), oe
(c) B1 each call uses memory on the call stack; because the recursion never stops, this is called a stack overflow
(c) Answer: Because n decreases past 1 without ever equalling it, the base case (n=1) is never reached, causing infinite recursion and a stack overflow.
(d) M1 result initialised to 1 before the loop
(d) M1 FOR loop iterating from 1 to n (e.g. FOR i <- 1 TO n)
(d) M1 result <- result * i inside the loop
(d) A1 correct RETURN result after the loop; any correct logic, ignore minor syntax

(d) Answer:

FUNCTION MysteryIterative(n : INTEGER) RETURNS INTEGER
    result <- 1
    FOR i <- 1 TO n
        result <- result * i
    NEXT i
    RETURN result
ENDFUNCTION

Question 11

(a) M1 correct place values used (128,64,32,16,8,4,2,1) with correct bits identified
(a) A1 10110011, cao
(a) Answer: 10110011
(b) M1 splits into two 4-bit nibbles: 1011 and 0011
(b) A1 B3, cao
(b) Answer: B3
(c) M1 recognises the MSB is 1, so the number is negative
(c) M1 correctly inverts the bits and adds 1 (00010110 + 1 = 00010111), or uses correct negative place-value weighting
(c) A1 -23, cao
(c) Answer: -23
(d) B1 01111111 represents the largest positive value storable in 8-bit two's complement (127), oe
(d) B1 binary addition gives 10000000, but with two's complement this bit pattern represents -128, oe
(d) B1 the result of adding two positive numbers has incorrectly become negative because there are not enough bits to store the true result (128), which is overflow, oe
(d) Answer: 01111111 + 00000001 = 10000000, which as two's complement represents -128, not the correct positive result (128); this incorrect sign change is overflow, caused by the result exceeding the range that 8 bits can represent.
(e) B1 256 (2⁸)
(e) Answer: 256

Question 12

(a) M1 total and count20 initialised to 0 before the loop
(a) M1 FOR loop running exactly 10 times
(a) M1 INPUT temp inside the loop
(a) M1 running total correctly updated (total <- total + temp)
(a) M1 correct selection test (temp > 20) and count20 incremented when true
(a) M1 count20 correctly output after the loop
(a) M1 average correctly calculated as total / 10
(a) A1 correct test for whether the average is a whole number (e.g. total MOD 10 = 0) with an appropriate message output in both cases; any correct logic, ignore minor syntax

(a) Answer:

total <- 0
count20 <- 0
FOR i <- 1 TO 10
    INPUT temp
    total <- total + temp
    IF temp > 20 THEN
        count20 <- count20 + 1
    ENDIF
NEXT i
OUTPUT "Days above 20 degrees: ", count20
average <- total / 10
IF total MOD 10 = 0 THEN
    OUTPUT "The average is a whole number: ", average
ELSE
    OUTPUT "The average is not a whole number: ", average
ENDIF

(b) B1 normal data: any value clearly within range, e.g. 15 (should be accepted)
(b) B1 boundary data: a value exactly on a limit, e.g. 50 or -50 (should be accepted)
(b) B1 erroneous data: a value outside the range or wrong type, e.g. 75 or "hot" (should be rejected)
(b) Answer: Normal: 15. Boundary: 50 (or -50). Erroneous: 75 (or a non-numeric value such as "hot").
(c) B1 boundary values test the exact edges of the accepted range, which is where off-by-one errors (e.g. using < instead of ≤) are most likely to occur, oe
(c) B1 testing values exactly on the limit confirms whether the validation correctly accepts (or rejects) them as intended by the specification, oe
(c) Answer: Boundary values check that the comparison operators (≤, ≥) are correct at the exact edges of the valid range, where logic errors such as excluding a valid limit value are most likely.