MetadataPastPaper.sampleTitle

(i) A 2-input XOR gate outputs 1 when the two inputs have different values (one high and one low), and outputs 0 when the inputs are the same (both low or both high). (ii) A 2-input NAND gate produces an output of 0 only when both inputs are 1. If any input is 0, the output is 1, which represents the inverse of a standard AND gate.

Part (i) XOR gate [Max 2 marks]: 1 mark for stating output is 1 when inputs are different. 1 mark for stating output is 0 when inputs are the same. Part (ii) NAND gate [Max 2 marks]: 1 mark for stating output is 0 only when both inputs are 1. 1 mark for stating output is 1 if at least one input is 0 (or output is inverse of AND gate).

(a) contiguous: Defragmentation rearranges sectors so that files are stored in contiguous (continuous/consecutive) blocks, minimizing disk head movement.
(b) performance: Reduced physical movement of the read-write head results in faster file access, increasing overall system performance or speed.
(c) incremental: Unlike a full backup, an incremental backup only saves files that have been modified or newly created since the last backup of any type.
(d) compression: Compression algorithms reduce the file size by removing redundancy (lossless) or unnecessary data (lossy), which decreases transmission time.

1 mark for each correct term up to 4 marks:
- (a) contiguous (Accept: consecutive / continuous)
- (b) performance (Accept: speed / read-write speed / response time / throughput / efficiency)
- (c) incremental
- (d) compression (Accept: data compression / file compression)

1. The buffer acts as a temporary storage area to bridge the speed gap between primary memory and the slower secondary storage device. 2. Data is transferred from RAM to the buffer at high speed. This allows the CPU to continue with other operations instead of idling during the slow write process. 3. The secondary storage device reads data from the buffer at its native, slower transfer speed. When the buffer is empty, a hardware interrupt is generated to request more data from RAM.

Award 1 mark per point up to a maximum of 3: - Buffer acts as a temporary storage/holding area (to compensate for speed differences). - CPU sends data to the buffer at high speed, allowing the CPU to continue with other processing tasks / prevents CPU idling. - Slower secondary storage device reads/writes data from the buffer at its own speed. - An interrupt is sent to the CPU when the buffer is empty to request more data.

1. PROM (Programmable ROM) is purchased blank and can only be written to/programmed once. Once programmed, it cannot be erased or modified. 2. EPROM (Erasable Programmable ROM) can be erased by exposing the chip to ultraviolet (UV) light through a quartz window, after which it can be reprogrammed. 3. EEPROM (Electrically Erasable Programmable ROM) can be erased and reprogrammed using electrical signals without being removed from the circuit board.

Award 1 mark for each explanation (max 3): - PROM: Programmed once only / cannot be erased or rewritten. - EPROM: Erased using ultraviolet (UV) light (before being reprogrammed). - EEPROM: Erased/reprogrammed electrically (in-circuit).

1. Vector graphics are stored as a set of drawing instructions and geometric objects (such as lines, curves, and shapes).
2. Each object is defined mathematically by properties such as start/end coordinates, radius, width, line thickness, and fill colour.
3. Scaling a vector graphic does not require adding more pixels; instead, the computer recalculates the mathematical equations to draw the shapes at the new scale. Because the number of shapes and their instruction data remains constant, the file size does not increase.

Award up to 2.5 marks:
- 1 mark: Stating that vector graphics are stored as drawing commands/instructions or geometric shapes defined by mathematical formulas.
- 1 mark: Stating that shapes have properties/attributes (e.g., coordinates, thickness, fill colour).
- 0.5 marks: Explaining that scaling only recalculates these formulas, so no additional pixels/data are stored, keeping the file size constant.

1. Sampling rate is the number of samples taken per second. A higher rate captures more frequent sound measurements, improving fidelity (capturing higher frequencies) but increasing file size as more data points must be stored.
2. Sampling resolution (bit depth) is the number of bits allocated per sample. A higher resolution reduces quantization error, allowing more precise representation of amplitude (improving fidelity) but increasing file size since each sample requires more bits.
3. Both factors directly scale the overall file size: \(File\ Size = Sampling\ Rate \times Sampling\ Resolution \times Duration\).

Award up to 2.5 marks:
- 1 mark: Explaining sampling rate (more frequent samples/higher fidelity vs. more data points/larger file size).
- 1 mark: Explaining sampling resolution (more bits per sample/reduced quantization error vs. larger file size).
- 0.5 marks: Stating or showing that file size is directly proportional to both factors (e.g., through the relationship/formula).

A packet-filtering firewall functions by checking data packets against a set of security criteria. Specifically, it:
1. Inspects the header of each incoming and outgoing packet to extract key transmission details.
2. Compares these packet attributes (such as the source IP address, destination IP address, port number, or protocol) against a pre-determined database of security rules (Access Control Lists).
3. Decides to either allow the packet to pass through to its destination or block/drop the packet if it violates the rules.

Award 1 mark for each of the following points, up to a maximum of 3 marks:
- Explains that the firewall inspects/analyzes the packet headers of incoming and/or outgoing data.
- States that it compares packet details (e.g., source/destination IP address, port number, protocol) against a pre-defined set of security rules/filters.
- Explains that it allows or blocks/drops the packets depending on whether they meet the specified rules.

Transport Layer Security (TLS) is a cryptographic protocol designed to secure internet communications.
1. Purpose: To ensure confidentiality, integrity, and authenticity of data sent over the network.
2. How it works:
- A handshake is initiated where the client verifies the identity of the server using its digital certificate.
- The client and server agree on a symmetric session key.
- All subsequent data sent between the client and server is encrypted using this session key, preventing eavesdropping and tampering.

Award 1 mark for each of the following points, up to a maximum of 3 marks:
- Purpose: To provide secure/private/encrypted communication (or protect confidentiality/integrity of data) over a network.
- Authentication: The client authenticates the server's identity using its digital certificate.
- Encryption: A symmetric session key is negotiated during the handshake, and all subsequent data transmitted is encrypted using this key.

In a client-server architecture, responsibilities are partitioned between the service provider (server) and service requesters (clients). Characteristics suitable for a centralized database include: Centralised security (ensuring data access rules are enforced universally), Centralised backup (enabling routine automated backups of the entire database in one place), Centralised data integrity (avoiding conflicting local copies of database records), and Resource sharing (allowing many clients to query and update the same data store concurrently).

Award 1 mark for each valid characteristic described up to a maximum of 4 marks:
- Centralised security / Access control: User accounts, access rights, and permissions are managed centrally by the server.
- Centralised backup: Data can be backed up in a single location rather than needing individual backups on every machine.
- Centralised data storage / Consistency: Ensures all users access the same, most up-to-date version of the database files.
- Performance/Division of labour: Server processes intensive database queries (back-end) while client manages user interface (front-end).
- Scalability: It is easier to add new clients to the network without degrading the central database structure.
(Do not accept generic benefits of networks like 'can share printers' unless directly linked to database operations.)

A routing table is a database stored in a router that lists the routes to particular network destinations. When a packet is received, the router reads the destination IP address in the packet header, matches it with the best route in the routing table, and forwards the packet to the corresponding output interface.

Award up to 2 marks: 1 mark for stating that the routing table stores network destination paths or next-hop information. 1 mark for explaining that the router compares the destination IP of the incoming packet with the table to find the appropriate outgoing route.

As a packet passes through a router, the router decreases the TTL value by 1. If the TTL reaches 0, the packet is discarded and not forwarded. This prevents packets from traveling infinitely in routing loops and causing network congestion.

Award up to 2 marks: 1 mark for explaining that the router decrements the TTL value by 1 (and/or discards the packet if TTL reaches 0). 1 mark for stating that this prevents packets from circulating endlessly / looping indefinitely in the network.

The SQL script to create the table requires: 1. CREATE TABLE statement with field names and correct data types. 2. Definition of the primary key. 3. Definition of the foreign key referencing the parent table. SQL statement: CREATE TABLE Appointment ( AppointmentID INT NOT NULL, PatientID INT, AppointmentDate DATE, FeeCharged DECIMAL(5,2), PRIMARY KEY (AppointmentID), FOREIGN KEY (PatientID) REFERENCES Patient(PatientID) );

1 mark for correct CREATE TABLE and fields with correct data types (AppointmentID INT, PatientID INT, AppointmentDate DATE, FeeCharged DECIMAL(5,2)). 1 mark for correct PRIMARY KEY definition. 0.66 marks for correct FOREIGN KEY definition referencing Patient(PatientID).

The SQL script requires: 1. SELECT clause listing EmpName, Salary, and DeptName. 2. FROM clause with join syntax (either INNER JOIN or implicit join). 3. WHERE clause to filter salaries > 45000. 4. ORDER BY clause sorting by Salary DESC.

1 mark for SELECT and FROM clause with correct INNER JOIN on DeptID. 1 mark for WHERE clause filtering Salary > 45000. 0.66 marks for ORDER BY Salary DESC.

The SQL query updates rows in the Book table. The SET clause sets the new RentalPrice to 1.10 times the current value. The WHERE clause restricts this change to books of the 'Sci-Fi' genre. SQL: UPDATE Book SET RentalPrice = RentalPrice * 1.10 WHERE Genre = 'Sci-Fi';

1 mark for UPDATE Book and SET RentalPrice = RentalPrice * 1.1 or equivalent. 1.66 marks for correct WHERE Genre = 'Sci-Fi' constraint.

Let's trace the execution step-by-step:

1. `LDD 200` \(\rightarrow\) ACC = 3
2. `STO 202` \(\rightarrow\) Memory[202] = 3
3. `LDM #0` \(\rightarrow\) ACC = 0
4. `STO 203` \(\rightarrow\) Memory[203] = 0

**Iteration 1:**
5. `LDD 203` \(\rightarrow\) ACC = 0 (no change recorded as ACC is already 0)
6. `ADD 201` \(\rightarrow\) ACC = 0 + 4 = 4
7. `STO 203` \(\rightarrow\) Memory[203] = 4
8. `LDD 202` \(\rightarrow\) ACC = 3
9. `DEC ACC` \(\rightarrow\) ACC = 2
10. `STO 202` \(\rightarrow\) Memory[202] = 2
11. `CMP #0` \(\rightarrow\) Compares 2 with 0 (not equal)
12. `JPN LOOP` \(\rightarrow\) Jumps to LOOP

**Iteration 2:**
13. `LDD 203` \(\rightarrow\) ACC = 4
14. `ADD 201` \(\rightarrow\) ACC = 4 + 4 = 8
15. `STO 203` \(\rightarrow\) Memory[203] = 8
16. `LDD 202` \(\rightarrow\) ACC = 2
17. `DEC ACC` \(\rightarrow\) ACC = 1
18. `STO 202` \(\rightarrow\) Memory[202] = 1
19. `CMP #0` \(\rightarrow\) Compares 1 with 0 (not equal)
20. `JPN LOOP` \(\rightarrow\) Jumps to LOOP

**Iteration 3:**
21. `LDD 203` \(\rightarrow\) ACC = 8
22. `ADD 201` \(\rightarrow\) ACC = 8 + 4 = 12
23. `STO 203` \(\rightarrow\) Memory[203] = 12
24. `LDD 202` \(\rightarrow\) ACC = 1
25. `DEC ACC` \(\rightarrow\) ACC = 0
26. `STO 202` \(\rightarrow\) Memory[202] = 0
27. `CMP #0` \(\rightarrow\) Compares 0 with 0 (equal)
28. `JPN LOOP` \(\rightarrow\) No jump, proceeds to next line
29. `END` \(\rightarrow\) Program stops.

### Completed Trace Table:
| ACC | Memory [202] | Memory [203] |
| :---: | :---: | :---: |
| 3 | | |
| | 3 | |
| 0 | | |
| | | 0 |
| 4 | | |
| | | 4 |
| 3 | | |
| 2 | | |
| | 2 | |
| 4 | | |
| 8 | | |
| | | 8 |
| 2 | | |
| 1 | | |
| | 1 | |
| 8 | | |
| 12 | | |
| | | 12 |
| 1 | | |
| 0 | | |
| | 0 | |

- **1.0 Mark**: Correct updates to Memory address [202] with values `3`, `2`, `1`, `0` in correct chronological sequence.
- **1.0 Mark**: Correct updates to Memory address [203] with values `0`, `4`, `8`, `12` in correct chronological sequence.
- **1.5 Marks**: Correct sequence of values in the Accumulator (ACC) column: `3`, `0`, `4`, `3`, `2`, `4`, `8`, `2`, `1`, `8`, `12`, `1`, `0` (allow minor omissions with a 0.5-mark deduction per incorrect sequence change, up to 1.5 marks max).

Let's trace the execution step-by-step:

1. `LDM #3` \(\rightarrow\) ACC = 3
2. `STO 161` \(\rightarrow\) Memory[161] = 3
3. `LDM #0` \(\rightarrow\) ACC = 0
4. `STO 160` \(\rightarrow\) Memory[160] = 0

**Iteration 1 (IX = 0):**
5. `LDX 150` \(\rightarrow\) ACC = Memory[150 + IX] = Memory[150 + 0] = 12
6. `ADD 160` \(\rightarrow\) ACC = 12 + Memory[160] = 12 + 0 = 12 (No ACC change)
7. `STO 160` \(\rightarrow\) Memory[160] = 12
8. `INC IX` \(\rightarrow\) IX = 1
9. `LDD 161` \(\rightarrow\) ACC = Memory[161] = 3
10. `DEC ACC` \(\rightarrow\) ACC = 2
11. `STO 161` \(\rightarrow\) Memory[161] = 2
12. `CMP #0` \(\rightarrow\) Compares ACC (2) with 0
13. `JPN LOOP` \(\rightarrow\) Jumps to LOOP

**Iteration 2 (IX = 1):**
14. `LDX 150` \(\rightarrow\) ACC = Memory[150 + IX] = Memory[150 + 1] = Memory[151] = 7
15. `ADD 160` \(\rightarrow\) ACC = 7 + Memory[160] = 7 + 12 = 19
16. `STO 160` \(\rightarrow\) Memory[160] = 19
17. `INC IX` \(\rightarrow\) IX = 2
18. `LDD 161` \(\rightarrow\) ACC = Memory[161] = 2
19. `DEC ACC` \(\rightarrow\) ACC = 1
20. `STO 161` \(\rightarrow\) Memory[161] = 1
21. `CMP #0` \(\rightarrow\) Compares ACC (1) with 0
22. `JPN LOOP` \(\rightarrow\) Jumps to LOOP

**Iteration 3 (IX = 2):**
23. `LDX 150` \(\rightarrow\) ACC = Memory[150 + IX] = Memory[150 + 2] = Memory[152] = 15
24. `ADD 160` \(\rightarrow\) ACC = 15 + Memory[160] = 15 + 19 = 34
25. `STO 160` \(\rightarrow\) Memory[160] = 34
26. `INC IX` \(\rightarrow\) IX = 3
27. `LDD 161` \(\rightarrow\) ACC = Memory[161] = 1
28. `DEC ACC` \(\rightarrow\) ACC = 0
29. `STO 161` \(\rightarrow\) Memory[161] = 0
30. `CMP #0` \(\rightarrow\) Compares ACC (0) with 0
31. `JPN LOOP` \(\rightarrow\) No jump, proceeds to next line
32. `END` \(\rightarrow\) Program terminates.

### Completed Trace Table:
| ACC | IX | Memory [160] | Memory [161] |
| :---: | :---: | :---: | :---: |
| 3 | | | |
| | | | 3 |
| 0 | | | |
| | | 0 | |
| 12 | | | |
| | | 12 | |
| | 1 | | |
| 3 | | | |
| 2 | | | |
| | | | 2 |
| 7 | | | |
| 19 | | | |
| | | 19 | |
| | 2 | | |
| 2 | | | |
| 1 | | | |
| | | | 1 |
| 15 | | | |
| 34 | | | |
| | | 34 | |
| | 3 | | |
| 1 | | | |
| 0 | | | |
| | | | 0 |

- **1.0 Mark**: Correct updates to `IX` (`1`, `2`, `3`) and Memory address [161] (`3`, `2`, `1`, `0`) in sequence.
- **1.0 Mark**: Correct updates to Memory address [160] (`0`, `12`, `19`, `34`) in sequence.
- **1.5 Marks**: Correct tracking of ACC changes: `3`, `0`, `12`, `3`, `2`, `7`, `19`, `2`, `1`, `15`, `34`, `1`, `0` (allow 0.5-mark deduction per tracking error up to 1.5 marks max).

When a running process requests I/O, it cannot continue executing on the CPU immediately because I/O devices are slow. First, the process transitions from the Running state to the Blocked state. Second, the CPU saves the current state of the process (including the program counter and register values) into its Process Control Block (PCB) to allow future resumption. Third, the operating system scheduler selects a new process from the Ready queue to run, restoring its state from its respective PCB. Finally, once the I/O operation completes, an interrupt is sent to the CPU, and the operating system changes the state of the waiting process from Blocked to Ready so it can compete for CPU time again.

Award 1 mark for each of the following up to a maximum of 4 marks: - State transition 1: Running process transitions to the Blocked state. - Save State: The process's current state (registers, program counter) is saved into its Process Control Block (PCB). - Scheduling: The operating system/scheduler loads and runs a process from the Ready state. - State transition 2: When I/O completes, the process transitions from the Blocked state to the Ready state.

To add the two binary numbers:

\(01011100\) (equivalent to denary \(+92\))
+ \(00110110\) (equivalent to denary \(+54\))
-----------
\(10010010\) (equivalent to signed denary \(-110\))

An overflow error has occurred because the sum of two positive numbers has resulted in a negative number (the sign bit, MSB, is 1). Alternatively, \(92 + 54 = 146\), which is outside the range of 8-bit signed two's complement integers (\(-128\) to \(+127\)).

1 mark: Correct 8-bit binary result of the addition: \(10010010\).
1 mark: Clear explanation of why overflow occurred (e.g., adding two positive numbers resulted in a negative value / MSB is 1, OR the denary sum 146 exceeds the maximum range of +127).

1. Convert the hexadecimal characters to 4-bit binary values:
\(9 = 1001\)
\(\text{C} = 12 = 1100\)
Combined, the 8-bit binary number is \(10011100\).

2. Convert the signed binary integer to denary:
The MSB has a weight of \(-128\).
\(-128 + 16 + 8 + 4 = -100\).

Alternatively, to find the magnitude:
Invert the bits of \(10011100\) \(\rightarrow 01100011\)
Add 1 \(\rightarrow 01100100\) (which is denary \(64 + 32 + 4 = 100\))
Since the MSB was 1, the value is \(-100\).

1 mark: Correctly converting the hexadecimal value to the 8-bit binary pattern: \(10011100\).
1 mark: Correctly calculating the denary representation of this two's complement pattern: \(-100\).

1. Find the two's complement of the subtrahend \(00011011\):
Invert all bits: \(11100100\)
Add 1: \(11100101\)

2. Add this value to the first number \(01001100\):
\(01001100\)
+ \(11100101\)
------------
\(100110001\)

Discard the carry bit from the 9th column to yield the final 8-bit result: \(00110001\).

(Verification: \(76 - 27 = 49\). \(00110001_2 = 32 + 16 + 1 = 49_{10}\)).

1 mark: Correct two's complement of the subtrahend: \(11100101\).
1 mark: Correct final 8-bit binary result: \(00110001\) (ignore any 9th carry bit).

1. Breakpoint: This allows the programmer to set a specific point in the source code where execution will automatically halt. This lets the developer inspect the current state of variables and memory at that exact moment.
2. Single-stepping: This feature allows the programmer to run the program one line/instruction at a time. It is highly useful for tracing the exact execution path and seeing exactly where a logic error occurs.
3. Variable watch (watchpoint): This feature continuously monitors and displays the value of specified variables as the program runs or is stepped through. It helps detect when and how a variable's value changes unexpectedly.

1 mark for correct description of Breakpoint (halting execution at a specific line to inspect state).
1 mark for correct description of Single-stepping (executing code line-by-line to observe program flow).
1 mark for correct description of Variable watch (monitoring and displaying specific variable values during execution).

(a) A program library is a collection of pre-written, pre-compiled modules, functions, or subroutines that can be imported and reused by other software applications to perform common tasks.
(b) Benefits of dynamic linking over static linking:
1. Smaller executable file size: The library code is not combined into the executable file; it remains external and is loaded only at runtime, saving disk space.
2. Independent updates: If a bug is fixed or an improvement is made in the library, the DLL file can be updated without the need to recompile or redistribute the main application.
3. Shared memory: Multiple running applications can share a single copy of the dynamic library loaded in RAM, saving system memory.

(a) 1 mark for defining a program library (pre-compiled/written reusable code/routines).
(b) 2 marks for any two described benefits of dynamic linking (e.g., smaller executable size, independent updates, shared RAM). Max 2 marks.

1. Auto-completion (or Intellisense): Predicts and displays a list of matching keywords, variables, or functions as the programmer types. Selecting from this list speeds up typing and prevents spelling/syntax mistakes.
2. Syntax highlighting: Displays different components of source code (such as language keywords, variables, strings, and comments) in different colors or fonts. This improves code readability and helps the programmer quickly identify syntax errors, such as unclosed strings or mismatched brackets.
3. Auto-indentation: Automatically formats and indents code blocks (such as inside 'if' statements or loops) according to the nesting level. This makes the logical structure and flow of the program visually clear, helping to prevent structural logic errors.

1 mark for explaining Auto-completion (speeding up entry/preventing typos by suggesting keywords/identifiers).
1 mark for explaining Syntax highlighting (color-coding elements to improve readability/spot syntax errors easily).
1 mark for explaining Auto-indentation (automatically formatting code blocks to make logical structure clear).

1. The built-in function used is `MID` (1 mark). Its purpose is to extract a substring of a specified length (here, 1 character) from a source string starting at a specified character index (here, position 6) (1 mark).
2. The parameter passed is `"2022-X-999"`. The character at position 6 is `'X'`. Since `'X'` does not match `'F'`, `'H'`, or `'I'`, the `OTHERWISE` path is taken, returning `"Unknown"` (1 mark).
3. The selection structure is `CASE OF ... ENDCASE` (also acceptable: case selection, multi-way branch) (1 mark).

1. Award 1 mark for correctly identifying the function as `MID`. Award 1 mark for describing its purpose (extracting a substring / specific number of characters from a starting index).
2. Award 1 mark for the exact output string `"Unknown"` (accept without quotes).
3. Award 1 mark for identifying the structure as `CASE OF`, `CASE statement`, or `multi-way selection`. Do not accept simply 'selection' or 'IF statement'.

1. The variable `Remainder` is declared inside the function using `DECLARE`, meaning it has a **local** scope and is only accessible within `ProcessNumber` (1 mark).
2. The nested selection block is the inner `IF Remainder = 0 THEN ... ELSE ... ENDIF` statement which sits entirely within the outer `ELSE` block (1 mark).
3. When the argument is \(-5\), the condition `Value <= 0` evaluates to TRUE (since \(-5 \le 0\)), so the function immediately executes `RETURN "Invalid"` (1 mark).
4. To call the function and assign its result, the correct pseudocode syntax is: `Result <- ProcessNumber(17)` (1 mark).

1. Award 1 mark for 'Local' or 'Local scope'.
2. Award 1 mark for identifying the nested selection block (accept description of the inner `IF` statement or specifying the line range containing the inner check).
3. Award 1 mark for `"Invalid"` (accept without quotes).
4. Award 1 mark for the exact statement: `Result <- ProcessNumber(17)` (allow variable spacing, but the assignment operator `<-` and spelling must be correct).

For (a): Analyzing the loop, when a student's score is 50 or above, 'PassedCount' incremented by 1 ('PassedCount <- PassedCount + 1'). Therefore, its purpose is to count how many students scored 50 or above / passed.
For (b): Looking at the declarations at the beginning of the function, 'DECLARE PassedSum : REAL' explicitly defines the data type for 'PassedSum' as REAL.

1 mark for (a): Purpose must mention counting / storing the number of students who passed or scored 50 or above.
1 mark for (b): REAL (Accept case-insensitive 'Real'. Reject 'Float', 'Double', or 'Decimal' as they are not standard Cambridge pseudocode data types).

Step 1: Check the condition for free delivery. The threshold is $50. If OrderValue >= 50, the delivery is free. Thus, Decision A must check if \(OrderValue \ge 50\).
Step 2: If the condition is False (No branch), the standard delivery cost of $5 is assigned. Thus, Process B must be \(DeliveryCost \leftarrow 5\).
Step 3: After assigning the standard delivery, we check if the customer has a loyalty card to apply a discount. Thus, Decision C must check if \(HasCard = \text{TRUE}\).
Step 4: If Decision C is True (Yes branch), the delivery cost receives a $2 discount, reducing it from $5 to $3. Thus, Process D must assign \(DeliveryCost \leftarrow 3\) or \(DeliveryCost \leftarrow DeliveryCost - 2\).
Step 5: Before outputting, the final total cost must be calculated by adding the order value and delivery cost. Thus, Process E must be \(TotalCost \leftarrow OrderValue + DeliveryCost\).

1 mark per correct block:
- A: OrderValue >= 50 (accept: OrderValue > 49.99, or equivalent logic check)
- B: DeliveryCost <- 5 (accept assignment with <- or =)
- C: HasCard = TRUE (accept: HasCard? or HasCard = TRUE?)
- D: DeliveryCost <- 3 or DeliveryCost <- DeliveryCost - 2 (accept assignment with <- or =)
- E: TotalCost <- OrderValue + DeliveryCost (accept assignment with <- or =)

To convert the flowchart to pseudocode, we follow the logical blocks:
1. Initialize variables: Set both `Count` and `Total` to `0` and take the first `INPUT Value` before entering the loop.
2. Design the loop: The loop runs as long as `Value` is not equal to `-1` (`Value <> -1`). A pre-assertion `WHILE` loop is the most direct fit here.
3. Inside the loop: Add the current `Value` to `Total`, increment `Count` by `1`, and read the next `INPUT Value` so the loop termination condition can be checked again.
4. Design the conditional check after the loop: If `Count > 0`, calculate `Average` as `Total / Count` and output it. Otherwise, output "No data" to avoid a division-by-zero error.

Award up to 5 marks based on the following criteria:
- 1 mark: Initializing variables `Count` and `Total` to 0, AND taking the initial input `Value` before the loop.
- 1 mark: Using a correct loop structure with the condition to terminate when `Value` is `-1` (e.g., `WHILE Value <> -1` ... `ENDWHILE` or equivalent nested structure).
- 1 mark: Correct processing inside the loop: accumulating `Total`, incrementing `Count`, and requesting the next `Value` inside the loop body.
- 1 mark: Correct conditional structure (`IF Count > 0 THEN ... ELSE ... ENDIF`) to check that at least one value was entered before division.
- 1 mark: Correct calculation of `Average` and output of either `Average` or `"No data"` based on the conditional branch.

To define a composite data type, use the TYPE ... ENDTYPE structure. Inside the structure, declare each field with its respective identifier and data type. To declare the array, use the DECLARE keyword followed by the identifier, a colon, the ARRAY keyword with the bounds, and the OF keyword followed by the user-defined type name. Code: TYPE BookRecord DECLARE BookID : INTEGER DECLARE Title : STRING DECLARE IsBorrowed : BOOLEAN ENDTYPE DECLARE LibraryCatalog : ARRAY[1:1000] OF BookRecord

1 Mark: Correct record definition structure using TYPE BookRecord and ENDTYPE. 1 Mark: All three fields correctly declared within the record structure with their specified data types. 1 Mark: Correct declaration of the 1D array including identifier, bounds [1:1000], and correct user-defined base type.

First, define the record type CarDetails with fields RegPlate (STRING) and HoursParked (INTEGER) within a TYPE ... ENDTYPE block. Second, declare a 2D array named GarageGrid with index bounds 1 to 5 and 1 to 50, where each element is of the composite type CarDetails.

1 Mark: Correct definition of TYPE CarDetails and ENDTYPE with appropriate field declarations. 1 Mark: Correct 2-dimensional array declaration syntax. 1 Mark: Correct bounds [1:5, 1:50] and data type OF CarDetails.

Using a 1D array of records offers several distinct advantages over parallel arrays:
- **Data Integrity/Alignment**: With parallel arrays, if you sort or delete an element in one array, you must perform the exact same action at the exact same index in all other three arrays. Failure to do so leads to mismatched member data. With a record, all attributes are bound together, so moving one record keeps all associated data together.
- **Subroutine Parameters**: Modularity is improved. A procedure to process a member's payment only needs to accept one parameter of the record type, rather than multiple parameters for each attribute.
- **Extensibility**: If the club decides to store a fifth attribute (e.g., DateJoined), the programmer only needs to modify the record structure definition. With parallel arrays, a fifth array must be declared, and all array manipulation logic across the program must be updated.

Award 1 mark for each valid advantage explained, up to a maximum of 3 marks:
- **Preventing data misalignment**: Easier to sort/delete/insert data because you only need to swap/manipulate one record index instead of keeping four separate arrays aligned.
- **Simplified modularity**: A single record or the array of records can be passed to subroutines as a single parameter rather than passing multiple parallel arrays/variables.
- **Ease of maintenance / Extensibility**: Adding a new attribute only requires changing the record definition, rather than declaring a new parallel array and rewriting related indexing code.
- **Improved readability / Conceptual logic**: The data structure matches the real-world entity (a member) more logically, making the code easier to understand and debug.

*Note: Do not accept vague answers like "it is faster" or "it takes less memory" unless qualified by specific logic showing why management overhead is reduced.*

An elegant solution checks both constraints: that all side lengths are positive numbers, and that they satisfy the triangle inequality theorem (the sum of any two sides must be strictly greater than the remaining side).

Example Pseudocode:
FUNCTION IsValidTriangle(Side1 : REAL, Side2 : REAL, Side3 : REAL) RETURNS BOOLEAN
IF Side1 > 0 AND Side2 > 0 AND Side3 > 0 THEN
IF (Side1 + Side2 > Side3) AND (Side1 + Side3 > Side2) AND (Side2 + Side3 > Side1) THEN
RETURN TRUE
ELSE
RETURN FALSE
ENDIF
ELSE
RETURN FALSE
ENDIF
ENDFUNCTION

Award up to 5 marks:
1 mark: Correct FUNCTION header defining three parameters of REAL data type and returning a BOOLEAN type.
1 mark: Correct validation that all three sides are strictly positive (Side1 > 0 AND Side2 > 0 AND Side3 > 0).
2 marks: Correct implementation of the triangle inequality rules (sum of any two sides must be greater than the third). Award 1 mark if only some pairs are checked, or if OR is incorrectly used instead of AND.
1 mark: Correct RETURN statements for both valid and invalid scenarios and correct ENDFUNCTION termination.

Line 04 contains the logic error. It initializes `MinValue` to 0. Since the array contains only positive integers, no elements will ever be strictly less than 0. Consequently, the conditional test on line 06 will always evaluate to FALSE, and the function will incorrectly return 0. To fix this, `MinValue` should be initialized to the first element in the array (`List[1]`) or a very large sentinel value.

1 mark: Correctly identifying line 04 (or line 4).
1 mark: Providing a correct replacement statement, such as `MinValue <- List[1]` (accept `MinValue <- List[Index]` if logic is clear, or initializing to a large constant integer value).

The logic error is on line 13. When the `TargetChar` is found on line 07, `Found` is set to TRUE. However, line 10 (`Index <- Index + 1`) still executes before the loop terminates on the next condition check. This increments `Index` to one position past the match. Thus, line 13 returns an incorrect, offset index. Returning `Index - 1` corrects this offset.

1 mark: Correctly identifying line 13.
1 mark: Providing a correct replacement statement, such as `RETURN Index - 1`.

The logic error occurs on line 05. At line 04, `Value1` is overwritten with the value of `Value2`. When line 05 executes, assigning `Value1` back to `Value2` simply duplicates the current value of `Value1` (which is `Value2`), failing to restore the original value of `Value1`. Line 05 must instead assign the saved value stored in the variable `Temp` to `Value2`.

1 mark: Correctly identifying line 05 (or line 5).
1 mark: Providing the correct replacement statement `Value2 <- Temp`.

The algorithm works by: 1. Calculating the length of InString. 2. Using a WHILE loop to find the index of the first non-space character (StartPtr). 3. Checking if StartPtr exceeds the length, meaning the string is empty or contains only spaces, and returning "" if true. 4. Using a WHILE loop searching backwards from the end of InString to find the index of the last non-space character (EndPtr). 5. Initializing an empty OutString and iterating from StartPtr to EndPtr. During each iteration, the character at index i is checked. It is appended to OutString only if both it and the previously processed character are not spaces, effectively collapsing multiple internal spaces into a single space. Finally, OutString is returned.

Award up to 7 marks for correct pseudocode: 1 mark: Correct function header with parameter, return type, and matching ENDFUNCTION. 1 mark: Correct loop/logic to find the index of the first non-space character (StartPtr) to strip leading spaces. 1 mark: Correct check for boundary condition when string is empty or only spaces (returning ""). 1 mark: Correct loop/logic to find the index of the last non-space character (EndPtr) from the right to strip trailing spaces. 1 mark: Correct loop structure starting from StartPtr to EndPtr. 1 mark: Correct condition inside the loop to prevent appending a space if the previous appended character was also a space. 1 mark: Correct string concatenation and updating tracking variables correctly inside the loop, followed by returning the built string.

First, find the storage saving per record:
\(6\text{ bytes} - 4\text{ bytes} = 2\text{ bytes saved per record}\).

Next, multiply the saving per record by the total number of records:
\(2\text{ bytes} \times 10,000 = 20,000\text{ bytes}\).

1 mark for the correct calculation and final value of 20000 (or 20,000).

1. Standard storage size:
\(1,000\text{ elements} \times 1\text{ byte/element} = 1,000\text{ bytes}\).

2. Bit-packed storage size:
Each Boolean uses 1 bit. Total bits needed = 1,000 bits.
Since 1 byte = 8 bits, the total bytes needed = \(1,000 / 8 = 125\text{ bytes}\).

3. Memory saved:
\(1,000\text{ bytes} - 125\text{ bytes} = 875\text{ bytes}\).

1 mark for the correct calculation showing 875 bytes saved.

1. Calculate total size for Option A:
\(500\text{ records} \times 20\text{ bytes/record} = 10,000\text{ bytes}\).

2. Calculate total size for Option B:
Average size per record = \(12\text{ bytes (characters)} + 1\text{ byte (overhead)} = 13\text{ bytes}\).
Total average size for Option B = \(500\text{ records} \times 13\text{ bytes/record} = 6,500\text{ bytes}\).

3. Calculate storage saved:
\(10,000\text{ bytes} - 6,500\text{ bytes} = 3,500\text{ bytes}\).

1 mark for the correct final answer of 3500 (or 3,500).

Decomposition involves breaking a complex system into smaller, self-contained sub-modules. The key advantages are: 1. Teamwork and Parallel Development: Different developers can work on different modules at the same time. 2. Simplified Testing: Modules can be unit-tested individually, making debugging much easier. 3. Reusability: Well-defined modules can be reused within this system or in future projects.

Award 1 mark for each valid advantage, up to a maximum of 3: - Division of labor / multiple programmers can work simultaneously on different modules; - Easier to test and debug individual modules; - Code reusability / modules can be reused in other programs; - Simplifies maintenance as updates can be localized; - Reduces complexity / makes the project easier to understand.

Based on the rules provided in the scenario:
1. For transition X (Current State: S1, Input: 'B'): The rule states 'If it receives 'B', it remains in S1.' Therefore, X is S1.
2. For transition Y (Current State: S2, Input: 'A'): The rule states 'If the system is in state S2 and receives 'A', it transitions to S3.' Therefore, Y is S3.
3. For transition Z (Current State: S3, Input: 'B'): The rule states 'If the system is in state S3 and... if it receives 'B', it transitions to S2.' Therefore, Z is S2.

1 mark for identifying X = S1
1 mark for identifying Y = S3
1 mark for identifying Z = S2

Let's trace the execution step-by-step starting from S1:
- The first character is '+'. A transition from S1 on a sign character ('+' or '-') goes to S2. Thus, after '+', the state is S2.
- The next character is '4'. A transition from S2 on a digit goes to S3.
- The third character is '2'. A transition from S3 on a digit goes to S3. Thus, after '+42', the state is S3.
- The final character is 'A'. Any non-digit/non-sign character transitions the system to the error state S4 from any state. Thus, after '+42A', the state is S4.

1 mark for stating S2 for part 1
1 mark for stating S3 for part 2
1 mark for stating S4 for part 3

Decomposing a system into modules provides several key benefits: First, it enables parallel development, meaning multiple programmers can write and test different modules at the same time, significantly speeding up the project timeline. Second, it facilitates easier testing and debugging, as each module can be isolated and verified independently (unit testing) to ensure correctness before being combined into the larger system. Third, it promotes code reusability, allowing a single module to be invoked multiple times across different parts of the program or even reused in future projects, which reduces code duplication.

Award 1 mark for each valid explained benefit up to a maximum of 2 marks. Acceptable points include: 1. Division of labor / Parallel development: Different programmers can work on different modules at the same time to speed up development. 2. Easier testing and debugging: Individual modules can be tested and debugged independently (unit testing) before integration. 3. Code reusability: Modules can be reused in other parts of the application or in different systems. 4. Manageability / Maintenance: Reduces complexity, making the code easier to understand, maintain, and update in the future.

The following is a complete pseudocode solution:

```
FUNCTION CleanSentence(InputStr : STRING) RETURNS STRING
DECLARE Cleaned : STRING
DECLARE NextChar : CHAR
DECLARE PrevChar : CHAR
DECLARE i : INTEGER

Cleaned <-- ""
PrevChar <-- ' ' // Initialised to space to automatically prevent leading spaces

FOR i <-- 1 TO LENGTH(InputStr)
NextChar <-- MID(InputStr, i, 1)

// Check if the character is alphabetical
IF (NextChar >= 'a' AND NextChar <= 'z') OR (NextChar >= 'A' AND NextChar <= 'Z') THEN
Cleaned <-- Cleaned & NextChar
PrevChar <-- NextChar
ELSEIF NextChar = ' ' THEN
// Append space only if the last appended character was not a space
IF PrevChar <> ' ' THEN
Cleaned <-- Cleaned & ' '
PrevChar <-- ' '
ENDIF
ENDIF
NEXT i

// Remove trailing space if there is one
IF LENGTH(Cleaned) > 0 THEN
IF MID(Cleaned, LENGTH(Cleaned), 1) = ' ' THEN
Cleaned <-- MID(Cleaned, 1, LENGTH(Cleaned) - 1)
ENDIF
ENDIF

RETURN Cleaned
ENDFUNCTION
```

Award up to 6 marks for correct logic:

1. **Function Definition & Return**: Correct function header (defining `InputStr : STRING` as a parameter and returning `STRING`) and corresponding `RETURN` and `ENDFUNCTION`. (1 mark)
2. **Iteration**: Loop starts correctly at index 1 and ends at `LENGTH(InputStr)`. (1 mark)
3. **Character Extraction**: Uses standard `MID(InputStr, i, 1)` to extract each individual character. (1 mark)
4. **Alphabet Validation**: Correct checking and appending of alphabetic characters ('a'..'z' and 'A'..'Z'). (1 mark)
5. **Consecutive & Leading Spaces**: Avoids consecutive space characters and leading spaces (e.g. by tracking the previous character/state or comparing carefully). (1 mark)
6. **Trailing Space Removal**: Correctly checks if the final character is a space and removes it from the final returned string. (1 mark)

An exemplar pseudocode solution is shown below:

```pseudocode
PROCEDURE GenerateOverdueReport(CurrentDate : STRING)
DECLARE Line : STRING
DECLARE StudentID : STRING
DECLARE BookID : STRING
DECLARE DateDue : STRING
DECLARE OverdueCount : INTEGER

OverdueCount <- 0

OPENFILE "Loans.txt" FOR READ
OPENFILE "OverdueReport.txt" FOR WRITE

WHILE NOT EOF("Loans.txt")
READFILE "Loans.txt", Line

// Extract fields using fixed widths
StudentID <- MID(Line, 1, 7)
BookID <- MID(Line, 9, 6)
DateDue <- MID(Line, 16, 10)

// Check if date is overdue
IF DateDue < CurrentDate THEN
WRITEFILE "OverdueReport.txt", StudentID & " overdue for " & BookID
OverdueCount <- OverdueCount + 1
ENDIF
ENDWHILE

// Write the final summary line
WRITEFILE "OverdueReport.txt", "Total overdue: " & NUM_TO_STR(OverdueCount)

CLOSEFILE "Loans.txt"
CLOSEFILE "OverdueReport.txt"
ENDPROCEDURE
```

Award 1 mark for each of the following (max 8 marks):
1. **Procedure Header & Parameter:** Correct procedure header with parameter name and data type (`CurrentDate : STRING`) and matching `ENDPROCEDURE`.
2. **File Operations (Open):** Correctly opening `Loans.txt` for reading and `OverdueReport.txt` for writing.
3. **Looping Logic:** Use of a loop until the end of `Loans.txt` is reached (`WHILE NOT EOF(...)` or equivalent loop structure).
4. **Reading File:** Reading a record/line from `Loans.txt` into a string variable inside the loop.
5. **String Extraction (MID):** Correctly extracting all three parts of the line (`StudentID`, `BookID`, `DateDue`) using `MID` with accurate parameters:
- `StudentID`: `MID(Line, 1, 7)`
- `BookID`: `MID(Line, 9, 6)`
- `DateDue`: `MID(Line, 16, 10)`
6. **Overdue Condition:** Correct comparison (`DateDue < CurrentDate`) and incrementing an integer counter initialization/logic.
7. **File Writing:** Correctly writing the transaction details in the exact format ` overdue for ` to `OverdueReport.txt` inside the loop.
8. **Summary & Close:** Correctly writing the summary line with `NUM_TO_STR(OverdueCount)` to `OverdueReport.txt` *after* the loop and closing both files.