2025 Cambridge IAL Computer Science (9618) Practice Paper with Answers

A character set is a mapping of characters/symbols to a set of unique numeric codes (binary values) that the computer system can process. In Unicode, each character is assigned a unique code point. It supports variable-width encodings (such as UTF-8 or UTF-16) or fixed-width encodings, enabling the representation of over a million distinct characters. This allows it to support virtually all written languages and emojis, whereas older ASCII standards are restricted to 128 characters.

1 mark: Definition of 'character set' as a complete defined list of characters/symbols along with their corresponding binary representations. 1 mark: Explaining that Unicode assigns a unique binary value (code point, e.g., 8/16/32-bit) to each character. 0.5 marks: Stating the benefit of Unicode over ASCII (e.g., handles thousands of international characters/symbols, whereas ASCII is limited to 128 or 256 characters).

An embedded system often operates continuously without human intervention. A watchdog timer is an independent hardware timing device that helps the system recover from software hangs, crashes, or infinite loops. It initializes with a set countdown value. During normal execution, the software periodically resets this timer to prevent it from reaching zero. If a software fault occurs, the timer expires (reaches zero) and triggers a hardware reset signal to restart the system.

1 mark: Purpose is to automatically recover/reset the system if a software crash, freeze, or infinite loop occurs without human intervention. 1 mark: It functions as a countdown timer which the running software must periodically reset (or 'kick') during normal execution. 0.5 marks: If the timer reaches zero / expires, a hardware reset is triggered to reboot the system.

The Current Instruction Register (CIR) is a register in the Control Unit of the CPU. Its role is to temporarily store the instruction that is currently being decoded and executed. At the end of the Fetch stage, the instruction is loaded into the CIR from the Memory Data Register (MDR). Once in the CIR, the instruction is split into its constituent parts: the opcode (the instruction operation) and the operand (the address or the actual data). The control unit then decodes the opcode to coordinate the execution.

1 mark: Temporarily holds the instruction currently being decoded and executed. 1 mark: Receives the instruction from the Memory Data Register (MDR) at the end of the Fetch phase. 0.5 marks: Splits the instruction into its opcode (operation code) and operand(s) for decoding by the control unit.

Lossy compression algorithms achieve smaller file sizes by permanently discarding redundant or less perceptible data (common in audio/image files). Lossless compression reduces file size by reorganizing or indexing data without discarding any information, allowing the original file to be reconstructed exactly. An executable file contains binary machine code instructions. If lossy compression were used, some bits would be lost, altering the instructions. Even a single changed bit can make the program corrupt, causing execution failure or critical runtime errors.

1 mark: Lossy compression permanently discards data to reduce file size, whereas lossless compression retains all data and allows exact recreation. 1 mark: Executable files contain binary instructions/machine code that require 100% precision. 0.5 marks: Any loss of data (even a single bit) will corrupt the program code, making it unusable or causing crashes.

Data validation is an automatic check carried out by a program on input data to ensure that it is sensible, complete, and reasonable before processing. A range check sets both an upper and a lower boundary for a data value (e.g., an exam mark must be between 0 and 100 inclusive). A limit check, however, only checks a single boundary—either a maximum allowed value or a minimum allowed value (e.g., checking only that age is greater than or equal to 18, with no upper bound, or checking only that a payment amount is less than a maximum limit).

1 mark: Definition: An automatic program check to ensure input data is sensible, reasonable, complete, or conforms to specified rules (do not accept 'ensuring data is correct/accurate'). 1 mark: Range check verifies data lies between both a minimum and maximum boundary. 0.5 marks: Limit check only verifies a single boundary (either an upper limit or a lower limit, but not both).

Normalization is the process of adjusting the mantissa and exponent of a floating-point number so that the mantissa starts with a standard bit pattern. In two's complement, a normalized positive number starts with '01' and a normalized negative number starts with '10'. Reasons for normalization: 1) Precision: It eliminates redundant leading zeros (or ones), ensuring the maximum number of significant bits are stored in the mantissa, reducing truncation/rounding errors. 2) Uniqueness: It ensures there is only one unique binary representation for each non-zero real number, making comparison operations simpler and faster.

1 mark: Definition: Adjusting the mantissa and exponent so the mantissa begins with '01' (positive) or '10' (negative) in two's complement, eliminating redundant leading digits. 1 mark: Reason 1: Maximizes the precision/accuracy of the value by utilizing the full width of the mantissa. 0.5 marks: Reason 2: Ensures there is a unique, standardized representation for every real number (facilitating easier comparisons).

A virtual machine (VM) is a software environment that emulates a complete, separate physical computer system, including its own operating system and virtual hardware resources. This virtualization is managed by software called a hypervisor. VMs protect host operating systems through isolation (sandboxing). The VM operates inside a strictly confined environment. If malware infects the VM, it remains isolated within that virtual environment. The malware cannot directly access the host system's file directories or physical memory spaces. If the VM is compromised, it can be deleted or reverted to a safe, clean snapshot without affecting the host operating system.

1 mark: Definition: Software that emulates/creates a virtual representation of a physical computer running its own OS. 1 mark: Isolation: The VM is sandboxed / isolated from the host OS and other systems by a hypervisor. 0.5 marks: Security: Malware is restricted to the virtual disk and cannot write to or corrupt the host OS files or memory, allowing safe containment.

The syntax analyser is the second phase of a compiler. Its main role is to take the stream of tokens output by the lexical analyser and verify if they form grammatically correct statements according to the syntax rules of the source language. It builds an abstract syntax tree (or parse tree) to represent the hierarchical structure of the statements. If the code violates any syntax rules (such as missing brackets, incorrect keyword order), the syntax analyser generates syntax error reports and terminates compilation or continues checking for further errors.

1 mark: Checks the tokens from the lexical analyser against the grammar/syntax rules of the programming language. 1 mark: Constructs a syntax tree (or parse tree) representing the hierarchical structure of the statements. 0.5 marks: Identifies and reports syntax errors (such as mismatched parentheses or incorrect statement structures).

Bytecode serves as a middle layer between high-level source code and hardware-specific machine code. The VM executes this bytecode, acting as an abstraction layer over the host platform's physical CPU. Direct benefit is that developers write and compile code once, which can then be executed on multiple physical architectures without recompiling.

1 mark: Identifying bytecode as intermediate/machine-independent code.
1 mark: Explaining that the VM interprets or compiles (JIT) this bytecode into the local processor's native machine instructions.
0.5 mark: Pointing out the resulting benefit of platform independence (portability).

By sampling at a rate higher than twice the maximum frequency (\(f_s \ge 2 \times f_{max}\)), the original analogue sound wave can be reconstructed with perfect fidelity. Since human hearing caps at approximately 20 kHz, audio digitizers typically use at least 40 kHz (or standard 44.1 kHz) to satisfy the Nyquist rate for human audio perception.

1 mark: Correctly stating the Nyquist theorem (sampling frequency must be at least double the highest frequency of the analogue signal).
1 mark: Stating the purpose (prevents distortion / prevents aliasing / ensures accurate reconstruction of the original waveform).
0.5 mark: Providing a practical context (e.g., standard human audio frequency limit of 20 kHz requires at least 40 kHz sampling rate).

Immediate addressing: e.g., LDD #45 (loads the constant value 45 directly into the accumulator). Direct addressing: e.g., LDD 45 (looks up address 45 in RAM and loads the value found there into the accumulator).

1 mark: Clearly explaining immediate addressing (the data value is hardcoded directly inside the instruction).
1 mark: Clearly explaining direct addressing (the instruction holds the address of the data in memory).
0.5 mark: Comparing their execution/access characteristics (immediate requires zero memory read cycles for data retrieval, direct requires one memory access cycle).

Under paging, the OS keeps track of mapped pages via page tables. When a process requests memory, physical frames do not need to be contiguous. Disadvantage: It can lead to internal fragmentation (on the very last page of a process) and can cause disk thrashing if virtual memory swapping becomes too frequent.

1 mark: Explaining the division of memory into fixed-size pages (logical) and frames (physical).
1 mark: Explaining the role of the page table in mapping logical pages to non-contiguous physical memory locations.
0.5 mark: Identifying a valid disadvantage (e.g., overhead of managing page tables, risk of disk thrashing under low physical memory, or internal fragmentation in the final page of a block).

To find the output \(X\) for each set of inputs:

1. For \(A = 0, B = 0, C = 1\):
- First, evaluate the NOR term: \(A \text{ NOR } B = \text{NOT}(0 \text{ OR } 0) = \text{NOT}(0) = 1\).
- Next, evaluate the NOT term: \(\text{NOT } C = \text{NOT}(1) = 0\).
- Finally, evaluate the XOR: \(X = 1 \text{ XOR } 0 = 1\).

2. For \(A = 1, B = 0, C = 1\):
- First, evaluate the NOR term: \(A \text{ NOR } B = \text{NOT}(1 \text{ OR } 0) = \text{NOT}(1) = 0\).
- Next, evaluate the NOT term: \(\text{NOT } C = \text{NOT}(1) = 0\).
- Finally, evaluate the XOR: \(X = 0 \text{ XOR } 0 = 0\).

Award 1 mark for each correct output value:
- 1 mark: \(X = 1\) for the first input set
- 1 mark: \(X = 0\) for the second input set

We derive the expression step by step:
1. The intermediate output \(W\) is the output of the AND gate with inputs \(P\) and \(Q\):
\(W = P \text{ AND } Q\)

2. The intermediate output \(Y\) is the output of the NOT gate with input \(R\):
\(Y = \text{NOT } R\)

3. The final output \(S\) is the result of combining \(W\) and \(Y\) using a NOR gate:
\(S = W \text{ NOR } Y = (P \text{ AND } Q) \text{ NOR } (\text{NOT } R)\)

This can also be written in equivalent forms, such as:
\(S = \text{NOT}((P \text{ AND } Q) \text{ OR } (\text{NOT } R))\)

Award marks as follows:
- 1 mark for correctly identifying the components: \((P \text{ AND } Q)\) and \(\text{NOT } R\).
- 1 mark for correctly combining both parts using the NOR operator (or the equivalent \(\text{NOT}(... \text{ OR } ...)\)).

Accept equivalent algebraic/Boolean notation, such as \(S = \overline{(P \cdot Q) + \overline{R}}\).

To create a table in SQL, the CREATE TABLE statement is used. Each field is declared with an appropriate data type (VARCHAR/CHAR for text, INT/INTEGER for the year). The primary key is set on VehicleID, and the foreign key constraint is declared referencing Owner(OwnerID).

1 mark: Correct CREATE TABLE Vehicle (...) syntax.
1 mark: VehicleID specified as primary key with correct type.
1 mark: Make, Model, and YearOfManufacture defined with appropriate types.
1 mark: OwnerID set as foreign key referencing Owner(OwnerID).

The ALTER TABLE statement is used to modify the structure of an existing table. To add a column, ALTER TABLE Customer ADD is used followed by the column definition. To remove a column, ALTER TABLE Customer DROP COLUMN is used.

1 mark: Correct use of ALTER TABLE Customer for adding a column.
1 mark: Correct syntax to add EmailAddress with VARCHAR(100) or CHAR(100).
1 mark: Correct use of ALTER TABLE Customer for dropping a column.
1 mark: Correct syntax to drop MiddleName (either DROP COLUMN MiddleName or DROP MiddleName).

The query requires a join operation between the Student and Class tables on the matching ClassID fields. The SELECT clause lists the requested fields, and the WHERE clause filters the results for RoomNumber 'A12'.

1 mark: Correct SELECT clause with FirstName, LastName, and ClassName.
1 mark: Correct FROM clause specifying both tables (Student and Class).
1 mark: Correct join condition matching ClassID between both tables (either using INNER JOIN ... ON or WHERE).
1 mark: Correct filter WHERE RoomNumber = 'A12'.

For task 1, an UPDATE query is used with SET to modify the UnitPrice and a WHERE clause to filter the products. For task 2, a DELETE FROM statement is used with a WHERE clause to select products with a StockLevel of 0.

1 mark: Correct UPDATE Product SET UnitPrice = UnitPrice * 1.1 (or equivalent expression).
1 mark: Correct WHERE StockLevel < 10 for the UPDATE statement.
1 mark: Correct DELETE FROM Product syntax.
1 mark: Correct WHERE StockLevel = 0 for the DELETE statement.

Step-by-step trace: 1) LDM #4 sets ACC to 4. 2) STO 100 stores 4 in address 100. 3) LDR IX, #2 sets IX to 2. 4) LDX 105 loads value from address (105 + IX) which is 107. Since address 107 has 18, ACC becomes 18. 5) ADD 100 adds the value at address 100 (which is 4) to ACC, so ACC = 22. 6) STX 110 stores ACC (22) at address (110 + IX) which is 112. Thus, address 112 gets the value 22. 7) LDD 111 loads value from address 111 (30) to ACC. 8) DEC ACC decrements ACC to 29. 9) STO 111 stores 29 in address 111. The final value in address 112 is 22.

1 mark for finding index register IX = 2 and loading 18 from address 107. 1 mark for adding value at address 100 (4) to get ACC = 22. 1 mark for storing 22 at target address 112 using indexed addressing. 0.6 marks for accurate final value 22.

Step-by-step trace: 1) LDD 202 loads 5 into ACC. 2) CMP #5 compares ACC (5) with 5, setting the equal status. 3) JPE L1 branches to label L1, bypassing LDD 200. 4) L1: LDI 200 performs an indirect load. Address 200 contains 203, so it loads from address 203. Since address 203 contains 14, ACC becomes 14. 5) ADD 202 adds the value at address 202 (5) to ACC, making ACC = 19. 6) STO 205 stores 19 in address 205. 7) LDI 201 performs an indirect load. Address 201 contains 204, so it loads from address 204. Since address 204 contains 25, ACC becomes 25. 8) SUB #10 subtracts 10 from ACC, making ACC = 15. 9) STO 204 stores 15 in address 204. The final value in address 204 is 15.

1 mark for identifying the conditional jump is taken, bypassing LDD 200. 1 mark for evaluating the indirect load LDI 200 as loading 14 and storing 19 in address 205. 1 mark for evaluating LDI 201 as loading 25, subtracting 10 to get 15. 0.6 marks for final accurate value 15 in address 204.

Step-by-step trace of the loop: Initial states are IX = 0, Memory[85] = 0, Memory[80] = 3. Iteration 1: LDX 81 loads Memory[81+0] = 10. ADD 85 adds 0, ACC = 10. STO 85 stores 10 in 85. INC IX increments IX to 1. LDD 80 loads 3, DEC ACC decrements to 2, STO 80 stores 2 in 80. CMP #0 checks 2, JPN LOOP jumps back. Iteration 2: LDX 81 loads Memory[81+1] = 20. ADD 85 adds 10, ACC = 30. STO 85 stores 30 in 85. INC IX increments IX to 2. LDD 80 loads 2, DEC ACC decrements to 1, STO 80 stores 1 in 80. CMP #0 checks 1, JPN LOOP jumps back. Iteration 3: LDX 81 loads Memory[81+2] = 30. ADD 85 adds 30, ACC = 60. STO 85 stores 60 in 85. INC IX increments IX to 3. LDD 80 loads 1, DEC ACC decrements to 0, STO 80 stores 0 in 80. CMP #0 checks 0, comparison is equal so JPN LOOP is not taken. The loop terminates. The final value in address 85 is 60.

1 mark for tracing the loop counter decrementing from 3 down to 0 over 3 iterations. 1 mark for tracing the index register incrementing from 0 to 3. 1 mark for accumulating the correct values (10 + 20 + 30) to get 60. 0.6 marks for final accurate value 60 stored in address 85.

Let's trace the algorithm step-by-step:
1. Initial state: `x = 1`, `y = 6`, `Data = [12, 5, 8, 14, 3, 9]`.
2. **Iteration 1**: `x < y` (1 < 6) is TRUE. `Data[1] > Data[6]` (12 > 9) is TRUE.
- `temp <- Data[1]` (12)
- `Data[1] <- Data[6]` (9)
- `Data[6] <- temp` (12)
- `x <- x + 1` (2)
- `Data` is now `[9, 5, 8, 14, 3, 12]`.
3. **Iteration 2**: `x < y` (2 < 6) is TRUE. `Data[2] > Data[6]` (5 > 12) is FALSE.
- `y <- y - 1` (5)
4. **Iteration 3**: `x < y` (2 < 5) is TRUE. `Data[2] > Data[5]` (5 > 3) is TRUE.
- `temp <- Data[2]` (5)
- `Data[2] <- Data[5]` (3)
- `Data[5] <- temp` (5)
- `x <- x + 1` (3)
- `Data` is now `[9, 3, 8, 14, 5, 12]`.
5. **Iteration 4**: `x < y` (3 < 5) is TRUE. `Data[3] > Data[5]` (8 > 5) is TRUE.
- `temp <- Data[3]` (8)
- `Data[3] <- Data[5]` (5)
- `Data[5] <- temp` (8)
- `x <- x + 1` (4)
- `Data` is now `[9, 3, 5, 14, 8, 12]`.
6. **Iteration 5**: `x < y` (4 < 5) is TRUE. `Data[4] > Data[5]` (14 > 8) is TRUE.
- `temp <- Data[4]` (14)
- `Data[4] <- Data[5]` (8)
- `Data[5] <- temp` (14)
- `x <- x + 1` (5)
- `Data` is now `[9, 3, 5, 8, 14, 12]`.
7. **Iteration 6**: `x < y` (5 < 5) is FALSE. Loop terminates.

Max 3.5 marks:
- 1 mark: Correctly identifying when to decrement `y` to 5 and leave elements unchanged when the comparison `Data[2] > Data[6]` (5 > 12) is False.
- 1 mark: Correct array elements swaps for `Data[1]` and `Data[6]`, as well as `Data[2]` and `Data[5]` along with their corresponding updates to `temp` and `x`.
- 1 mark: Correct array elements swaps for `Data[3]` and `Data[5]`, as well as `Data[4]` and `Data[5]` along with their corresponding updates to `temp` and `x`.
- 0.5 marks: Correctly updating loop variables `x` and `y` to final state values of 5 and 5 with proper loop termination.

Let us trace the recursion step-by-step:
- **Call 1**: `Recurse(4, 3)`. Since `a > b` (4 > 3), the `ELSEIF` condition triggers, returning `3 + Recurse(1, 3)`.
- **Call 2**: `Recurse(1, 3)`. Since `a > b` is false (1 > 3 is false) and neither is <= 0, the `ELSE` condition triggers, returning `1 + Recurse(1, 2)`.
- **Call 3**: `Recurse(1, 2)`. Similarly, since `1 > 2` is false, this returns `1 + Recurse(1, 1)`.
- **Call 4**: `Recurse(1, 1)`. Since `1 > 1` is false, this returns `1 + Recurse(1, 0)`.
- **Call 5**: `Recurse(1, 0)`. Since `b <= 0` (0 <= 0 is true), the base case triggers, returning `1`.

Working back up the call stack:
- `Recurse(1, 1)` returns `1 + 1 = 2`.
- `Recurse(1, 2)` returns `1 + 2 = 3`.
- `Recurse(1, 3)` returns `1 + 3 = 4`.
- `Recurse(4, 3)` returns `3 + 4 = 7`.

Max 3.5 marks:
- 1 mark: Correctly demonstrating the base case parameter triggering (`b = 0`) and returning 1.
- 1 mark: Correct parameter transitions sequence through recursive calls: (4, 3) -> (1, 3) -> (1, 2) -> (1, 1) -> (1, 0).
- 1 mark: Correctly representing the accumulation logic working up the stack (+3 for the first call, +1 for others).
- 0.5 marks: Correct final return value of 7.

Let's trace the function execution with `Str = "AAABBC"`:
1. Initial state before loop: `OutStr = ""`, `CurrentChar = "A"`, `Count = 1`.
2. **i = 2**: `MID(Str, 2, 1)` is `"A"`. This matches `CurrentChar`, so `Count <- Count + 1` which is 2.
3. **i = 3**: `MID(Str, 3, 1)` is `"A"`. This matches `CurrentChar`, so `Count <- Count + 1` which is 3.
4. **i = 4**: `MID(Str, 4, 1)` is `"B"`. This does NOT match `CurrentChar`. Thus, `OutStr <- OutStr & CurrentChar & NUM_TO_STR(Count)` which results in `"" & "A" & "3" = "A3"`. `CurrentChar` is updated to `"B"`, and `Count` is reset to 1.
5. **i = 5**: `MID(Str, 5, 1)` is `"B"`. This matches `CurrentChar`, so `Count <- Count + 1` which is 2.
6. **i = 6**: `MID(Str, 6, 1)` is `"C"`. This does NOT match `CurrentChar`. Thus, `OutStr <- OutStr & CurrentChar & NUM_TO_STR(Count)` which results in `"A3" & "B" & "2" = "A3B2"`. `CurrentChar` is updated to `"C"`, and `Count` is reset to 1.
7. Loop ends.
8. After the loop, the remaining character is appended: `OutStr <- OutStr & CurrentChar & NUM_TO_STR(Count)`, yielding `"A3B2" & "C" & "1" = "A3B2C1"`.
9. Returns `"A3B2C1"`.

Max 3.5 marks:
- 1 mark: Correctly tracking variable values for the first run (until `i = 3` with `Count = 3`).
- 1 mark: Correct transition logic at `i = 4` (concatenation to `OutStr`, setting `CurrentChar` to `"B"`, and resetting `Count` to 1).
- 1 mark: Correct transition logic at `i = 6` (concatenation to `OutStr`, setting `CurrentChar` to `"C"`, and resetting `Count` to 1).
- 0.5 marks: Correctly executing post-loop code to yield the final returned value of `"A3B2C1"`.

Step-by-step trace:
- `Sum` is initialized to 0.
- **Row = 1**:
- `Check` is set to `TRUE`.
- `Col = 1`: `Grid[1, 1]` is 3 (odd). No match.
- `Col = 2`: `Grid[1, 2]` is 5 (odd). No match.
- `Col = 3`: `Grid[1, 3]` is 7 (odd). No match.
- Loop ends. `Check` is `TRUE`, so `Sum <- Sum + 10` which becomes 10.
- **Row = 2**:
- `Check` is set to `TRUE`.
- `Col = 1`: `Grid[2, 1]` is 1 (odd). No match.
- `Col = 2`: `Grid[2, 2]` is 4 (even). `Sum <- Sum + 4` (14), `Check <- FALSE`.
- `Col = 3`: `Grid[2, 3]` is 6 (even). `Sum <- Sum + 6` (20).
- Loop ends. `Check` is `FALSE`, so no addition of 10.
- **Row = 3**:
- `Check` is set to `TRUE`.
- `Col = 1`: `Grid[3, 1]` is 9 (odd). No match.
- `Col = 2`: `Grid[3, 2]` is 2 (even). `Sum <- Sum + 2` (22), `Check <- FALSE`.
- `Col = 3`: `Grid[3, 3]` is 3 (odd). No match.
- Loop ends. `Check` is `FALSE`, so no addition of 10.
- Output `Sum` which is 22.

Max 3.5 marks:
- 1 mark: Correctly tracing `Row = 1` actions including `Check` remaining `TRUE` and adding 10 to `Sum`.
- 1 mark: Correctly tracing `Row = 2` including updating `Check` to `FALSE` and adding even values (4 and 6) to `Sum`.
- 1 mark: Correctly tracing `Row = 3` including updating `Check` to `FALSE` and adding even value (2) to `Sum`.
- 0.5 marks: Correctly demonstrating the final output instruction with value 22.

To translate the structure chart interfaces into a pseudocode function header: 1. Identify the module type as a FUNCTION because it returns a single control flag parameter ('IsValid' of type Boolean). 2. Define the parameters passing into the module as 'StudentID' and 'EmailAddress', both of type STRING. 3. State the return type of the function as BOOLEAN. The final pseudocode header is: FUNCTION ValidateDetails(StudentID : STRING, EmailAddress : STRING) RETURNS BOOLEAN

1 mark: Correct use of keyword FUNCTION and matching name ValidateDetails. 2 marks: Correct parameters with types (StudentID : STRING, EmailAddress : STRING) (1 mark for each parameter). 1.5 marks: Correct return type definition (RETURNS BOOLEAN).

The state transitions derived from the system rules are: 1. Locked state with event 'coin' goes to Unlocked state. 2. Unlocked state with event 'push' goes to Locked state. 3. Locked state with event 'force' goes to Alarm state. 4. Alarm state with event 'reset' goes to Locked state.

1 mark: For transition Locked + coin -> Unlocked. 1 mark: For transition Unlocked + push -> Locked. 1 mark: For transition Locked + force -> Alarm. 1 mark: For transition Alarm + reset -> Locked. 0.5 marks: For clearly indicating Locked as the starting/initial state.

The function begins by declaring the local variables and initializing the count variable to 0. It opens 'Scores.txt' in READ mode and 'Passes.txt' in WRITE mode. A loop is executed until the end of the input file is reached. Inside the loop, it reads two consecutive lines corresponding to the name and the score. It then checks if the score is greater than or equal to the minimum passing score. If true, the name is written to 'Passes.txt' and the counter is incremented. Finally, both files are closed and the counter is returned.

1 mark: Correct function header and return type definition.
1 mark: Declaring local variables with correct data types.
1 mark: Opening 'Scores.txt' for reading and 'Passes.txt' for writing.
1 mark: Implementing a loop that runs until EOF of 'Scores.txt' is reached.
1 mark: Reading both values (name and score) in the correct order inside the loop.
1 mark: Correct conditional statement to check if the score is >= MinPassScore.
1 mark: Writing names of passing students to 'Passes.txt' and updating the count.
1 mark: Closing both files and returning the correct count value.

The function initialises variables for the primary and secondary diagonal sums. Using a single loop running from 1 to 5, it accumulates the diagonal values. The primary diagonal element at step I is at index [I, I]. The secondary diagonal element is at index [I, 6 - I]. After the loop, the difference is calculated. If the difference is negative, it is multiplied by -1 to get the absolute value, which is then returned.

1 mark: Correct function header and return type integer.
1 mark: Declaring and initializing PrimarySum and SecondarySum to 0.
1 mark: Correct loop running exactly from 1 to 5.
2 marks: Correct array index mapping for primary diagonal (Matrix[I, I]) and secondary diagonal (Matrix[I, 6 - I]).
1 mark: Logic to calculate absolute value without standard library functions.
1 mark: Returning the final computed absolute difference.

The function first checks the base case: if N is less than 2, it returns 0. If N is odd (checked using the expression N MOD 2 <> 0), it recursively calls itself with N - 1 to convert the problem into an even boundary. If N is even, it performs the recursive step of adding N to the result of SumEven(N - 2).

1 mark: Correct function header with correct parameter name, type, and return type.
2 marks: Base case correctly checking if N < 2 and returning 0.
2 marks: Recursive case for odd values of N calling SumEven(N - 1).
2 marks: Recursive case for even values of N returning N + SumEven(N - 2).

The procedure first checks if the queue is already full by checking if NumItems is equal to 10. If so, it outputs "Queue Full". If the queue is empty (NumItems is 0), both HeadPointer and TailPointer are set to 1. Otherwise, TailPointer is incremented. If TailPointer exceeds 10, it wraps around to 1. Finally, NewItem is placed at QueueData[TailPointer] and NumItems is incremented.

1 mark: Correct procedure header with parameter declaration.
1 mark: Checking if queue is full (NumItems = 10) and outputting message.
1 mark: Logic to handle initial insertion when queue is empty.
2 marks: Logic to increment and wrap TailPointer using IF TailPointer > 10 THEN TailPointer <- 1.
1 mark: Assigning NewItem to QueueData[TailPointer].
1 mark: Incrementing NumItems after successful insertion.

The function validates the password structure. First, it extracts the length and returns FALSE if it is outside the range [6, 12]. Next, it loops through each character of the password using the MID function. It updates boolean flags if uppercase or lowercase letters are found. Finally, it returns TRUE if both flags are true, otherwise FALSE.

1 mark: Correct function header and return type definition.
1 mark: Correct length check validation using OR or logical limits returning FALSE.
1 mark: Initializing boolean flags for upper and lower check to FALSE.
1 mark: Using loop from 1 to LENGTH(Password) and accessing each character using MID.
1 mark: Checking for uppercase range correctly.
1 mark: Checking for lowercase range correctly.
1 mark: Returning TRUE only if both conditions are met, otherwise FALSE.

The procedure implements an optimized bubble sort in descending order. The outer loop is a post-condition loop (REPEAT...UNTIL) controlled by a boolean flag `Swapped` and an iteration count `Pass`. In each pass, the inner loop compares adjacent elements. Since we want a descending order, we swap them if the left element `Numbers[I]` is smaller than the right element `Numbers[I+1]`. If any swap occurs, `Swapped` is set to TRUE. The process terminates if no elements were swapped on a complete pass.

1 mark: Correct procedure header with parameter declarations (BYREF array, BYVAL size).
1 mark: Initializing Pass counter and outer loop structure.
1 mark: Resetting Swapped flag to FALSE at start of outer loop.
1 mark: Correct inner loop limit (1 TO Size - Pass).
1 mark: Correct descending comparison (Numbers[I] < Numbers[I + 1]).
1 mark: Swapping elements correctly using a temporary variable and setting Swapped to TRUE.
1 mark: Correct loop termination condition when NOT Swapped.

1. Convert the absolute value of the number to binary:
\(6.75 = 6 + 0.75 = 110_2 + 0.11_2 = 110.11_2\)

2. To represent the negative value \(-6.75\), write \(+6.75\) with leading zero bits (e.g., \(0110.1100\)) and take the two's complement:
- Invert the bits: \(1001.0011\)
- Add 1: \(1001.0100_2\) (which represents \(-6.75\))

3. Normalize this negative number. A normalized negative floating-point number must start with the bits \(10\):
\(1.0010100_2 \times 2^3\)

4. Write down the 8-bit mantissa:
Mantissa = \(10010100\)

5. Write down the 4-bit exponent for \(+3\) in two's complement:
\(3 = 0011_2\)
Exponent = \(0011\)

Combined 12-bit representation: \(10010100\ 0011\)

1 mark for converting \(6.75\) or \(-6.75\) correctly to binary (e.g. \(1001.01\)).
1 mark for normalizing the negative mantissa correctly to 8 bits: \(10010100\).
1 mark for the correct 4-bit exponent: \(0011\).

1. Analyze the mantissa:
- The mantissa is `01011000`. Since it begins with `0`, it represents a positive number.
- Placing the binary point after the first bit (sign bit): \(0.1011000_2\)
- Convert to denary: \(0.5 \times 1 + 0.25 \times 0 + 0.125 \times 1 + 0.0625 \times 1 = 0.5 + 0.125 + 0.0625 = 0.6875\) (or \(\frac{11}{16}\))

2. Analyze the exponent:
- The exponent is `1101`. Since it begins with `1`, it is a negative number represented in two's complement.
- Convert `1101` to denary: \(-8 + 4 + 1 = -3\) (or invert `1101` \(\rightarrow\) `0010`, add 1 \(\rightarrow\) `0011`, giving \(-3\))

3. Calculate the final value:
- Value = \(0.6875 \times 2^{-3} = 0.6875 \times \frac{1}{8} = 0.0859375\) (or \(\frac{11}{128}\))

1 mark for calculating the correct mantissa value (\(0.6875\) or \(\frac{11}{16}\)).
1 mark for calculating the correct exponent value (\(-3\)).
1 mark for calculating the correct final denary value (\(0.0859375\) or \(\frac{11}{128}\)).

1. Underflow occurs when an arithmetic operation results in a non-zero value that is too small (its absolute value is too close to zero) to be represented with the minimum possible exponent allocated in the system.
2. This happens because the negative exponent required to represent the actual value is smaller (more negative) than the range of the exponent bits allows.
3. Computer systems typically handle underflow by representing the value as zero (known as 'flush-to-zero') or by raising an underflow exception / setting a status flag.

1 mark for stating that the value is too small to be represented (or magnitude is smaller than the minimum representable non-zero value).
1 mark for explaining that this is because the negative exponent required is beyond the capacity of the allocated exponent bits.
1 mark for identifying that the system represents the result as zero (or raises an exception/error flag).

1. Construct the K-map from the truth table:

```
BC
A | 00 | 01 | 11 | 10
----+----+----+----+----
0 | 0 | 1 | 1 | 0
1 | 1 | 1 | 0 | 0
```

2. Group the adjacent 1s to form the largest possible groups (each containing a power of 2 cells):
- **Group 1**: Cells (0,0,1) and (0,1,1) in the first row. This group spans across \(B=0\) and \(B=1\), which cancels out \(B\). Since \(A=0\) and \(C=1\), this simplifies to \(\bar{A}C\).
- **Group 2**: Cells (1,0,0) and (1,0,1) in the second row. This group spans across \(C=0\) and \(C=1\), which cancels out \(C\). Since \(A=1\) and \(B=0\), this simplifies to \(A\bar{B}\).

3. Combine both simplified terms to obtain the final sum-of-products boolean expression:
\(A\bar{B} + \bar{A}C\)

1 mark for correctly placing the 1s in the K-map (or identifying the four active minterms).
1 mark for grouping and simplifying the first loop to \(\bar{A}C\).
1 mark for grouping and simplifying the second loop to \(A\bar{B}\) and providing the final sum-of-products expression.

1. Many denary fractional numbers like \(0.1\) cannot be represented exactly in binary because they do not have a finite representation as a sum of powers of 2 (i.e., they form a recurring/infinite binary fraction: \(0.0001100110011..._2\)).
2. Because the mantissa has a fixed number of bits, the number must be rounded or truncated, introducing a small rounding/quantization error.
3. When performing repetitive additions of this value (e.g., in a loop), these small errors accumulate (cumulative error). For example, a loop intended to run until a variable exactly equals \(1.0\) may never terminate because the accumulated sum might skip the exact value due to precision limits.

1 mark for explaining that \(0.1\) has a recurring binary representation / cannot be expressed as a finite sum of powers of 2.
1 mark for stating that rounding/truncating to fit the fixed mantissa size introduces an initial representation error.
1 mark for explaining that repetitive additions cause these errors to accumulate, leading to significant inaccuracies or infinite/malfunctioning loops.

A data dependency hazard arises during instruction pipelining when instruction N+1 requires data from instruction N, but instruction N has not yet completed its write-back stage. Normally, this would require a pipeline stall (bubble) where instruction N+1 is held. Operand forwarding resolves this by adding hardware paths that detect this dependency and copy the output buffer of the ALU (or executive phase) directly to the input of the ALU for the next clock cycle, bypassing the register write-back and read phases entirely. This allows execution to proceed at full speed without needing to insert stall cycles.

1 mark: Definition of data dependency hazard (one instruction relies on output of previous instruction not yet written back). 1 mark: Identification that without intervention, this leads to a pipeline stall/bubble. 1 mark: Explanation of forwarding (routing data directly from ALU output of the producer instruction). 1 mark: Explanation of routing to ALU input of the consumer instruction, bypassing register write-back/read.

A Type 1 hypervisor is installed directly on the physical server hardware (bare-metal) beneath any guest operating systems. A Type 2 hypervisor runs as an application on top of an existing host operating system. Type 1 hypervisors offer a performance advantage because they have direct access to hardware without the overhead of an intermediate host operating system, making them more secure, robust, and efficient for enterprise server virtualization.

1 mark: Type 1 hypervisor runs directly on physical hardware (bare-metal). 1 mark: Type 2 hypervisor runs on top of a host operating system. 1 mark: Advantage of Type 1 is better performance/efficiency due to absence of host OS overhead. 1 mark: Type 1 has greater security/isolation because the host OS cannot be compromised to affect the hypervisor.

RISC (Reduced Instruction Set Computer) utilizes simple instructions that are of fixed length (typically 32-bit), making them easy to decode and ideal for pipelining. CISC (Complex Instruction Set Computer) utilizes complex, variable-length instructions that can perform multi-step operations (like combining load, calculate, and store in one instruction). While RISC instructions mostly execute in a single clock cycle and rely heavily on registers, CISC instructions can take multiple clock cycles and access memory directly, resulting in a denser program code with fewer instructions but a more complex hardware decoder.

1 mark: RISC instructions are of fixed length; CISC instructions are of variable length. 1 mark: RISC instructions are simple/perform one basic task; CISC instructions are complex/can perform multiple actions (e.g., load and calculate). 1 mark: RISC instructions typically execute in a single clock cycle; CISC instructions take multiple clock cycles. 1 mark: RISC relies heavily on registers (load/store architecture); CISC allows direct operations on memory.

The Transport Layer is responsible for establishing a host-to-host connection, segmenting data, and managing flow control and error checking. TCP achieves reliability by first performing a three-way handshake to establish a connection. During transmission, it assigns sequence numbers to each segment so the receiver can reorder them and detect missing data. The receiver sends acknowledgments (ACKs) for received segments. If the sender does not receive an ACK within a timeout period, it retransmits the missing segment, ensuring error-free delivery.

1 mark: Function of Transport Layer (establishing host-to-host session / packet segmentation / port addressing). 1 mark: TCP connection establishment (three-way handshake). 1 mark: Packet ordering using sequence numbers. 1 mark: Reliability through acknowledgments (ACKs) and retransmission of lost packets.

NAT allows a router to present a single public IP address to the WAN on behalf of multiple devices on a private LAN. When an internal device sends a packet, the router replaces the private source IP address and port with its own public IP address and a unique port number, creating an entry in the NAT translation table. When an incoming response arrives from the Internet, the router inspects the destination port, matches it against the NAT translation table to identify the original private IP address and port, and forwards the packet to the correct internal device.

1 mark: Purpose of NAT (conserve public IP addresses / hide private IPs). 1 mark: Outgoing translation (replaces private source IP and port with public IP and a unique port). 1 mark: NAT table entry creation (maps internal IP/port to external IP/port). 1 mark: Incoming translation (matches destination port of incoming packet to table to forward to correct internal device).

MIMD (Multiple Instruction Multiple Data) refers to an architecture where multiple processing cores or processors execute different instructions on different datasets at the same time. This is standard in modern multi-core computers. In contrast, SISD (Single Instruction Single Data) features a single processor that executes a single instruction stream on one data stream at a time (sequential execution). MIMD is highly suited for parallel processing because different tasks (or parts of a single task) can be divided and processed concurrently across different cores, greatly increasing computing speed and throughput.

1 mark: Definition of MIMD (multiple processors/cores executing different instructions on different data streams concurrently). 1 mark: Definition of SISD (single instruction executed sequentially on a single data stream at a time). 1 mark: Contrast in execution (MIMD allows parallel execution of independent tasks; SISD is strictly sequential). 1 mark: Performance benefit (MIMD handles multi-threaded applications and complex simulations much faster by dividing the computational load).

Step-by-step evaluation using a stack:
- Push 12: [12]
- Push 4: [12, 4]
- Process '/': Pop 4, Pop 12. Evaluate 12 / 4 = 3. Push 3. Stack becomes [3].
- Push 5: [3, 5]
- Process '*': Pop 5, Pop 3. Evaluate 3 * 5 = 15. Push 15. Stack becomes [15].
- Push 3: [15, 3]
- Push 2: [15, 3, 2]
- Process '^': Pop 2, Pop 3. Evaluate 3^2 = 9. Push 9. Stack becomes [15, 9].
- Process '-': Pop 9, Pop 15. Evaluate 15 - 9 = 6. Push 6. Stack becomes [6].

Award 1 mark for each correct stack state after the respective operator is processed:
- After '/': [3] (or 3)
- After '*': [15] (or 15)
- After '^': [15, 9] (or 15, 9)
- After '-': [6] (or 6)
Accept alternative notation (e.g., without brackets) as long as the elements and their sequence are correct.

We perform Dijkstra's algorithm step-by-step starting from A:
1. Initialize distances: A = 0, B = infinity, C = infinity, D = infinity, E = infinity.
2. Visit A (dist 0). Update neighbors of A: B = 4, C = 2. Visited set = {A}.
3. Next nearest unvisited vertex is C (dist 2). Visit C. Update neighbors of C:
- B can be reached via A->C->B with distance 2 + 1 = 3. Since 3 < 4, update B = 3.
- D can be reached via A->C->D with distance 2 + 8 = 10.
- E can be reached via A->C->E with distance 2 + 10 = 12.
Visited set = {A, C}.
4. Next nearest unvisited vertex is B (dist 3). Visit B. Update neighbors of B:
- D can be reached via A->C->B->D with distance 3 + 5 = 8. Since 8 < 10, update D = 8.
Visited set = {A, C, B}.
5. Next nearest unvisited vertex is D (dist 8). Visit D. Update neighbors of D:
- E can be reached via A->C->B->D->E with distance 8 + 2 = 10. Since 10 < 12, update E = 10.
Visited set = {A, C, B, D}.
6. Visit E (dist 10). Visited set = {A, C, B, D, E}.

Final shortest distances: B = 3, C = 2, D = 8, E = 10.

Award 1 mark for each correct final shortest distance:
- Distance to B: 3 (1 mark)
- Distance to C: 2 (1 mark)
- Distance to D: 8 (1 mark)
- Distance to E: 10 (1 mark)

Step-by-step conversion:
1. Convert the sub-expression \((X + Y) * Z\):
- Convert parenthesis: \(X + Y\) becomes \(X Y +\)
- Multiply by Z: \(X Y + Z *\)

2. Convert the sub-expression \(W / (U + V)\):
- Convert parenthesis: \(U + V\) becomes \(U V +\)
- Divide W by the result: \(W U V + /\)

3. Convert the entire expression \(((X + Y) * Z) - (W / (U + V))\):
- Join the two converted halves using the subtraction operator: \([Part 1] [Part 2] -\)
- This yields: \(X Y + Z * W U V + / -\)

- Award 1 mark for correct RPN of \((X + Y) * Z\): `X Y + Z *`
- Award 1 mark for correct RPN of \(W / (U + V)\): `W U V + /`
- Award 2 marks for correct final RPN: `X Y + Z * W U V + / -` (Award 1 mark if there is only one minor error in the final combination, such as an incorrect final operator or incorrect order of operands).

To implement a stack procedurally, we declare the array and the pointer as global variables:

```pseudocode
DECLARE StackArray : ARRAY[0:49] OF INTEGER
DECLARE TopPointer : INTEGER

TopPointer <- -1
```

Setting `TopPointer` to `-1` indicates that there are currently no elements in the stack, as the array is 0-indexed.

1 mark: Correct declaration of 1D array `StackArray` of size 50 (indices 0 to 49) of type `INTEGER`.
1 mark: Correct declaration of `TopPointer` as `INTEGER`.
1 mark: Initialisation of `TopPointer` to `-1` (Accept: `0` if candidate specifies 1-indexed array, but array index in question was explicitly 0 to 49).

The class definition containing the required private attributes and the constructor initialising the top pointer is as follows:

```pseudocode
CLASS BookStack
PRIVATE TitleArray : ARRAY[0:19] OF STRING
PRIVATE Top : INTEGER

PUBLIC PROCEDURE NEW()
Top <- -1
ENDPROCEDURE
ENDCLASS
```

1 mark: Correct class header, footer, and attribute declarations with `PRIVATE` keyword (both `TitleArray` as an array of 20 strings and `Top` as an integer).
1 mark: Correct constructor method header (`PUBLIC PROCEDURE NEW()`) and closing statement.
1 mark: Correct initialisation `Top <- -1` inside the constructor.

The procedure needs to loop through all valid indices of the array (from 0 to 99) and assign an empty string to each slot. After the loop, the top pointer is set to -1:

```pseudocode
PROCEDURE InitializeStack()
FOR Index <- 0 TO 99
NamesStack[Index] <- ""
ENDFOR
TopPtr <- -1
ENDPROCEDURE
```

1 mark: Correct procedure header, footer, and a loop that correctly iterates 100 times (from 0 to 99).
1 mark: Assigning `""` to `NamesStack[Index]` (or equivalent loop variable) inside the loop.
1 mark: Assigning `-1` to `TopPtr` outside the loop.

The following Python code declares the class with its private attributes and constructor:

```python
class Instrument:
def __init__(self, name, category):
self.__name = name
self.__category = category
```

1 Mark: Correct class header definition (class Instrument:)
1 Mark: Correct constructor header with parameters (def __init__(self, name, category):)
1 Mark: Correct assignment of parameters to private attributes with double underscores (__name and __category).

The subclass StringInstrument inherits from Instrument and invokes its parent constructor using super():

```python
class StringInstrument(Instrument):
def __init__(self, name, category, numberOfStrings):
super().__init__(name, category)
self.__numberOfStrings = numberOfStrings
```

1 Mark: Correct subclass header demonstrating inheritance (class StringInstrument(Instrument):)
1 Mark: Calling the superclass constructor correctly (super().__init__(name, category))
1 Mark: Declaring and initializing the private attribute __numberOfStrings.

The complete Java class definition with private fields, constructor, and getter methods:

```java
public class Product {
private String productID;
private double price;

public Product(String productID, double price) {
this.productID = productID;
this.price = price;
}

public String getProductID() {
return this.productID;
}

public double getPrice() {
return this.price;
}
}
```

1 Mark: Correctly declaring private fields with correct data types (String and double).
1 Mark: Correctly defining the constructor initializing both fields.
1 Mark: Defining public getter methods returning the correct properties.

The Java subclass utilizes the `extends` keyword and calls the parent constructor via `super()`:

```java
public class DiscountedProduct extends Product {
private double discountRate;

public DiscountedProduct(String productID, double price, double discountRate) {
super(productID, price);
this.discountRate = discountRate;
}
}
```

1 Mark: Class declaration with inheritance (extends Product).
1 Mark: Correct declaration of private field discountRate (double).
1 Mark: Constructor calling super(productID, price) and initializing discountRate.

The abstract class Shape utilizes the abc module to declare an abstract class and abstract method:

```python
from abc import ABC, abstractmethod

class Shape(ABC):
def __init__(self, color):
self.__color = color

@abstractmethod
def getArea(self):
pass
```

1 Mark: Correct import statement and class definition inheriting from ABC.
1 Mark: Correct constructor initializing private attribute __color.
1 Mark: Correct declaration of abstract method getArea using the @abstractmethod decorator.

```python
QueueArray = [0] * 10
HeadPointer = 0
TailPointer = 0
NumItems = 0

def enqueue(Item):
global TailPointer, NumItems, QueueArray
if NumItems == 10:
return False
QueueArray[TailPointer] = Item
TailPointer = (TailPointer + 1) % 10
NumItems += 1
return True
```

1 Mark: Checking if queue is full using `NumItems == 10`.
1 Mark: Inserting `Item` at the index indicated by `TailPointer`.
1 Mark: Correct circular pointer update using `(TailPointer + 1) % 10` (or manual conditional check).
1 Mark: Correctly incrementing `NumItems` and returning `True`/`False` appropriately.

```python
QueueData = [""] * 8
Head = 0
Tail = 0

def dequeue():
global Head, QueueData
if Head == Tail:
return "EMPTY"
item = QueueData[Head]
Head += 1
return item
```

1 Mark: Correctly checks if the queue is empty using `Head == Tail`.
1 Mark: Correctly retrieves the element from `QueueData[Head]`.
1 Mark: Correctly increments `Head` by 1.
1 Mark: Correctly returns either "EMPTY" or the retrieved item.

```python
DataQueue = [""] * 5
TailPointer = 0

def dequeue_shift():
global TailPointer, DataQueue
if TailPointer == 0:
return None
item = DataQueue[0]
for i in range(1, TailPointer):
DataQueue[i - 1] = DataQueue[i]
TailPointer -= 1
return item
```

1 Mark: Checking if the queue is empty using `TailPointer == 0` and returning `None`.
1 Mark: Storing the value of the element at index 0 before updating.
1 Mark: Using a loop to shift subsequent active elements (`range(1, TailPointer)`) one space left.
1 Mark: Decrementing `TailPointer` and returning the stored item.

```python
class Element:
def __init__(self, data, priority):
self.Data = data
self.Priority = priority

QueueArray = [None] * 5
NumItems = 0

def insert_priority(NewData, NewPriority):
global NumItems, QueueArray
new_item = Element(NewData, NewPriority)
i = NumItems - 1
while i >= 0 and QueueArray[i].Priority > NewPriority:
QueueArray[i + 1] = QueueArray[i]
i -= 1
QueueArray[i + 1] = new_item
NumItems += 1
```

1 Mark: Declaring and initializing a new record object/element with `NewData` and `NewPriority`.
1 Mark: Writing an insertion shift loop that moves elements with lower priority (higher numeric priority value) one index right.
1 Mark: Inserting the new item at the correct insertion index (`i + 1`).
1 Mark: Correctly incrementing `NumItems` by 1.

Python solution:

CallCount = 0

def CountPaths(X, Y):
global CallCount
CallCount += 1
if X == 0 or Y == 0:
return 1
return CountPaths(X - 1, Y) + CountPaths(X, Y - 1)

result = CountPaths(3, 2)
print("Returned value:", result)
print("CallCount:", CallCount)

1 mark: Correct base cases (returning 1 when X == 0 or Y == 0).
1 mark: Correct recursive step summing the two calls with decremented X and Y.
1 mark: Correctly updating and displaying the global CallCount variable resulting in 19.

Python solution:

CallCount = 0

def CollatzCount(N):
global CallCount
CallCount += 1
if N == 1:
return 0
elif N % 2 == 0:
return 1 + CollatzCount(N // 2)
else:
return 1 + CollatzCount(3 * N + 1)

steps = CollatzCount(6)
print("Returned step count:", steps)
print("CallCount:", CallCount)

1 mark: Correct base case (returning 0 if N == 1).
1 mark: Correct recursive cases for even and odd conditions with step additions.
1 mark: Correctly updating and printing global CallCount resulting in 9.

Python solution:

CallCount = 0

def BinarySearchCount(Arr, Low, High, Target):
global CallCount
CallCount += 1
if Low > High:
return -1
Mid = (Low + High) // 2
if Arr[Mid] == Target:
return Mid
elif Target < Arr[Mid]:
return BinarySearchCount(Arr, Low, Mid - 1, Target)
else:
return BinarySearchCount(Arr, Mid + 1, High, Target)

Arr = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91]
result = BinarySearchCount(Arr, 0, 9, 10)
print("Returned value:", result)
print("CallCount:", CallCount)

1 mark: Correct base cases (Low > High returning -1, and Target found returning Mid).
1 mark: Correct mid calculation and recursive calls with adjusted boundaries.
1 mark: Correctly counting recursive calls (CallCount = 5) and displaying the expected results.

The function traverses the input `ConfigString` character by character. It maintains a boolean flag `is_value` to determine if it is currently reading a key (before the colon) or a value (after the colon). When a semicolon is encountered, it checks if the built-up `current_key` matches the target. If yes, it returns the accumulated `current_value`. If not, both key and value buffers are reset. This allows key-value extraction without utilizing `.split()` or other banned libraries.

Example Test Execution:
`print(GetValue("host:localhost;port:5000;db:users;", "port"))` prints `5000`.

Marks are awarded as follows:
- 1 Mark: Iteration structure that correctly processes every character of the string in order.
- 1 Mark: Tracking state using a flag or variable to distinguish between keys and values (based on `:` identifier).
- 1 Mark: Identifying the end of a key-value pair (based on `;` identifier) and performing comparison against `TargetKey`.
- 1 Mark: Correctly returning the associated value string on match, and returning empty string on mismatch.

The algorithm implements a state-machine parser. It tracks whether the scanner is currently inside a quote block using a boolean flag `in_quotes`. Commas only trigger field splitting when `in_quotes` is false. Quotation marks are omitted from the buffer, solving the requirement to clean quotes from the returned string.

Example Test Execution:
`print(ExtractField("apple,'banana,grape',cherry", 1))` prints `banana,grape`.

Marks are awarded as follows:
- 1 Mark: Character traversal loop with toggle state flag `in_quotes` activated upon matching the quote character.
- 1 Mark: Distinguishing between a separating comma (outside quotes) and literal commas (within quotes).
- 1 Mark: Tracking and incrementing the field index counter, and resetting the field buffer appropriately.
- 1 Mark: Correctly extracting and returning the requested field (handling end-of-string fields) and omitting quotes from the final output.

The algorithm parses the compressed string sequentially. When an alphabetic character is encountered, it signifies the end of the previous run (if there was one). The run is decompressed by multiplying the character by the accumulated count (converted to an integer) and appending it to `result`. The code then sets `current_char` to the new letter and resets the count buffer. Digits are continuously appended to the `current_count` buffer to accommodate multi-digit repetitions. A final decompression cycle must execute after the loop concludes to process the last run.

Example Test Execution:
`print(DecompressString("X5Y11Z2"))` prints `XXXXXYYYYYYYYYYYZZ`.

Marks are awarded as follows:
- 1 Mark: Logic to distinguish alphabetical characters (new runs) from digit characters (run counts).
- 1 Mark: Appending the correct repetition of characters to the result string when a new run begins.
- 1 Mark: Accumulating multi-digit counts as strings before parsing to integer to support numbers > 9.
- 1 Mark: Replicating the decompression step after the loop completes to handle the final sequence.

The function dynamically creates the target string bounds `[Tag]` and `[/Tag]`. It scans the string without relying on built-in find/search methods by defining a helper comparison mechanism. It identifies the index directly following the open tag and the index directly preceding the close tag, checking for valid placement. Finally, it constructs the resulting substring character-by-character from between those indexes.

Example Test Execution:
`print(ExtractTagContent("[bold]Welcome to CIE[/bold]", "bold"))` prints `Welcome to CIE`.

Marks are awarded as follows:
- 1 Mark: Correctly dynamic building of the open and close tags from the `Tag` argument.
- 1 Mark: Parsing character-by-character with loop structure to find the open tag position without built-in index/find routines.
- 1 Mark: Correctly identifying the close tag position relative to the open tag.
- 1 Mark: Reconstructing and returning the inner text, validating tag positions (returning empty string if tags are missing or out of order).