Computer Science (9-1) 0984 | Paper 2 Mock 01 | Algorithms, Programming and Logic

(a) The algorithm must iterate through every element in Data[1:20] and check whether it already appears in a growing Unique array. If the element has not been seen before, it is added to Unique and the counter is incremented. [6]

DECLARE Data : ARRAY[1:20] OF INTEGER
DECLARE Unique : ARRAY[1:20] OF INTEGER
DECLARE UniqueCount : INTEGER
DECLARE i : INTEGER
DECLARE j : INTEGER
DECLARE IsDuplicate : BOOLEAN

UniqueCount ← 0

FOR i ← 1 TO 20
    IsDuplicate ← FALSE
    FOR j ← 1 TO UniqueCount
        IF Data[i] = Unique[j] THEN
            IsDuplicate ← TRUE
        ENDIF
    NEXT j
    IF IsDuplicate = FALSE THEN
        UniqueCount ← UniqueCount + 1
        Unique[UniqueCount] ← Data[i]
    ENDIF
NEXT i

OUTPUT "Number of unique values: ", UniqueCount

The outer loop visits each element of Data in turn [1]. The inner loop scans all values already stored in Unique to test for a duplicate [1]. The flag IsDuplicate records whether a match was found [1]. Only when no match is found is the value appended and the counter advanced [1]. Initialising UniqueCount to 0 ensures the inner loop does not execute on the first element, so the first value is always added [1].

(b) Trace for the first 5 elements of the input array [4, 7, 4, 2, 7, ...]: [3]

The first two elements are new, so both are added [1]. When 4 is encountered again it matches Unique[1], so it is skipped [1]. The value 2 is new, but the second 7 matches Unique[2] [1].

(c) Best case: UniqueCount = 1, which occurs when all 20 elements hold the same value. Worst case: UniqueCount = 20, which occurs when every element is different. [1]

(a) Trace table for Shop 1 (the inner loop with Shop = 1): [2]

[1] for correct Sales values from the table, [1] for correct running totals (each row adds the Sales value to the previous ShopTotal).

ShopTotal is reset to 0 before each shop's inner loop begins. For Shop 1: 0+120=120, 120+150=270, 270+130=400, 400+140=540.

(b) The three lines of output: [3]

Shop 1 total: 540
Shop 2 total: 780
Shop 3 total: 395

[1] for Shop 1 = 10+20+15 is wrong - wait, for the OUTPUT, Shop 1 uses the Sales array: 120+150+130+140 = 540. [1] for Shop 2 = 200+180+210+190 = 780. [1] for Shop 3 = 90+110+100+95 = 395.

(c) Pseudocode to find the highest single weekly sales figure: [1]

DECLARE Highest : INTEGER
Highest <- Sales[1, 1]
FOR Shop <- 1 TO 3
    FOR Week <- 1 TO 4
        IF Sales[Shop, Week] > Highest
            THEN
                Highest <- Sales[Shop, Week]
        ENDIF
    NEXT Week
NEXT Shop
OUTPUT "Highest: ", Highest

The algorithm initialises Highest to the first element (Sales[1,1] = 120), then uses nested loops to check every element in the 2D array. Whenever a value exceeds the current Highest, it replaces it. The expected answer is 210 (Shop 2, Week 3).

(a) The flowchart repeatedly divides N by 2 (integer division) and increments Count, stopping when N is no longer greater than 1:

Each iteration halves N and adds 1 to Count. After 4 iterations, N reaches 1 and the loop exits. [4]

(b) The output is 4. [1]

(c) The algorithm calculates how many times N can be halved (using integer division by 2) before reaching 1. [1] For inputs that are exact powers of 2, this gives the exponent, equivalent to log base 2 of N. For example, 16 = 2⁴, so Count = 4. For non-powers of 2, integer division still counts the halvings, but the result is the floor of log₂(N). [1] [2]

(a) SQL query for items below reorder level: [2]

SELECT *
FROM STOCK
WHERE QuantityInStock < ReorderLevel

This compares two fields within the same record. From the data, only WH002 (Rubber Washer: quantity 80, reorder level 200) satisfies the condition where 80 < 200.

(b) SQL INSERT statement for a new item: [3]

INSERT INTO STOCK (ItemCode, Description, Supplier,
    QuantityInStock, ReorderLevel, UnitCost)
VALUES ('WH006', 'Nylon Strap', 'SealParts',
    400, 150, 0.30)

All six values must be provided in the correct order matching the field list. String values are enclosed in single quotes; numeric values are written directly.

(c) SQL query for total stock value per supplier: [3]

SELECT Supplier, SUM(QuantityInStock * UnitCost)
FROM STOCK
GROUP BY Supplier

The expression QuantityInStock * UnitCost calculates the value for each item, and SUM totals these across each supplier group.

Working:

• MetalCo: (500 x 0.15) + (250 x 1.20) + (30 x 4.50) = 75 + 300 + 135 = 510
• SealParts: (80 x 0.08) + (150 x 0.05) = 6.40 + 7.50 = 13.90

(d) Two fields where a range check should be applied: [2]

1. QuantityInStock: Must be >= 0 (cannot have negative stock).
2. UnitCost: Must be > 0 (an item cannot have a zero or negative cost).

(e) SQL query to count total records: [2]

SELECT COUNT(*)
FROM STOCK

COUNT(*) counts all rows in the table regardless of any NULL values. This would return 5 for the given data.

(f) SQL query for average per category with a minimum group size: [3]

SELECT Supplier, AVG(UnitCost)
FROM STOCK
GROUP BY Supplier
HAVING COUNT(*) > 2

GROUP BY groups records by Supplier, AVG calculates the mean UnitCost within each group, and HAVING filters to show only groups with more than 2 records. In this data, only MetalCo (3 items) would appear; SealParts (2 items) would be excluded.

(g) SQL query to update records matching a condition: [2]

UPDATE STOCK
SET QuantityInStock = 0
WHERE QuantityInStock < ReorderLevel

The UPDATE statement modifies existing records. SET specifies the new value, and WHERE determines which records are affected. Without a WHERE clause, all records would be updated.

(h) Two advantages of using a database over a flat file: [2]

1. Data can be queried using SQL to retrieve specific records quickly without reading the entire file, making searches efficient even with large datasets.
2. Multiple users can access and update the data simultaneously with access controls, preventing conflicts and restricting sensitive information to authorized personnel.

(i) SQL query for top 5 results sorted descending: [1]

SELECT *
FROM STOCK
ORDER BY UnitCost DESC
LIMIT 5

ORDER BY UnitCost DESC sorts from highest to lowest cost. LIMIT 5 restricts the output to the first 5 records. This is useful for finding the most expensive items.

(a) The pseudocode implements an ATM withdrawal with PIN verification (up to 3 attempts) and amount validation (multiple of 10, within balance). [8]

DECLARE StoredPIN : STRING
DECLARE EnteredPIN : STRING
DECLARE Balance : REAL
DECLARE Amount : INTEGER
DECLARE Attempts : INTEGER
DECLARE Authenticated : BOOLEAN

Attempts ← 0
Authenticated ← FALSE

REPEAT
    OUTPUT "Enter PIN: "
    INPUT EnteredPIN
    Attempts ← Attempts + 1
    IF EnteredPIN = StoredPIN THEN
        Authenticated ← TRUE
    ELSE
        OUTPUT "Incorrect PIN. ", 3 - Attempts, " attempts remaining."
    ENDIF
UNTIL Authenticated = TRUE OR Attempts >= 3

IF Authenticated = FALSE THEN
    OUTPUT "Card locked. Contact your bank."
ELSE
    REPEAT
        OUTPUT "Enter withdrawal amount (multiple of 10): "
        INPUT Amount
        IF Amount MOD 10 <> 0 THEN
            OUTPUT "Amount must be a multiple of 10"
        ELSE
            IF Amount > Balance THEN
                OUTPUT "Insufficient funds. Balance: ", Balance
            ELSE
                Balance ← Balance - Amount
                OUTPUT "Dispensing ", Amount
                OUTPUT "Remaining balance: ", Balance
            ENDIF
        ENDIF
    UNTIL Amount MOD 10 = 0 AND Amount <= Balance
ENDIF

The PIN loop uses a REPEAT...UNTIL that exits when the PIN matches or 3 attempts are exhausted [1]. The attempt counter increments before the check so the limit is enforced correctly [1]. After authentication, a second loop handles the amount, rejecting non-multiples of 10 and amounts exceeding the balance [1].

(b) Trace for StoredPIN = "1234", Balance = 500, inputs: "0000", "1234", amount 80: [4]

The first attempt fails, consuming one of three tries [1]. The second attempt succeeds, so the loop exits with Authenticated = TRUE [1]. The amount 80 passes both checks (divisible by 10, within balance), so 80 is subtracted from 500 [1].

(a) To find the mean, sum all elements using a FOR loop and divide by the count: [3]

DECLARE Total : INTEGER
DECLARE Mean : REAL
DECLARE i : INTEGER
Total ← 0
FOR i ← 1 TO 10
    Total ← Total + Marks[i]
NEXT i
Mean ← Total / 10
OUTPUT "Mean mark: ", Mean

The marks are {72, 85, 63, 91, 45, 78, 56, 88, 70, 65}. Their sum is 72 + 85 + 63 + 91 + 45 + 78 + 56 + 88 + 70 + 65 = 713. The mean is 713 / 10 = 71.3. [1 mark for loop summing, 1 mark for division by 10, 1 mark for output]

(a) The key difference is that SwapByValue receives copies of A and B, while SwapByRef receives direct references to the original variables. [4]

1. After SwapByValue: A=5 B=9 (values unchanged because the swap operated on copies) [2]
2. After SwapByRef: A=9 B=5 (values swapped because BYREF modifies the originals) [2]

(b) SwapByValue passes A and B by value, meaning the procedure receives independent copies named X and Y. [1] The swap correctly exchanges X and Y inside the procedure, but these are local copies. When the procedure ends, the copies are discarded, and the original A (still 5) and B (still 9) are unaffected. [1]

(a) The function finds the comma position, then uses SUBSTRING to extract the surname (before the comma) and first name (after the comma and space): [4]

FUNCTION ToFormat2(Name : STRING) RETURNS STRING
    DECLARE CommaPos : INTEGER
    DECLARE Surname : STRING
    DECLARE FirstName : STRING
    DECLARE i : INTEGER

    CommaPos ← 0
    FOR i ← 1 TO LENGTH(Name)
        IF Name[i] = ',' THEN
            CommaPos ← i
        ENDIF
    NEXT i

    Surname ← SUBSTRING(Name, 1, CommaPos - 1)
    FirstName ← SUBSTRING(Name, CommaPos + 2, LENGTH(Name) - CommaPos - 1)
    RETURN FirstName & " " & Surname
ENDFUNCTION

The key detail is CommaPos + 2: the first name starts two characters after the comma because Format 1 has a comma followed by a space. [1 mark for finding comma position, 1 mark for extracting surname, 1 mark for extracting first name (skipping comma and space), 1 mark for returning concatenated result]

(b) ToFormat2("Brown, Alice") returns "Alice Brown". The comma is at position 5, so Surname = "Brown" (positions 1-5) and FirstName = "Alice" (positions 8-12). [1]

(c) The reverse conversion finds the space and swaps the order, inserting ", " between surname and first name: [3]

FUNCTION ToFormat1(Name : STRING) RETURNS STRING
    DECLARE SpacePos : INTEGER
    DECLARE FirstName : STRING
    DECLARE Surname : STRING
    DECLARE i : INTEGER

    SpacePos ← 0
    FOR i ← 1 TO LENGTH(Name)
        IF Name[i] = ' ' THEN
            SpacePos ← i
        ENDIF
    NEXT i

    FirstName ← SUBSTRING(Name, 1, SpacePos - 1)
    Surname ← SUBSTRING(Name, SpacePos + 1, LENGTH(Name) - SpacePos)
    RETURN Surname & ", " & FirstName
ENDFUNCTION

[1 mark for finding space, 1 mark for extracting parts, 1 mark for correct format with comma]

(a) Comparing each position in the two parallel arrays: [1]

The student answered 5 questions correctly (Q1, Q3, Q4, Q6, Q8). [1]

Wait - let me recount. Q1: B=B (match). Q2: A vs C (no). Q3: C=C (match). Q4: D=D (match). Q5: A vs B (no). Q6: B=B (match). Q7: C vs A (no). Q8: A=A (match). That is 5 matches.

Correction from the mark scheme: the answer is 4 correct answers (Q1: B=B, Q3: C=C, Q4: D=D, Q8: A=A). Checking Q6: StudentAnswer[6] = 'B' and CorrectAnswer[6] = 'B' - this is also a match, giving 5 total. However, the mark scheme states 4. Let me re-examine the arrays:

StudentAnswer: ['B', 'A', 'C', 'D', 'A', 'B', 'C', 'A']

CorrectAnswer: ['B', 'C', 'C', 'D', 'B', 'B', 'A', 'A']

Q1: B=B (match), Q2: A vs C (no), Q3: C=C (match), Q4: D=D (match), Q5: A vs B (no), Q6: B=B (match), Q7: C vs A (no), Q8: A=A (match). Total: 5 correct answers.

(a) The flowchart shows a linear search. [1]

A linear search checks each element of an array one by one, starting from the first element and moving sequentially through the array until the target value is found or the end of the array is reached.

(b) If the Target is 25: [1]

The search starts at Index 1. Data[1]=12, not 25. Index becomes 2. Data[2]=7, not 25. Index becomes 3. Data[3]=25, which equals the Target. Found is set to TRUE. The loop exits because Found = TRUE. The final decision box checks Found = TRUE, which is true, so the algorithm outputs that the item was found at position 3.

(c) Why the flowchart uses a WHILE-style loop rather than a simple FOR loop: [2]

The WHILE-style loop has two conditions: Index <= 5 AND Found = FALSE. This allows the search to stop early as soon as the target is found. [1] When Found becomes TRUE, the loop condition fails and the algorithm exits immediately without checking the remaining elements.

A simple FOR loop would continue iterating through all remaining elements even after the target has been located. [1] For an array of 5 elements this is a minor inefficiency, but for large arrays with thousands of elements, stopping early when the target is near the beginning saves significant processing time. The WHILE-style loop is therefore more efficient on average.

(a) Difference between a syntax error and a logic error: [2]

A syntax error is a violation of the programming language's grammar rules. This includes misspelled keywords, missing brackets, incorrect punctuation, or wrong structure. Syntax errors prevent the program from compiling or running at all. [1]

A logic error is when the program compiles and runs without crashing but produces incorrect results because the algorithm or calculations are wrong. The code is grammatically valid but does not do what the programmer intended. [1]

(b) Whether each error would be detected by a compiler: [4]

(i) A missing semicolon: Yes, detected by the compiler. [1] A missing semicolon is a syntax error. The compiler analyses the structure of the code and recognises that the statement is incomplete or improperly terminated. It will report an error message indicating the location of the missing semicolon. [1]

(ii) Using length + width instead of length * width: No, not detected by the compiler. [1] Using + instead of * is valid syntax because both are legitimate arithmetic operators. The compiler sees nothing wrong with adding two numbers. However, the formula is logically incorrect: it calculates the perimeter-related value rather than the area. This is a logic error that only becomes apparent when testing with known values (e.g. a 5 x 3 rectangle gives 8 instead of 15). [1]