MetadataPastPaper.sampleTitle

Tracing the loop step-by-step:
- Initial state: Total = 0, Count = 0.
- Iteration i = 0: Value = A[0] = 3. Since 3 MOD 3 == 0, Total becomes 0 + 3 = 3, and Count becomes 0 + 1 = 1.
- Iteration i = 1: Value = A[1] = 7. Since 7 MOD 3 != 0, Total becomes 3 - 1 = 2. Count does not change.
- Iteration i = 2: Value = A[2] = 12. Since 12 MOD 3 == 0, Total becomes 2 + 12 = 14, and Count becomes 1 + 1 = 2.
- Iteration i = 3: Value = A[3] = 5. Since 5 MOD 3 != 0, Total becomes 14 - 1 = 13. Count does not change.
- Iteration i = 4: Value = A[4] = 18. Since 18 MOD 3 == 0, Total becomes 13 + 18 = 31, and Count becomes 2 + 1 = 3.

Completed trace table:
| i | Value | Total | Count |
|---|---|---|---|
| | | 0 | 0 |
| 0 | 3 | 3 | 1 |
| 1 | 7 | 2 | |
| 2 | 12 | 14 | 2 |
| 3 | 5 | 13 | |
| 4 | 18 | 31 | 3 |

Maximum 5 marks:
- 1 mark: Correct values in 'i' column (0, 1, 2, 3, 4) and 'Value' column (3, 7, 12, 5, 18) throughout trace.
- 1 mark: Correct 'Total' column values on iterations 1 & 2 (3, 2).
- 1 mark: Correct 'Total' column values on iterations 3 & 4 (14, 13).
- 1 mark: Correct 'Total' column value on iteration 5 (31).
- 1 mark: Correct 'Count' column values (1, 2, 3) written only when they change (or written fully on respective rows with 1, 1, 2, 2, 3). Accept blank or repeated correct values for Count on unchanged steps.

Let's trace the execution step-by-step:
- Before the loop starts (Initial Check): X is initialized to 45, Y is initialized to 12. Temp is not yet defined.
- First loop test: Y > 0 (12 > 0) is True. Inside the loop:
- Temp <- 45 MOD 12 = 9
- X <- 12
- Y <- 9
- Second loop test: Y > 0 (9 > 0) is True. Inside the loop:
- Temp <- 12 MOD 9 = 3
- X <- 9
- Y <- 3
- Third loop test: Y > 0 (3 > 0) is True. Inside the loop:
- Temp <- 9 MOD 3 = 0
- X <- 3
- Y <- 0
- Fourth loop test: Y > 0 (0 > 0) is False. The loop terminates.
- The final value of X is 3.

- 1 Mark: Correct trace for the first iteration (X = 12, Y = 9, Temp = 9 at the second check).
- 1 Mark: Correct trace for the second iteration (X = 9, Y = 3, Temp = 3 at the third check).
- 1 Mark: Correct final values identifying that the loop terminates when Y reaches 0 (X = 3, Y = 0, Temp = 0 at the final check).
- 0.5 Mark: Correctly identifying the final returned value of X as 3.

Scope defines the parts of a program where a variable can be accessed or modified.
1. Local Variable Scope: Local variables are declared within a specific subroutine (function or procedure) or block of code and are only visible and accessible within that context. Once the subroutine finishes execution, the local variable's lifetime ends and its memory is released.
2. Global Variable Scope: Global variables are declared in the main body of the program outside any specific subroutine and remain accessible from any part of the program throughout its entire runtime.
3. Advantage of Local Variables: Using local variables limits access to data to only where it is needed. This prevents side-effects, such as another subroutine accidentally overwriting a variable's value, and makes code modular, easier to debug, and reusable.

- 1 Mark: Clear definition of local variable scope (restricted to the subroutine/block where declared).
- 1 Mark: Clear definition of global variable scope (accessible throughout the entire program).
- 1.5 Marks: One valid reason for using local variables over global variables, split as:
- 1 Mark: Identifies a valid reason (e.g., 'avoids unintended side effects', 'makes subroutines modular/reusable', 'efficient memory management as they are destroyed after execution').
- 0.5 Mark: Provides clear development-focused explanation or elaboration of that reason.

An elegant way to implement this in Python is:

```python
def ValidateCode(code):
# Rule 1: Check length is exactly 8
if len(code) != 8:
return False

# Rule 2: Check first three characters are uppercase letters
for i in range(3):
if not ('A' <= code[i] <= 'Z'):
return False

# Rule 3: Check fourth character is a hyphen
if code[3] != '-':
return False

# Rule 4: Check that the last four characters are numeric and form a value between 1000 and 9999
last_four = code[4:]
if not last_four.isdigit():
return False

val = int(last_four)
if val < 1000 or val > 9999:
return False

return True
```

### Alternative Version (Pseudocode)
```text
SUBROUTINE ValidateCode(code)
IF LEN(code) != 8 THEN
RETURN False
ENDIF

FOR i FROM 0 TO 2
IF code[i] < 'A' OR code[i] > 'Z' THEN
RETURN False
ENDIF
ENDFOR

IF code[3] != '-' THEN
RETURN False
ENDIF

FOR i FROM 4 TO 7
IF code[i] < '0' OR code[i] > '9' THEN
RETURN False
ENDIF
ENDFOR

val <- TO_INTEGER(SUBSTRING(code, 4, 4))
IF val < 1000 OR val > 9999 THEN
RETURN False
ENDIF

RETURN True
ENDSUBROUTINE
```

Marks are awarded as follows:

1. **Subroutine Structure (1 Mark)**: Correct subroutine header defining name `ValidateCode` and accepting one parameter.
2. **Length Validation (1 Mark)**: Checks if the input string has a length of exactly 8 characters. Returns False or handles state if not.
3. **Uppercase Character Verification (2 Marks)**: Checks that the first three characters are uppercase letters ('A'-'Z'). Award 1 mark for correct indexing/loop limits, and 1 mark for correctly checking they are all within 'A' to 'Z'.
4. **Separator Check (1 Mark)**: Correctly checks that the character at index 3 (fourth position) is a hyphen (`-`).
5. **Digit Type Check (1 Mark)**: Verifies that characters 4 to 7 are all numeric digits (e.g. using a loop, `.isdigit()`, regex, or range comparison '0'-'9').
6. **Integer Range Check (2 Marks)**: Extracts characters 4 to 7 as a substring, safely casts/interprets them as an integer, and checks that this value is between 1000 and 9999 inclusive. Award 1 mark for conversion and 1 mark for the bounds check.
7. **Return Values (1 Mark)**: Subroutine correctly returns `True` only if all validation tests pass, and returns `False` if any test fails.

*Note: Equivalent constructs in any recognized programming language (Python, C#, VB.Net, Java) or pseudocode are fully acceptable.*

The global constants are declared at the top-level scope (not inside any class or subroutine) and are conventionally written in uppercase. Either GRID_SIZE or EMPTY_CELL is correct.

1 mark for either GRID_SIZE or EMPTY_CELL. Accept case-insensitive matches but ignore trailing punctuation.

Inside the MovePlayer method, steps_taken is initialized to 0 and incremented. It is a local variable because its scope is limited to the MovePlayer method.

1 mark for steps_taken. Reject direction (as it is a parameter), self.PlayerY (as it is an instance variable/attribute), or variables from other subroutines.

The parameter list of SetupGrid is (self, initial_score). Therefore, either initial_score or self is a formal parameter.

1 mark for initial_score or self. Reject local variables inside the subroutine like row or new_row.

The identifier DisplayMenu represents a subroutine defined outside of the GridGame class. It returns the value of choice, making it a function.

1 mark for DisplayMenu (accept DisplayMenu()). Reject methods within the class like MovePlayer or SetupGrid.

In the __init__ constructor of the GridGame class, the line self.Grid = [] initializes an instance variable called Grid as an empty list.

1 mark for Grid or self.Grid. Reject local variables like new_row or other attributes like Score or PlayerX.

When parameters are passed by value, a copy of the actual data is passed into the subroutine's local scope. If the subroutine performing the validation checks modifies these variables during its calculations, those modifications remain local and do not alter the player's true position in the calling routine. Passing by reference would create an alias to the original variables, risking unintended changes to the player's location before the move is confirmed.

Award marks as follows:
- 1.0 mark: For explaining that passing by value creates a local copy which prevents the subroutine from accidentally modifying the original coordinate variables in the calling routine (preventing side effects).
- 0.5 marks: For explaining that the subroutine only needs to read or inspect the coordinates to perform its check and does not need to return updated coordinate values through those parameters.

Local variables only exist within the execution context of the subroutine where they are declared. By using local variables for file handlers and loop counters inside `LoadMap`, you ensure that other subroutines cannot accidentally read or overwrite these variables. Additionally, the memory allocated for these variables is released once the subroutine finishes execution, which is more efficient than keeping global variables in memory throughout the program run.

Award marks as follows:
- 1.0 mark: For explaining that local scope prevents accidental modifications or naming conflicts (side-effects) from other subroutines, preserving encapsulation.
- 0.5 marks: For noting that local variables are deallocated when the subroutine finishes, leading to efficient memory management OR making the subroutine easier to test/debug independently.

`GetMenuChoice` returns the validated menu choice (such as an integer or a character) to the calling routine, which means it is a function. Structurally, functions use a return statement to pass data back to the point where they were called, allowing the subroutine call to be assigned to a variable or used in an expression. A procedure simply executes its block of statements and does not pass a value back directly.

Award marks as follows:
- 0.5 marks: Correctly identifying `GetMenuChoice` as a function.
- 1.0 mark: Explaining the key structural difference (functions must return a value to the calling statement, whereas procedures do not return a value).

When a parameter is passed by reference, the subroutine is given the memory address of the actual variable. Therefore, any updates made to the 2D array inside `ResetBoard` immediately update the original array in the calling routine. If it were passed by value, the compiler would create a local copy of the entire 2D array; the resetting would only affect this copy, and the original board would remain unchanged when the subroutine finished.

Award marks as follows:
- 1.0 mark: Explaining that passing by reference allows modifications inside the subroutine to directly update the original array in the calling routine.
- 0.5 marks: Explaining that passing by value would create a copy of the array, meaning any changes would be lost once the subroutine finished execution.

### Detailed Solution

1. **Relationship Type:**
The relationship is **composition**. This is because the Tile objects have a strong ownership relationship with the GameBoard and cannot exist without it.

2. **Difference in Object Lifetimes:**
* **Composition (Strong 'has-a' relationship):** The lifetime of the child object (Tile) is completely controlled by the parent object (GameBoard). If the parent object is destroyed, all its child objects are automatically destroyed along with it.
* **Aggregation (Weak 'has-a' relationship):** The child object can exist independently of the parent object. If the parent object is destroyed, the child object continues to exist (it may be associated with another class or live on in global memory).

3. **Implementation in Code:**
To implement composition, the child objects must be instantiated inside the constructor of the parent class (e.g., using 'new Tile()' inside GameBoard's constructor). This ensures they are created alongside the parent and cannot be passed in from outside already created.

**Marking Scheme:**

* **Part 1 (1 Mark):**
* **1 mark** for stating **Composition** (Accept: 'object composition').

* **Part 2 (2 Marks):**
* **1 mark** for explaining that in composition, the lifetime of the associated object is bound to the parent object / if parent is destroyed, child is destroyed.
* **1 mark** for explaining that in aggregation, the associated object exists independently of the parent / if parent is destroyed, child survives.

* **Part 3 (1 Mark):**
* **1 mark** for explaining that the child objects (Tile) are instantiated / created *inside* the parent class (GameBoard) constructor (or instantiated when the parent is instantiated), rather than being passed in as reference arguments from external code.

To represent a single move from a starting grid square to a destination grid square, the record must capture both the starting and ending positions.

A typical solution defines four fields corresponding to the row and column indices:
- `StartRow` (Integer) and `StartCol` (Integer) to store the starting position.
- `EndRow` (Integer) and `EndCol` (Integer) to store the destination position.

Alternatively, if the grid coordinates are represented as alphanumeric strings (such as "E4"), the structure could use:
- `StartPosition` (String)
- `EndPosition` (String)

Award up to 2 marks:
- 1 Mark: For identifying appropriate fields to represent both the starting position and ending position (e.g. Row/Col or X/Y for start and end, or Start/End position strings).
- 1 Mark: For specifying appropriate and consistent data types (e.g. Integer for indices, String for coordinate codes) for all identified fields.

To represent a single move from a starting grid square to a destination grid square, the record must capture both the starting and ending positions.

A typical solution defines four fields corresponding to the row and column indices:
- `StartRow` (Integer) and `StartCol` (Integer) to store the starting position.
- `EndRow` (Integer) and `EndCol` (Integer) to store the destination position.

Alternatively, if the grid coordinates are represented as alphanumeric strings (such as "E4"), the structure could use:
- `StartPosition` (String)
- `EndPosition` (String)

Award up to 2 marks:
- 1 Mark: For identifying appropriate fields to represent both the starting position and ending position (e.g. Row/Col or X/Y for start and end, or Start/End position strings).
- 1 Mark: For specifying appropriate and consistent data types (e.g. Integer for indices, String for coordinate codes) for all identified fields.

Below is the modified Python subroutine:

def CompressString(Data):
    if len(Data) == 0:
        return ""
    Compressed = ""
    CurrentChar = Data[0]
    Count = 1
    for i in range(1, len(Data)):
        if Data[i] == CurrentChar:
            Count += 1
        else:
            if Count > 1:
                Compressed += str(Count) + CurrentChar
            else:
                Compressed += CurrentChar
            CurrentChar = Data[i]
            Count = 1
    if Count > 1:
        Compressed += str(Count) + CurrentChar
    else:
        Compressed += CurrentChar
    return Compressed

Award marks as follows:
- 1 Mark: Correct check for empty/base case len(Data) == 0.
- 1 Mark: Correctly initialising Compressed, CurrentChar, and Count.
- 1 Mark: Loop correctly iterates through all characters of the input string Data.
- 1 Mark: Checking if Count > 1 inside the loop's else branch.
- 1 Mark: Appending only CurrentChar inside the loop's else branch when Count is 1.
- 1 Mark: Correctly resetting Count to 1 and updating CurrentChar to Data[i] inside the else branch.
- 1 Mark: Correctly applying the identical Count > 1 conditional logic to the final run after the loop completes.
- 1 Mark: Correctly returning the fully compiled Compressed string.

Below is the correct pseudocode solution:

SUBROUTINE UpdateCellSecure(byRef Grid, byVal Row, byVal Col, byVal Val, byRef Success)
IF Row >= 0 AND Row <= 7 AND Col >= 0 AND Col <= 7 THEN
Grid[Row, Col] <- Val
Success <- True
ELSE
Success <- False
ENDIF
ENDSUBROUTINE

This design correctly specifies the parameter passing mechanisms (using byRef for parameters whose modifications need to persist, and byVal for those that do not). It also correctly incorporates range validation to prevent out-of-bounds execution errors.

Award marks as follows (Max 9 marks total):
- 1 mark: Correct subroutine header defining 'UpdateCellSecure' with all 5 parameters.
- 1 mark: Explicitly defining the 'Grid' parameter as passed by reference (e.g., using 'byRef' or equivalent language keyword).
- 1 mark: Explicitly defining the 'Success' parameter as passed by reference.
- 1 mark: Defining 'Row', 'Col', and 'Val' parameters as passed by value (either explicitly using 'byVal' or by default).
- 1 mark: Writing a conditional validation check that tests both lower bounds (Row >= 0 and Col >= 0).
- 1 mark: Writing a conditional validation check that tests both upper bounds (Row <= 7 and Col <= 7).
- 1 mark: Performing array modification 'Grid[Row, Col] <- Val' only within the valid branch of the conditional block.
- 1 mark: Setting 'Success' to True when the update is performed.
- 1 mark: Setting 'Success' to False in an alternative branch when range validation fails.

Here is a complete solution implemented in Python:

```python
def ValidateAndCalculateDistance(WarehouseGrid, StartRow, StartCol, Movements):
# Initialize tracking variables with starting coordinates
currentRow = StartRow
currentCol = StartCol

# Loop through each individual movement step in the sequence
for move in Movements:
if move == 'N':
currentRow -= 1
elif move == 'S':
currentRow += 1
elif move == 'E':
currentCol += 1
elif move == 'W':
currentCol -= 1

# Check if the coordinates have gone out of the 8x8 grid boundary
if currentRow < 0 or currentRow > 7 or currentCol < 0 or currentCol > 7:
return -1

# Check if the current position is blocked by an obstacle
if WarehouseGrid[currentRow][currentCol] == '#':
return -2

# Calculate Manhattan Distance
distance = abs(StartRow - currentRow) + abs(StartCol - currentCol)
return distance
```

### Walkthrough:
1. **Initialization**: We copy `StartRow` and `StartCol` into mutable tracking variables, `currentRow` and `currentCol`.
2. **Iteration**: A loop processes each direction character from the `Movements` string.
3. **Coordinate Update**: Using selective structure (`if/elif`), we update the position. Changing row coordinate coordinates corresponds to North/South moves (-1/+1), and column coordinates corresponds to East/West moves (+1/-1).
4. **Out-of-Bounds Check**: Immediately after updating, we verify if either coordinate is below 0 or above 7. If true, the loop is terminated instantly with return `-1`.
5. **Obstacle Collision Check**: Next, the cell's value is retrieved from `WarehouseGrid`. If it equals `'#'`, we return `-2`.
6. **Distance Calculation**: If the loop finishes without returning, the Manhattan distance is calculated using absolute differences (`abs`) and returned.

### Marking Scheme (Total: 13 Marks)

- **[1 Mark]**: Correct subroutine header with matching parameters (`WarehouseGrid`, `StartRow`, `StartCol`, `Movements`).
- **[1 Mark]**: Initialisation of temporary coordinate tracking variables (`currentRow`, `currentCol`) to the start values.
- **[2 Marks]**: Loop correctly iterates over every element/character in the `Movements` variable.
- **[2 Marks]**: Correct implementation of conditional logic to update coordinates for all 4 moves (North, South, East, West).
- **[2 Marks]**: Boundary checks correctly implemented to ensure `currentRow` and `currentCol` are between 0 and 7 inclusive. Returns `-1` immediately on violation.
- **[2 Marks]**: Obstacle collision check correctly implemented (retrieving value from grid index `[currentRow][currentCol]`). Returns `-2` immediately on finding `'#'`.
- **[2 Marks]**: Correct formula implementation for Manhattan Distance using absolute differences after loop completion.
- **[1 Mark]**: Correct return of the calculated distance value when no violations occur.

To calculate the storage size:

1. Calculate total bits:
\(\text{Sample rate} \times \text{Sample resolution} \times \text{Channels} \times \text{Duration}\)
\(8,000 \text{ Hz} \times 8 \text{ bits} \times 1 \text{ (mono)} \times 40 \text{ seconds} = 2,560,000 \text{ bits}\)

2. Convert bits to bytes:
\(2,560,000 \text{ bits} / 8 = 320,000 \text{ bytes}\)

3. Convert bytes to kibibytes (KiB) using binary prefix rules (where 1 KiB = 1024 bytes):
\(320,000 \text{ bytes} / 1024 = 312.5 \text{ KiB}\)

Therefore, the minimum storage size is 312.5 KiB.

1 mark for calculating the total file size in bytes (320,000 bytes).
1 mark for dividing the bytes by 1024 to obtain the correct size in kibibytes (312.5 KiB).

Under a two's complement fixed-point representation with a 4-bit integer part and 3-bit fractional part, the bit weights from left to right are:
\(-2^3, 2^2, 2^1, 2^0, 2^{-1}, 2^{-2}, 2^{-3}\)
which corresponds to:
\(-8, 4, 2, 1, 0.5, 0.25, 0.125\)

Applying these weights to \(1011.011_2\):
\(-8(1) + 4(0) + 2(1) + 1(1) + 0.5(0) + 0.25(1) + 0.125(1)\)
\(= -8 + 2 + 1 + 0.25 + 0.125\)
\(= -5 + 0.375\)
\(= -4.625\)

Alternatively, converting using the flip-and-add-1 method:
1. Flip the bits: \(0100.100\)
2. Add the value of the least significant bit (\(2^{-3} = 0.125\)): \(0100.101\)
3. Calculate magnitude: \(4 + 0.5 + 0.125 = 4.625\)
4. Apply negative sign: \(-4.625\).

1 mark for establishing the correct bit weights or recognizing that the integer part value is negative (starts with -8).
1 mark for arriving at the correct denary value of -4.625.

The Program Counter (PC) stores the address of the next instruction to be fetched from primary memory. The Current Instruction Register (CIR) holds the actual instruction currently being decoded and executed. Hence, option B is correct.

1 mark for identifying the PC as holding the address of the next instruction.
1 mark for identifying the CIR as holding the instruction currently being decoded.

Let's simplify the Boolean expression step-by-step:

1. Apply De Morgan's Law to the first term:
\(\overline{A + B} = \bar{A} \cdot \bar{B}\)

2. Rewrite the expression:
\((\bar{A} \cdot \bar{B}) + (A \cdot \bar{B})\)

3. Factor out \(\bar{B}\) using the distributive law:
\(\bar{B} \cdot (\bar{A} + A)\)

4. Apply the identity law \(\bar{A} + A = 1\):
\(\bar{B} \cdot (1) = \bar{B}\)

Therefore, the simplest form is \(\bar{B}\).

1 mark for correctly applying De Morgan's Law to get \(\bar{A} \cdot \bar{B}\).
1 mark for factoring out \(\bar{B}\) to obtain the simplified answer of \(\bar{B}\).

Assembly language is a low-level programming language where there is a direct one-to-one relationship between the assembly instructions and equivalent machine code instructions. It uses mnemonic codes (such as ADD, SUB, LDR) instead of raw binary, and needs an assembler to translate it into machine code so that the processor can execute it.

1 mark for identifying assembly language as a low-level mnemonic language.
1 mark for noting the one-to-one mapping requiring an assembler for translation to machine code.

Let's analyze the logic circuit step-by-step:
1. The output of the XOR gate is \(X = A \oplus B\).
2. The inputs to the NAND gate are \(X\) and \(B\).
3. The final output is \(Y = \overline{X \cdot B} = \overline{(A \oplus B) \cdot B}\).

Let's evaluate \(Y\) for each input combination:
- If \(A = 0, B = 0\): \(X = 0 \oplus 0 = 0\). \(Y = \overline{0 \cdot 0} = 1\).
- If \(A = 0, B = 1\): \(X = 0 \oplus 1 = 1\). \(Y = \overline{1 \cdot 1} = 0\).
- If \(A = 1, B = 0\): \(X = 1 \oplus 0 = 1\). \(Y = \overline{1 \cdot 0} = 1\).
- If \(A = 1, B = 1\): \(X = 1 \oplus 1 = 0\). \(Y = \overline{0 \cdot 1} = 1\).

Thus, the final output \(Y\) is 0 only when \(A = 0\) and \(B = 1\).

1 mark for demonstrating a correct trace of intermediate XOR outputs.
1 mark for identifying that the inputs must be A = 0, B = 1 to output 0 from the NAND gate.

To convert \(-75\) into 8-bit two's complement binary:
1. Convert the positive value \(+75\) to binary. \(75 = 64 + 8 + 2 + 1\), which is \(01001011_2\).
2. Invert all the bits of the positive binary representation to get the one's complement: \(10110100_2\).
3. Add 1 to the result to get the two's complement: \(10110100_2 + 1 = 10110101_2\).
Alternatively, using binary place values: \(-128 + 32 + 16 + 4 + 1 = -75\), which directly yields \(10110101_2\).

1 mark: Correct conversion of \(+75\) to binary (\(01001011\)) OR correct setting of place values with a single calculation error.
0.6 marks: Correct final 8-bit two's complement binary representation (\(10110101\)).

To convert \(1101.011_2\) into denary, determine the place value of each bit position:
- Integer part: \(2^3 (8)\), \(2^2 (4)\), \(2^1 (2)\), \(2^0 (1)\). This gives \(1 \times 8 + 1 \times 4 + 0 \times 2 + 1 \times 1 = 13\).
- Fractional part: \(2^{-1} (0.5)\), \(2^{-2} (0.25)\), \(2^{-3} (0.125)\). This gives \(0 \times 0.5 + 1 \times 0.25 + 1 \times 0.125 = 0.375\).
Combine the two parts: \(13 + 0.375 = 13.375\).

1 mark: Correct conversion of either the integer part (13) or the fractional part (0.375).
0.6 marks: Correctly combined final denary value (13.375).

Perform the binary addition:
```
10110100
+ 01101011
----------
(1)00011111
```
The sum of the two numbers is \(100011111_2\). Because this is a 9-bit number, the eighth bit carry generates an overflow condition. The 8-bit result is \(00011111_2\) and overflow has occurred because the correct mathematical result (271) cannot be represented in 8 bits (maximum 255).

1 mark: Correctly performing binary addition to get the binary sum \(00011111\) (even if 9th bit is shown or ignored).
0.6 marks: Correctly stating that overflow has occurred because the sum exceeds the capacity of an 8-bit register.

1. Convert the integer part, \(9\), to a 5-bit binary number: \(9 = 8 + 1\), which is \(01001_2\).
2. Convert the fractional part, \(0.625\), to a 4-bit binary fraction:
- \(0.625 \ge 0.5 (2^{-1}) \rightarrow\) bit is 1. Remainder = 0.125
- \(0.125 < 0.25 (2^{-2}) \rightarrow\) bit is 0. Remainder = 0.125
- \(0.125 \ge 0.125 (2^{-3}) \rightarrow\) bit is 1. Remainder = 0
- remaining bit \(2^{-4} \rightarrow\) bit is 0.
This gives \(.1010_2\).
3. Combine both parts: \(01001.1010_2\).

1 mark: Correct conversion of either the integer part to 5 bits (01001) or the fractional part to 4 bits (1010).
0.6 marks: Correct complete fixed-point representation (01001.1010).

1. Perform the arithmetic shift right by 3 places on \(11001000_2\). Since it is an arithmetic shift, the sign bit (the MSB, which is 1) is preserved and shifted into the vacated positions:
- Shift 1: \(11100100\)
- Shift 2: \(11110010\)
- Shift 3: \(11111001\)
2. Convert the resulting binary number \(11111001_2\) to denary:
Using place values: \(-128 + 64 + 32 + 16 + 8 + 1 = -7\).
(Verification: Original number is \(-128 + 64 + 8 = -56\). Dividing \(-56\) by \(2^3 = 8\) gives \(-7\).)

1 mark: Correct binary representation after shifting 3 places arithmetically (\(11111001\)).
0.6 marks: Correct conversion of that binary number to denary (\(-7\)).

To calculate the file size of an uncompressed audio recording:

1. Identify the key components from the question:
- Sampling rate = \(32\text{ kHz} = 32,000\text{ Hz}\)
- Sample resolution = \(16\text{ bits} = 2\text{ bytes}\)
- Number of channels = \(2\) (stereo)
- Duration = \(256\text{ seconds}\)

2. Calculate the total size in bytes:
\(\text{File Size} = \text{Sampling Rate} \times \text{Bytes per Sample} \times \text{Channels} \times \text{Duration}\)
\(\text{File Size} = 32,000 \times 2 \times 2 \times 256 = 32,768,000\text{ bytes}\)

3. Convert bytes to Mebibytes (MiB) where \(1\text{ MiB} = 2^{20}\text{ bytes} = 1,048,576\text{ bytes}\):
\(\text{File Size in MiB} = \frac{32,768,000}{1,048,576} = 31.25\text{ MiB}\)

- **1 Mark**: Correct calculation of the total size in bytes (\(32,768,000\text{ bytes}\)) or equivalent correct expression in bits (\(262,144,000\text{ bits}\)).
- **1 Mark**: Correct conversion method of dividing by \(2^{20}\) (or \(1,048,576\)) to get MiB.
- **0.5 Marks**: Correct final answer of 31.25 (accept "31.25 MiB").

To find the time taken to write the data, we must first align the storage units:

1. Convert GiB to MiB:
\(1\text{ GiB} = 1024\text{ MiB}\)
\(12.5\text{ GiB} = 12.5 \times 1024 = 12,800\text{ MiB}\)

2. Calculate the time taken:
\(\text{Time} = \frac{\text{Total Size in MiB}}{\text{Write Speed in MiB/s}}\)
\(\text{Time} = \frac{12,800}{400} = 32\text{ seconds}\)

- **1 Mark**: Correct conversion of the image size from GiB to MiB (\(12,800\text{ MiB}\)).
- **1 Mark**: Correct method shown for dividing the total size in MiB by the transfer rate in MiB/s (\(12,800 / 400\)).
- **0.5 Marks**: Correct final answer of 32 (accept "32 seconds").

To calculate the bit rate of the audio stream:

1. Use the formula:
\(\text{Bit Rate} = \text{Sampling Frequency (Hz)} \times \text{Sample Resolution (bits)} \times \text{Number of Channels}\)

2. Substitute the values:
\(\text{Bit Rate} = 96,000\text{ Hz} \times 24\text{ bits} \times 6\text{ channels}\)
\(\text{Bit Rate} = 13,824,000\text{ bits per second (bps)}\)

3. Convert to Megabits per second (Mbps):
\(\text{Bit Rate in Mbps} = \frac{13,824,000}{1,000,000} = 13.824\text{ Mbps}\)

- **1 Mark**: Correct calculation of the bit rate in bits per second (\(13,824,000\text{ bps}\)).
- **1 Mark**: Correct method for converting bps to Mbps by dividing by \(1,000,000\).
- **0.5 Marks**: Correct final answer of 13.824 (accept "13.824 Mbps").

To find the maximum transfer bandwidth of the bus:

1. Convert the bus width from bits to bytes:
\(\text{Bus Width} = \frac{64\text{ bits}}{8} = 8\text{ bytes}\)

2. Express the clock frequency in Hz:
\(\text{Frequency} = 800\text{ MHz} = 800,000,000\text{ Hz}\)

3. Calculate the bandwidth in bytes per second:
\(\text{Bandwidth} = 8\text{ bytes} \times 800,000,000\text{ Hz} = 6,400,000,000\text{ bytes/s}\)

4. Convert to Gigabytes per second (GB/s):
\(\text{Bandwidth in GB/s} = \frac{6,400,000,000}{1,000,000,000} = 6.4\text{ GB/s}\)

- **1 Mark**: Correct conversion of data bus width to bytes (\(8\text{ bytes}\)) and frequency to Hz (\(800 \times 10^6\text{ Hz}\)).
- **1 Mark**: Correctly calculating the byte-rate transfer per second (\(6,400,000,000\text{ bytes/s}\)).
- **0.5 Marks**: Correct final answer of 6.4 (accept "6.4 GB/s").

1. Apply De Morgan's Law to the first term: \( \overline{A \cdot B} = \overline{A} + \overline{B} \).
2. Substitute back into the expression: \( Q = (\overline{A} + \overline{B}) \cdot (A + B) \).
3. Expand the brackets: \( Q = \overline{A}\cdot A + \overline{A}\cdot B + \overline{B}\cdot A + \overline{B}\cdot B \).
4. Since any variable ANDed with its inverse is 0 (\( X \cdot \overline{X} = 0 \)), this simplifies to: \( Q = 0 + \overline{A}\cdot B + A\cdot\overline{B} + 0 = \overline{A}\cdot B + A\cdot\overline{B} \).
5. This is the expression for the XOR operation, which can also be written as: \( Q = A \oplus B \).

1 mark: Correctly applying De Morgan's Law to the first term to obtain \( \overline{A} + \overline{B} \).
1 mark: Expanding the brackets correctly and simplifying terms using the identity \( X \cdot \overline{X} = 0 \).
0.5 marks: Reaching the final correct simplified expression: \( \overline{A}\cdot B + A\cdot\overline{B} \) or \( A \oplus B \).

1. Convert the word description into algebraic notation: 'AND' is represented by multiplication (\(\cdot\)), 'OR' is represented by addition (\(+\)), and 'NOT' is represented by an overbar. Thus, the expression is: \( Y = A \cdot B + \overline{B} \cdot C \).
2. Substitute the input values (\(A = 1, B = 0, C = 1\)) into the expression:
\( Y = 1 \cdot 0 + \overline{0} \cdot 1 \)
\( Y = 0 + 1 \cdot 1 \)
\( Y = 0 + 1 = 1 \).

1 mark: Correct Boolean expression \( Y = A \cdot B + \overline{B} \cdot C \) (or equivalent algebraic notation such as \( AB + \overline{B}C \)).
1 mark: Showing clear evidence of substituting the input values into the expression.
0.5 marks: Stating the correct final output value of 1 (or True).

1. Apply De Morgan's Law to the first term: \( \overline{\overline{X} + Y} = \overline{\overline{X}} \cdot \overline{Y} \).
2. Apply the double negation rule (\( \overline{\overline{X}} = X \)) to simplify the first term to: \( X \cdot \overline{Y} \).
3. Substitute this back into the expression: \( P = X \cdot \overline{Y} + \overline{X} \cdot \overline{Y} \).
4. Factor out the common term \( \overline{Y} \): \( P = (X + \overline{X}) \cdot \overline{Y} \).
5. Use the identity \( X + \overline{X} = 1 \): \( P = 1 \cdot \overline{Y} = \overline{Y} \).

1 mark: Correctly applying De Morgan's Law and double negation to simplify the first term to \( X \cdot \overline{Y} \).
1 mark: Factoring out the common term to obtain \( (X + \overline{X}) \cdot \overline{Y} \).
0.5 marks: Correctly applying the identity \( X + \overline{X} = 1 \) to reach the final simplified expression \( \overline{Y} \).

1. Express the first condition (Sensor A active AND sensor B inactive) as a Boolean product: \( A \cdot \overline{B} \).
2. Express the second condition (Sensor B active AND sensor C active) as a Boolean product: \( B \cdot C \).
3. Combine both conditions with an OR operator (+) as either condition can trigger the alarm: \( S = A \cdot \overline{B} + B \cdot C \).

1 mark: Correct representation of the first condition as \( A \cdot \overline{B} \) (or equivalent standard notation like \( A\overline{B} \)).
1 mark: Correct representation of the second condition as \( B \cdot C \) (or equivalent standard notation like \( BC \)).
0.5 marks: Combining both terms with the OR operator to produce the final complete expression \( S = A \cdot \overline{B} + B \cdot C \).

At the beginning of the fetch stage, the Program Counter (PC) holds the address of the next instruction to be fetched. This address is copied from the PC to the Memory Address Register (MAR) via the internal processor bus, allowing the processor to prepare to read that specific instruction from main memory.

1 mark: State that the address or value in the PC is copied into the MAR. 1 mark: State that the PC holds the address of the next instruction to be fetched or executed.

In a Von Neumann architecture, both program instructions and data share the same physical memory space and the same system buses, which can cause a bottleneck. In contrast, a Harvard architecture maintains physically separate storage and separate signal paths/buses for instructions and data, enabling simultaneous access to both.

1 mark: Mentioning separate memory structures (or address spaces) for instructions and data in Harvard versus shared memory in Von Neumann. 1 mark: Mentioning separate system buses (data and address buses) in Harvard versus shared buses in Von Neumann (or explaining that Harvard allows simultaneous instruction/data access whereas Von Neumann is sequential).

The address bus is unidirectional because address signals only need to travel in one direction: from the processor to memory or input/output controllers to specify a location. The data bus must be bidirectional because data needs to flow in both directions: into the processor during a read operation, and out from the processor during a write operation.

1 mark: Clarifying that the address bus is unidirectional because memory/IO addresses are only generated/sent by the processor. 1 mark: Clarifying that the data bus is bidirectional to facilitate both read (receiving data) and write (sending data) operations.

With an address bus width of 24 bits, the total number of unique addressable locations is represented by \(2^{24}\). Calculating this value gives: \(2^{24} = 16,777,216\) unique addresses.

1 mark: Showing correct working of \(2^{24}\) (or equivalent representation, e.g., \(2^{10} \times 2^{14}\)). 1 mark: Correct integer value of \(16,777,216\) (also accept 16,777,216 addresses, or 16Mi / 16 Meg addresses).

To complete this task, the program performs the following steps:

1. Load the value from memory location `NUM1` into register `R1` using `LDR R1, NUM1`.
2. Load the value from memory location `NUM2` into register `R2` using `LDR R2, NUM2`.
3. Compare the two values using `CMP R1, R2`.
4. Branch conditionally: if `R1` is greater than `R2` (`BGT R1_LARGER`), we jump to the label where `R1` is stored in `MAX`.
5. If the condition is false, the program falls through to `STR R2, MAX`, which handles cases where `R2` is larger or equal.
6. Use an unconditional branch `B FINISH` to bypass the alternative storage block.
7. Provide the label `R1_LARGER:` followed by `STR R1, MAX` to handle the case where `R1` is larger.
8. Terminate the program with the `HALT` instruction at the end of execution.

Award marks as follows:
- **1 Mark**: Correctly loads both values from memory locations `NUM1` and `NUM2` into registers using `LDR`.
- **1 Mark**: Compares the two register values using the `CMP` instruction.
- **1 Mark**: Correct use of a conditional branch (e.g. `BGT`, `BLT`) to split execution flow based on the comparison.
- **1 Mark**: Correctly stores the maximum value to `MAX` using `STR` on both logical paths and terminates program flow cleanly using `HALT` (without falling through to execute both store operations).

1. The reader emits electromagnetic/radio waves through its antenna. 2. When the passive tag enters this range, the waves induce an electrical current in the tag's antenna (electromagnetic induction), which powers the tag's microchip. 3. The powered microchip modulates the signal and reflects it back to the reader (known as backscatter), transmitting its unique identifier or data.

Award marks as follows: 1 Mark: For explaining that the reader emits an electromagnetic field / radio frequency waves. 1 Mark: For explaining that this field induces an electrical current in the tag's antenna to power the microchip. 0.5 Marks: For explaining that the tag modulates and reflects (backscatters) the signal back to the reader to transmit its data.

1. A low-powered laser is focused onto the spiral track of pits and lands on the reflective surface of the spinning CD. 2. A photodetector measures the intensity of the reflected light. 3. Lands reflect the light directly back, whereas pits scatter the light. The transitions between pits and lands cause a change in light intensity which is registered as a binary 1, while no change represents a binary 0.

Award marks as follows: 1 Mark: For stating that a laser is shone onto the spinning surface containing pits and lands. 1 Mark: For explaining that lands reflect light and pits scatter light, which is detected by a photodetector. 0.5 Marks: For explaining that the transitions between pits and lands represent binary 1s and the flat areas represent binary 0s (or that changes in reflection intensity are converted into binary signals).

To gain high marks, candidates must address three distinct dimensions: **1. Moral and Ethical Aspects:** Opportunities include objective triaging, reducing human cognitive fatigue, and clinical priority optimization. Issues include algorithmic bias where historical data contains systemic healthcare biases, automation bias leading to staff blindly trusting the machine, and the erosion of empathy. **2. Legal Aspects:** Opportunities include clear digital logs for accountability and decision-making audits. Issues include strict compliance with data protection laws (e.g., GDPR / UK Data Protection Act 2018) concerning sensitive biometric/health data, and the explicit restriction under GDPR Article 22 against automated decision-making without human review. Liability issues arise regarding who is responsible for misdiagnoses (the software vendor, NHS trust, or clinical operator). **3. Cultural Aspects:** Opportunities include the shift toward tech-enabled modern healthcare. Issues include public skepticism of machine-led triage, linguistic or cultural barriers in how symptoms are described by diverse patient populations, and resistance from medical professionals who feel their diagnostic expertise is undervalued. A high-scoring essay will synthesise these aspects into a balanced conclusion.

**Level 3 (9-12 marks):** Candidate shows a comprehensive and detailed understanding of ethical, legal, and cultural dimensions. Discusses both benefits/opportunities and issues/drawbacks. Integrates relevant terminology correctly (e.g., GDPR, systemic bias, liability, automation bias). Well-structured, coherent, and ends with a reasoned evaluation. **Level 2 (5-8 marks):** Candidate addresses at least two of the dimensions (ethical, legal, cultural) with some detail, or all three with limited depth. The response has a clear structure but may be unbalanced (e.g., focusing heavily on legal issues and neglecting cultural ones). **Level 1 (1-4 marks):** Candidate presents isolated points from one or two dimensions without coherent structure. Understanding is superficial with minimal use of correct terminology. **Specific Points to credit:** *Ethical:* Bias in training data; triage objectivity; moral responsibility for medical errors. *Legal:* GDPR compliance for sensitive health data; right to human intervention; liability of NHS vs software developers. *Cultural:* Public trust in AI triage; digital divide and language barriers; professional resistance from clinical staff.

In a client-server network, data files are stored on a central server, which allows backup operations to be automated and managed centrally. Security credentials, user access rights, and antivirus updates are also administered from this single central server, ensuring consistent security policies across all workstations. In contrast, a peer-to-peer network relies on individual users to manage their own file sharing permissions and backups on their local machines, which increases the risk of data loss or unauthorised access due to human error.

1 mark: For identifying that data and user access are managed centrally (e.g. central backup or centralised access rights). 0.75 marks: For explaining how this improves security/integrity compared to a P2P network (e.g. prevents reliance on individual users to perform backups or secure their own devices, ensuring consistent policies).

When a node wishes to transmit, it sends a Request to Send (RTS) frame to the wireless Access Point (AP). If the AP is free, it replies with a Clear to Send (CTS) broadcast frame. Because the CTS is broadcasted by the AP, all other nodes within range of the AP (including those hidden from the transmitting node) receive it and know to defer their transmissions for a specified duration, thus avoiding collisions.

1 mark: For stating that a node sends an RTS and the Access Point responds with a CTS broadcast to all nodes in its range. 0.75 marks: For explaining that other nodes (even if hidden from the sender) receive the CTS and defer/delay their transmissions to prevent collisions.

Physically, the network is a star because every workstation is connected via its own dedicated cable to a central device (the switch/hub). Logically, it behaves as a bus because the underlying protocol broadcasts data packets to all nodes simultaneously along a single logical path, meaning only one device can transmit at a time and all nodes receive the transmission, mirroring a physical bus.

1 mark: Explaining the physical star layout (each node connected individually to a central hub/switch). 0.75 marks: Explaining the logical bus behaviour (the transmission behaves as if it is broadcast to all nodes on a single shared logical channel, where collisions can occur or CSMA/CD protocols are applied).

The SSID is a unique, alphanumeric identifier that acts as the name of a wireless network. Disabling the SSID broadcast means that the network name will not appear in the list of available networks shown to nearby devices. To connect, a user must manually enter the exact SSID, which deters casual intruders or wardrivers from discovering and attempting to access the network.

1 mark: Stating the purpose of an SSID (to uniquely identify/name a wireless network for client connection). 0.75 marks: Explaining that disabling the broadcast hides the network name from standard scans/device searches, preventing casual unauthorised access attempts (though not stopping sophisticated attackers who can sniff the SSID from active traffic).