2022 AQA AS-Level Computer Science 7516 Practice Paper with Answers

Solution

Part (a):
We trace the execution of the subroutine Mystery(11, 5) step-by-step:

• Initial state: X = 11, Y = 5, Z = 0.
• Iteration 1: X > 0 (11 > 0) is true. X MOD 2 = 1 (11 MOD 2 = 1) is true, so Z = 0 + 5 = 5. Then X = 11 DIV 2 = 5 and Y = 5 * 2 = 10.
• Iteration 2: X > 0 (5 > 0) is true. X MOD 2 = 1 (5 MOD 2 = 1) is true, so Z = 5 + 10 = 15. Then X = 5 DIV 2 = 2 and Y = 10 * 2 = 20.
• Iteration 3: X > 0 (2 > 0) is true. X MOD 2 = 1 (2 MOD 2 = 0) is false, so Z remains 15 (cell left blank). Then X = 2 DIV 2 = 1 and Y = 20 * 2 = 40.
• Iteration 4: X > 0 (1 > 0) is true. X MOD 2 = 1 (1 MOD 2 = 1) is true, so Z = 15 + 40 = 55. Then X = 1 DIV 2 = 0 and Y = 40 * 2 = 80.
• Termination: X > 0 (0 > 0) is false. Loop terminates.

Part (b):
The subroutine returns Z, which has a final value of 55.

Part (a) (4 marks):
- 1 mark: Row 1 completed correctly (X = 5, Y = 10, Z = 5)
- 1 mark: Row 2 completed correctly (X = 2, Y = 20, Z = 15)
- 1 mark: Row 3 completed correctly (X = 1, Y = 40, Z left blank or written as 15)
- 1 mark: Row 4 completed correctly (X = 0, Y = 80, Z = 55)

Note: Allow follow-through (FT) marks if an arithmetic mistake is carried forward consistently.

Part (b) (1 mark):
- 1 mark: 55 (Accept follow-through from the final value of Z in the trace table).

Solution

Part (a):
We trace the execution of the subroutine Mystery(11, 5) step-by-step:

• Initial state: X = 11, Y = 5, Z = 0.
• Iteration 1: X > 0 (11 > 0) is true. X MOD 2 = 1 (11 MOD 2 = 1) is true, so Z = 0 + 5 = 5. Then X = 11 DIV 2 = 5 and Y = 5 * 2 = 10.
• Iteration 2: X > 0 (5 > 0) is true. X MOD 2 = 1 (5 MOD 2 = 1) is true, so Z = 5 + 10 = 15. Then X = 5 DIV 2 = 2 and Y = 10 * 2 = 20.
• Iteration 3: X > 0 (2 > 0) is true. X MOD 2 = 1 (2 MOD 2 = 0) is false, so Z remains 15 (cell left blank). Then X = 2 DIV 2 = 1 and Y = 20 * 2 = 40.
• Iteration 4: X > 0 (1 > 0) is true. X MOD 2 = 1 (1 MOD 2 = 1) is true, so Z = 15 + 40 = 55. Then X = 1 DIV 2 = 0 and Y = 40 * 2 = 80.
• Termination: X > 0 (0 > 0) is false. Loop terminates.

Part (b):
The subroutine returns Z, which has a final value of 55.

Part (a) (4 marks):
- 1 mark: Row 1 completed correctly (X = 5, Y = 10, Z = 5)
- 1 mark: Row 2 completed correctly (X = 2, Y = 20, Z = 15)
- 1 mark: Row 3 completed correctly (X = 1, Y = 40, Z left blank or written as 15)
- 1 mark: Row 4 completed correctly (X = 0, Y = 80, Z = 55)

Note: Allow follow-through (FT) marks if an arithmetic mistake is carried forward consistently.

Part (b) (1 mark):
- 1 mark: 55 (Accept follow-through from the final value of Z in the trace table).

To find the correct transitions, we analyze the sequence '110' detection logic step-by-step for a Mealy FSM:

1. State S0: We have no active progress on '110'.
- If input is 0, we remain in S0 and output 0. Thus, [A] is 0/0.
- If input is 1, we progress to S1 (first digit matched) and output 0. Thus, [B] is 1/0.

2. State S1: We have matched '1'.
- If input is 0, the sequence is broken, so we go back to S0 and output 0. Thus, [C] is 0/0.
- If input is 1, we progress to S2 (we now have '11' matched) and output 0. Thus, [D] is 1/0.

3. State S2: We have matched '11'.
- If input is 0, the sequence '110' is fully matched. We output 1 and return to S0. Thus, [E] is 0/1.
- If input is 1, we still have '11' at the end of the stream (as '111' ends with '11'), so we remain in S2 and output 0. Thus, [F] is 1/0.

Award 1 mark for each correct transition label identified:
- [A]: 0/0 (1 mark)
- [B]: 1/0 (1 mark)
- [C]: 0/0 (1 mark)
- [D]: 1/0 (1 mark)
- [E]: 0/1 (1 mark)
- [F]: 1/0 (1 mark)

Here are standard implementations of the given algorithm in Python, C#, and VB.NET:

### Python
```python
def IsValidSerial(serial):
if len(serial) != 5:
return False
for i in range(0, 2):
char = serial[i]
if not ('A' <= char <= 'Z'):
return False
for i in range(2, 5):
char = serial[i]
if not ('0' <= char <= '9'):
return False
return True
```

### C#
```csharp
public static bool IsValidSerial(string serial) {
if (serial.Length != 5) {
return false;
}
for (int i = 0; i <= 1; i++) {
char c = serial[i];
if (!(c >= 'A' && c <= 'Z')) {
return false;
}
}
for (int i = 2; i <= 4; i++) {
char c = serial[i];
if (!(c >= '0' && c <= '9')) {
return false;
}
}
return true;
}
```

### VB.NET
```vbnet
Function IsValidSerial(Serial As String) As Boolean
If Serial.Length <> 5 Then
Return False
End If
For I As Integer = 0 To 1
Dim CharVar As Char = Serial(I)
If Not (CharVar >= "A"c AndAlso CharVar <= "Z"c) Then
Return False
End If
Next
For I As Integer = 2 To 4
Dim CharVar As Char = Serial(I)
If Not (CharVar >= "0"c AndAlso CharVar <= "9"c) Then
Return False
End If
Next
Return True
End Function
```

- **1 mark**: Correct function/method definition header with string parameter and correct overall return type framework.
- **1 mark**: Correct validation check on string length (rejecting any string whose length is not exactly 5).
- **1 mark**: Correct loop logic checking that elements at index 0 and 1 represent uppercase alphabetic characters (with standard ASCII bounds/comparison or equivalent functions).
- **1 mark**: Correct loop logic checking that elements at index 2, 3, and 4 represent standard numerical digits (with standard bounds/comparison or equivalent functions).
- **0.5 marks**: Returns true if and only if all preceding constraints are fully met.

Let's perform a step-by-step trace of the execution:

1. **Initialization**:
- `NumList` starts as `[4, 7, 12, 5]`.
- `X` starts at `0`.
- `Y` starts at `1`.

2. **Iteration 1 (`X = 0`)**:
- Condition `X < 3` (‎`0 < 3`‎) is true.
- `NumList[0]` is `4`.
- `4 MOD 2 = 0` is true, so the `THEN` block executes:
- `NumList[0] ← 4 DIV 2` (which is `2`).
- `Y ← 1 * 2` (which is `2`).
- `X ← X + 1` sets `X` to `1`.

3. **Iteration 2 (`X = 1`)**:
- Condition `X < 3` (‎`1 < 3`‎) is true.
- `NumList[1]` is `7`.
- `7 MOD 2 = 0` is false, so the `ELSE` block executes:
- `NumList[1] ← 7 + 1` (which is `8`).
- `Y ← 2 + 8` (which is `10`).
- `X ← X + 1` sets `X` to `2`.

4. **Iteration 3 (`X = 2`)**:
- Condition `X < 3` (‎`2 < 3`‎) is true.
- `NumList[2]` is `12`.
- `12 MOD 2 = 0` is true, so the `THEN` block executes:
- `NumList[2] ← 12 DIV 2` (which is `6`).
- `Y ← 10 * 6` (which is `60`).
- `X ← X + 1` sets `X` to `3`.

5. **Termination**:
- Condition `X < 3` (‎`3 < 3`‎) is false. The loop terminates.
- `NumList[3]` remains unaltered at `5` throughout.

**Completed Trace Table**:

| X | Y | NumList[0] | NumList[1] | NumList[2] | NumList[3] |
|---|---|------------|------------|------------|------------|
| | | 4 | 7 | 12 | 5 |
| 0 | 1 | | | | |
| | 2 | 2 | | | |
| 1 | | | | | |
| | 10| | 8 | | |
| 2 | | | | | |
| | 60| | | 6 | |
| 3 | | | | | |

- **1 mark**: Correctly traces the first iteration (`X = 0` updates `NumList[0]` to `2` and `Y` to `2`).
- **1.5 marks**: Correctly traces the second iteration (`X = 1` updates `NumList[1]` to `8` and `Y` to `10`).
- **1.5 marks**: Correctly traces the third iteration (`X = 2` updates `NumList[2]` to `6` and `Y` to `60`).
- **0.5 marks**: Correct final value of `X` set to `3` indicating the loop termination condition, with `NumList[3]` correctly left unchanged.

To represent the current column position, an identifier such as PlayerCol or CurrentColumn is standard. Because array indices in a grid are whole numbers (0 to 14), the appropriate basic data type is an Integer.

1 mark: Suggesting a sensible integer-focused identifier (e.g., PlayerCol, Col, XCoord, CurrentCol). 0.8 marks: Explicitly specifying the data type as Integer (or int).

Moving north decrements the row index. If CurrentRow is 0, moving north would result in an index of -1, which is out of bounds. Thus, the move is only valid if CurrentRow - 1 >= 0 or equivalently CurrentRow > 0.

1.8 marks for either CurrentRow > 0 or CurrentRow - 1 >= 0 (or equivalent boolean logic).

The generator generates (2, 3) which is empty, so treasure 1 is placed at (2, 3). The second coordinate pair is (2, 3), which is already occupied. The procedure skips this and does not place treasure 2 here. The third is (5, 6), which is empty, so treasure 2 is placed at (5, 6). The fourth is (7, 1), which is empty, so treasure 3 is placed at (7, 1). Thus, 3 items are successfully placed. The duplicate coordinate is (2, 3).

1 mark for stating that 3 items are placed. 0.8 marks for identifying (2, 3) as the duplicate coordinate.

By passing a parameter by reference (ByRef), the subroutine receives a reference to the original variable rather than a copy. Any modifications made inside the subroutine directly affect the original Grid variable in the Main procedure.

1.8 marks for Pass by reference or ByRef.

Since the grid has dimensions N x N and a nested loop is used (the outer loop iterating through rows, and the inner loop iterating through columns), the total number of steps is proportional to N * N = N^2. Therefore, the time complexity is O(N^2).

1.8 marks for writing O(N^2) or O(N^2) equivalent notation.

To handle 'North', 'north', or any word starting with the direction letter, the program can extract the first character of the input string using indexing and convert this character to uppercase to ensure case-insensitivity.

1 mark: Suggesting extracting the first character / substring of length 1. 0.8 marks: Suggesting converting the input to uppercase.

Since strings are immutable, you cannot directly assign a new character to an index. Instead, the whole row string must be reconstructed using slicing and concatenation (e.g., Grid[row] = Grid[row][:col] + 'A' + Grid[row][col+1:]), which requires creating a new string object in memory.

1 mark: Stating that strings are immutable / cannot be modified in-place. 0.8 marks: Explaining the need to reconstruct the string using slicing and concatenation.

Start: Row = 0, Col = 0, Score = 10. Move 1 (S): Row = 1, Col = 0. Score remains 10. Move 2 (E): Row = 1, Col = 1. Land on 'H', so Score reduces to 5. Move 3 (S): Row = 2, Col = 1. Score remains 5. Final state: Row = 2, Col = 1, Score = 5.

0.6 marks for Row = 2. 0.6 marks for Col = 1. 0.6 marks for Score = 5.

The input parameters are X = 7, Y = 3, D = 'E', and GridSize = 8. Checking the conditions: D == 'N' is false. D == 'S' is false. D == 'E' is true, so we evaluate X < GridSize - 1. This evaluates to 7 < 8 - 1, which simplifies to 7 < 7. This condition is false. Finally, D == 'W' is false. Since no branch evaluates to True, the function falls through to the final line and returns False.

1.8 marks: Correctly stating 'False' as the returned value. No partial marks.

Initialize Cost to 10. The condition MoveType == 'Diagonal' is True, so Cost changes to 15. The condition IsBoostActive is True, so Cost becomes 15 * 2 = 30. Calculate Energy = Energy - Cost, which is 25 - 30 = -5. The condition Energy < 0 is True, so Energy is updated to 0. The function returns 0.

1.8 marks: Correctly stating '0' as the returned integer. No partial marks.

We trace the loop over the list [120, 95, 80, 70, 50] with NewScore = 85. For i = 0 (Scores[0] = 120): 85 > 120 is False. For i = 1 (Scores[1] = 95): 85 > 95 is False. For i = 2 (Scores[2] = 80): 85 > 80 is True. The code inserts 85 at index 2, making the list [120, 95, 85, 80, 70, 50]. Scores.pop() removes the last element (50), leaving [120, 95, 85, 80, 70]. Placed is set to True, and the loop is terminated by break. The list is then returned.

1.8 marks: Correctly specifying the list [120, 95, 85, 80, 70]. Accept equivalent syntax representing the same elements in the exact same order.

The modified subroutine first validates the coordinates, then checks for obstacles, and conditionally performs the state change:

\`\`\`python
def MovePlayer(Board, CurrentRow, CurrentCol, NewRow, NewCol):
# Check if new coordinates are within the 8x8 grid boundaries
if NewRow >= 0 and NewRow <= 7 and NewCol >= 0 and NewCol <= 7:
# Check that the target position is not blocked by an obstacle
if Board[NewRow][NewCol] != 'X':
Board[CurrentRow][CurrentCol] = '.'
Board[NewRow][NewCol] = 'P'
return NewRow, NewCol

# Handle invalid scenarios
print("Invalid Move")
return CurrentRow, CurrentCol
\`\`\`

Marks are awarded as follows:
- **Boundary Check (Row)** [1 mark]: Correctly checking if \`NewRow\` is between 0 and 7 inclusive.
- **Boundary Check (Col)** [1 mark]: Correctly checking if \`NewCol\` is between 0 and 7 inclusive.
- **Obstacle Check** [2 marks]: Correctly checking if \`Board[NewRow][NewCol]\` is not equal to \'X\'.
- **Board Update** [2 marks]: Updating the old position to \'.\' and the new position to \'P\' only when all conditions are met.
- **Error Feedback** [2 marks]: Printing \'Invalid Move\' when any of the validation checks fail.
- **Return Coordinates** [2 marks]: Returning the new coordinates on a valid move, and returning the unchanged original coordinates on an invalid move.

The solution implements a nested loop to check neighboring cells while keeping index boundary limits safe using min/max functions or explicit boundary conditions:

\`\`\`python
def CountBurningNeighbours(Forest, Row, Col):
count = 0
# Check row range from Row-1 to Row+1, bound within [0, 9]
start_row = max(0, Row - 1)
end_row = min(9, Row + 1)

# Check column range from Col-1 to Col+1, bound within [0, 9]
start_col = max(0, Col - 1)
end_col = min(9, Col + 1)

for r in range(start_row, end_row + 1):
for c in range(start_col, end_col + 1):
# Skip the target cell itself
if r == Row and c == Col:
continue
# Increment count if neighboring cell is on fire
if Forest[r][c] == 'F':
count += 1
return count
\`\`\`

Marks are awarded as follows:
- **Loop Structure** [2 marks]: Iterating through the neighboring rows and columns (e.g., offsets -1, 0, 1) or individual manual checks.
- **Boundary Checks** [2 marks]: Ensuring that row and column checks remain strictly within the 0 to 9 index range to avoid array out-of-bounds errors.
- **Self-Exclusion** [2 marks]: Preventing the subroutine from counting the cell itself (at \`Row\`, \`Col\`) if it is on fire.
- **Character Comparison** [2 marks]: Correctly checking if the cell value equals \'F\' and incrementing a running counter.
- **Return Value** [2 marks]: Returning the correct total integer count of burning neighbors.

The subroutine must validate input bounds, iterate backwards through the row indices from bottom to top, and place the token when an empty space is detected:

\`\`\`python
def PlaceToken(Board, Column, PlayerToken):
# Step 1: Validate column range
if Column < 0 or Column > 6:
print("Invalid Column")
return False

# Step 2: Traverse from bottom row (5) to top row (0)
for row in range(5, -1, -1):
if Board[row][Column] == '.':
# Step 3: Place token and return True
Board[row][Column] = PlayerToken
return True

# Step 4: Handle full column case
print("Column Full")
return False
\`\`\`

Marks are awarded as follows:
- **Column Validation** [2 marks]: Correctly validating that \`Column\` is in the range 0 to 6, and returning \'False\' with an appropriate output if invalid.
- **Gravity Traversal** [3 marks]: Implementing a reverse loop from 5 down to 0 to search for the lowest free cell.
- **Cell Checking** [2 marks]: Checking for the placeholder character \'.\' to find an empty slot.
- **Board Update** [2 marks]: Assigning the \`PlayerToken\' directly to the found free slot, and returning \'True\'.
- **Full Column Handling** [1 mark]: Printing \'Column Full\' and returning \'False\' when no cell is empty.

Method 1: 1. Convert positive 83 to 8-bit binary: \(01010011\) (as \(64 + 16 + 2 + 1 = 83\)). 2. Invert all bits (one's complement): \(10101100\). 3. Add 1 to get the Two's Complement: \(10101100 + 1 = 10101101\). Method 2: Use place values: \(-128, 64, 32, 16, 8, 4, 2, 1\). We can form \(-83\) by taking \(-128 + 32 + 8 + 4 + 1\). This translates directly to the binary sequence \(10101101\).

1.1 marks: Correct working shown (such as converting positive 83 to binary \(01010011\) or showing a correct place-value calculation). 1.1 marks: Correct final binary representation of \(10101101\).

1. Distribute \(A\) over the parenthesis: \(A \cdot \overline{A} + A \cdot B\). 2. Apply the complement law: \(A \cdot \overline{A} = 0\), resulting in \(0 + A \cdot B\). 3. Apply the identity law: \(0 + A \cdot B = A \cdot B\). The simplified expression is \(A \cdot B\) (or \(A \text{ AND } B\)).

1.1 marks: Applying the distributive law to produce \(A \cdot \overline{A} + A \cdot B\). 1.1 marks: Correctly simplifying the complement term to obtain the final simplified answer \(A \cdot B\).

In hexadecimal, \(C\) is equivalent to 12. Using place values: The digit \(C\) represents \(12 \times 16^1 = 12 \times 16 = 192\). The digit \(5\) represents \(5 \times 16^0 = 5 \times 1 = 5\). Adding these together: \(192 + 5 = 197\).

1.1 marks: Showing the intermediate step of converting the hexadecimal digit \(C\) to 12 and multiplying by 16 to get 192. 1.1 marks: Correctly adding 5 to yield the final denary value of 197.

The Program Counter (PC) holds the address of the next instruction that is scheduled to be executed. During the Fetch stage, this address is copied to the Memory Address Register (MAR) to request the instruction from memory, and the PC is subsequently incremented to point to the next instruction address.

1.1 marks: Stating that the PC holds the address of the next instruction to be executed/fetched. 1.1 marks: Mentioning that the address is transferred to the MAR or explaining that the PC is incremented immediately after the fetch step.

ASCII is limited to 7 or 8 bits, which provides a maximum of 128 or 256 unique character codes. This is only enough for standard English and basic symbols. Unicode was developed using a wider bit layout (such as 16 or 32 bits), allowing for over a million unique code points. This extra capacity allows Unicode to represent characters from multiple languages (e.g., Chinese, Arabic, Cyrillic) and technical symbols simultaneously.

1.1 marks: Identifying that ASCII has limited capacity (7/8 bits) while Unicode uses more bits (e.g., 16/32 bits). 1.1 marks: Explaining the consequence (Unicode can store characters from many different global languages or specialized symbol sets simultaneously).

1. The FSM starts in state \(S_0\). 2. Input '1': The number of 1s becomes odd, so the machine transitions from \(S_0 \rightarrow S_1\). 3. Input '0': The parity does not change, so the machine stays in the same state, transitioning from \(S_1 \rightarrow S_1\). 4. Input '1': The number of 1s becomes even again, so the machine transitions from \(S_1 \rightarrow S_0\). The sequence of state transitions is \(S_0 \rightarrow S_1 \rightarrow S_1 \rightarrow S_0\).

1.1 marks: Correctly identifying the first transition from \(S_0\) to \(S_1\) upon receiving the first '1'. 1.1 marks: Correctly identifying the remaining transitions (staying in \(S_1\) on '0' and returning to \(S_0\) on the final '1').

A compiler scans the entire high-level program source code and translates it all at once into an independent machine-code executable (or object code) file. Once compiled, the program can run without the compiler. An interpreter does not produce a standalone executable file; instead, it translates the high-level code statement-by-statement, executing each instruction on the fly as it is translated during runtime.

1.1 marks: Explaining the compiler's behavior (translates whole program into an object/executable file prior to execution). 1.1 marks: Explaining the interpreter's behavior (translates and executes code statement-by-statement or line-by-line during execution).

In a client-server network, resources, files, and authentication databases are stored centrally on one or more dedicated servers. Client workstations must query the central server to access these files. In contrast, a peer-to-peer (P2P) network has no central server; all computers (peers) have equal status and share their own local data and resources directly with other workstations on the network.

1.1 marks: Explicitly identifying that a client-server network relies on centralized data storage on a dedicated server. 1.1 marks: Explaining that a peer-to-peer network distributes resource storage across individual participating nodes without a central authority.

To convert C3 to binary: C in hex is 12 in decimal, which is 1100 in binary. 3 in hex is 3 in decimal, which is 0011 in binary. Combining these gives 11000011. To convert C3 to decimal: \(12 \times 16^1 + 3 \times 16^0 = 192 + 3 = 195\).

1 mark for correct decimal conversion (195). 1.2 marks for correct 8-bit binary representation (11000011).

Step 1: Expand the terms: \( A \cdot B + A \cdot B + A \cdot C + B \cdot B + B \cdot C \). Step 2: Apply idempotent law \( A \cdot B + A \cdot B = A \cdot B \) and \( B \cdot B = B \): \( A \cdot B + A \cdot C + B + B \cdot C \). Step 3: Group terms with B: \( B \cdot (A + 1 + C) + A \cdot C \). Step 4: Since \( 1 + X = 1 \), this simplifies to: \( B \cdot (1) + A \cdot C = B + A \cdot C \).

1 mark for showing valid intermediate expansion/simplification steps (e.g., getting to \( A \cdot B + A \cdot C + B + B \cdot C \)). 1.2 marks for the correct simplified expression \( B + A \cdot C \) (accept \( B + AC \) or equivalent).

1. Assembly language uses human-readable mnemonics (like ADD, SUB) and labels, whereas machine code is composed entirely of binary (1s and 0s) or hexadecimal representation. 2. Assembly language cannot be directly executed by the CPU and requires an assembler to translate it into machine code, whereas machine code is executed directly by the processor.

1.1 marks for stating that assembly uses mnemonics/labels while machine code is binary. 1.1 marks for stating that assembly requires translation (assembler) whereas machine code is directly executable.

Step 1: Calculate total bits: \( 44,100 \text{ samples/sec} \times 16 \text{ bits/sample} \times 10 \text{ seconds} \times 1 \text{ channel} = 7,056,000 \text{ bits} \). Step 2: Convert to bytes: \( 7,056,000 / 8 = 882,000 \text{ bytes} \). Step 3: Convert to kilobytes: \( 882,000 / 1000 = 882 \text{ kB} \).

1 mark for correct method of calculating byte size (e.g., 44100 * 2 * 10). 1.2 marks for the correct final answer of 882 kB (accept 882).

During the fetch stage, the Program Counter (PC) holds the address of the next instruction to be executed. This address is copied to the Memory Address Register (MAR). Immediately after, or during this cycle, the PC is incremented by one so that it points to the address of the subsequent instruction to be fetched next.

1.1 marks for stating that the PC holds the address of the next instruction (or copies it to the MAR). 1.1 marks for explaining that the PC is incremented to point to the next instruction.

Advantage: An interpreter allows for easier debugging as errors can be identified immediately during execution, and code can be run instantly without waiting for a lengthy compilation process. Disadvantage: Interpreted execution is slower because translation occurs line-by-line during runtime, and the source code must be distributed to the end user, exposing the proprietary intellectual property.

1.1 marks for a valid advantage (e.g., faster debugging, instant execution/testing). 1.1 marks for a valid disadvantage (e.g., slower execution speed, source code is exposed/not optimized).

ASCII uses only 7 bits, allowing for a maximum of 128 unique character codes, which is insufficient for languages other than English. Unicode was developed to represent characters from all global languages, including various scripts, symbols, and emojis. Unicode typically uses 16 or 32 bits per character, providing hundreds of thousands of unique codes compared to ASCII's 128.

1.1 marks for explaining why Unicode was developed (to support global languages/scripts beyond basic English). 1.1 marks for identifying the difference in bit-width/representation size (e.g., 7-bit ASCII vs 16/32-bit Unicode).

Step 1: Expand the terms.
\( Q = A \cdot B + A \cdot B + A \cdot C + B \cdot B + B \cdot C \)

Step 2: Apply the idempotent law \( X \cdot X = X \) and \( X + X = X \).
\( Q = A \cdot B + A \cdot C + B + B \cdot C \)

Step 3: Factor out B from the terms containing B.
\( Q = B \cdot (A + 1 + C) + A \cdot C \)

Step 4: Use the identity \( 1 + X = 1 \).
\( Q = B \cdot (1) + A \cdot C \)
\( Q = B + A \cdot C \)

1 mark: Correct expansion and application of the idempotent law to obtain a partially simplified intermediate form such as \( A \cdot B + A \cdot C + B + B \cdot C \).
1.2 marks: Correctly simplifying down to the final expression \( B + A \cdot C \) (or equivalent representation like \( B + AC \)).

Step 1: Apply De Morgan's Law \( \overline{X + Y} = \overline{X} \cdot \overline{Y} \).
\( Y = \overline{\overline{A \cdot B}} \cdot \overline{\overline{A + C}} \)

Step 2: Apply the Double Negation Law \( \overline{\overline{X}} = X \).
\( Y = (A \cdot B) \cdot (A + C) \)

Step 3: Distribute the terms.
\( Y = A \cdot B \cdot A + A \cdot B \cdot C \)

Step 4: Simplify using idempotent law \( A \cdot A = A \).
\( Y = A \cdot B + A \cdot B \cdot C \)

Step 5: Simplify using absorption law \( X + X \cdot Y = X \).
\( Y = A \cdot B \cdot (1 + C) = A \cdot B \)

1 mark: Correct application of De Morgan's Law and Double Negation to reach \( (A \cdot B) \cdot (A + C) \).
1.2 marks: Correct reduction to the final simplified form \( A \cdot B \) (accept \( AB \)).

1. Express the intermediate outputs:
- Output of NAND gate: \( \overline{A \cdot B} \)
- Output of OR gate: \( \overline{A \cdot B} + C \)
- Output of NOT gate (final output \( Q \)): \( Q = \overline{\overline{A \cdot B} + C} \)

2. Simplify the expression using De Morgan's Law:
- \( Q = \overline{\overline{A \cdot B}} \cdot \overline{C} \)
- Using the double negation rule: \( Q = (A \cdot B) \cdot \overline{C} \)
- Thus, the fully simplified expression is \( Q = A \cdot B \cdot \overline{C} \) (or \( AB\overline{C} \)).

1 mark: Formulating the correct unsimplified expression \( Q = \overline{\overline{A \cdot B} + C} \).
1.2 marks: Applying De Morgan's and double negation rules correctly to obtain the final simplified expression \( A \cdot B \cdot \overline{C} \) (accept standard variations like \( AB\overline{C} \) or \( A \cdot B \cdot C' \)).

Method 1: Using the Distributive Law
\( (A + \overline{B}) \cdot (A + B) = A + (\overline{B} \cdot B) \)
Since \( \overline{B} \cdot B = 0 \):
\( X = A + 0 = A \)

Method 2: Using Expansion
\( X = A \cdot A + A \cdot B + \overline{B} \cdot A + \overline{B} \cdot B \)
- Since \( A \cdot A = A \) and \( \overline{B} \cdot B = 0 \):
\( X = A + A \cdot B + A \cdot \overline{B} \)
- Factor out A: \( X = A \cdot (1 + B + \overline{B}) \)
- Since \( 1 + Y = 1 \) for any expression Y:
\( X = A \cdot 1 = A \)

1 mark: Demonstrating a valid first step, either by using the distributive identity to get \( A + (\overline{B} \cdot B) \) or by fully expanding the expression to \( A \cdot A + A \cdot B + \overline{B} \cdot A + \overline{B} \cdot B \).
1.2 marks: Reaching the fully simplified answer \( A \).

1. Unsimplified left-hand side expression: \( A + \overline{A} \cdot B \)
- One NOT gate is needed to produce \( \overline{A} \).
- One AND gate is needed to compute \( \overline{A} \cdot B \).
- One OR gate is needed to compute \( A + (\overline{A} \cdot B) \).
- Total gates required = 3.

2. Simplified right-hand side expression: \( A + B \)
- Only one OR gate is needed.
- Total gates required = 1.

3. Gates saved: \( 3 - 1 = 2 \) gates.

1 mark: Correctly calculating the gate requirements for both expressions (3 gates for the unsimplified expression and 1 gate for the simplified expression).
1.2 marks: Correct final calculation of 2 gates saved with an explicit explanation of the gates involved (NOT, AND, OR vs. just OR).

To complete the program as specified:
1. We need to multiply the loaded value (stored in register `R0`) by 4. Since \(2^2 = 4\), this is achieved by shifting the contents of `R0` left by 2 bits. The instruction is:
`LSL R0, R0, #2`
2. Next, we need to subtract 7 from the result now held in `R0`. The instruction is:
`SUB R0, R0, #7`

Thus, the completed assembly fragment is:
```assembly
LDR R0, Value1
LSL R0, R0, #2
SUB R0, R0, #7
STR R0, Result
HALT
```

Award marks as follows:
- **1.5 marks** for the first missing instruction: `LSL R0, R0, #2` (Accept equivalent register names if specified, but `R0` is required here. Award 0.5 marks if logical shift left is used with the wrong shift amount, e.g., `#4`).
- **1.0 mark** for the second missing instruction: `SUB R0, R0, #7` (Allow subtraction of register from register if another register was used incorrectly, but must perform subtraction of literal 7).

To clear specific bits while leaving others unchanged, we perform a bitwise logical `AND` operation using a mask.
- To preserve the most significant 4 bits, the corresponding mask bits must be `1`.
- To clear the least significant 4 bits, the corresponding mask bits must be `0`.

This gives a binary mask of `11110000`.
- Converting `11110000` to decimal: \(128 + 64 + 32 + 16 = 240\). The decimal literal is `#240`.
- Converting `11110000` to hexadecimal: `F0`. The hexadecimal literal is `#&F0` or `#0xF0`.

The resulting assembly instruction is:
`AND R1, R1, #240` or `AND R1, R1, #0xF0`

Award marks as follows:
- **1.0 mark** for the correct instruction structure and registers: `AND R1, R1, `.
- **1.5 marks** for the correct immediate mask value of `11110000` represented as either decimal `#240` or hexadecimal `#0xF0` (accept `#&F0` or `#F0`).
- (Max 1.0 mark overall if correct mask value is used but with the wrong mnemonic or destination register).

To obtain high marks (9-12), responses must balance all three areas (ethical, legal, and cultural) and apply them directly to the scenario of the AI-driven triage app.

Key points to cover:

- **Ethical/Moral**: Detail the algorithmic bias resulting from skewed historical training data. Discuss the ethical dilemma of machine error vs. human doctor error, and who holds responsibility for incorrect triage results.
- **Legal**: Identify key legislation such as the UK Data Protection Act 2018 / GDPR. Discuss requirements for processing sensitive medical ('special category') data. Mention liability laws and regulatory frameworks for medical devices/software.
- **Cultural**: Address the digital divide (socioeconomic and age-based access to technology). Discuss changing cultural expectations of healthcare delivery and potential resistance from traditional demographics.

Level 3 (9-12 marks):
- Demonstrates a thorough, balanced, and highly coherent understanding of the ethical, legal, and cultural implications.
- Explicitly refers to the scenario (AI triage, wearable data, automated consultations).
- Accurately names and applies relevant legislation (e.g., Data Protection Act 2018 / GDPR).
- Explains complex ethical issues such as AI training bias and accountability.

Level 2 (5-8 marks):
- Covers at least two of the three aspects (ethical, legal, cultural) in reasonable depth, or all three superficially.
- Relates several points back to the healthcare application scenario.
- Mentions general data security or legal terms, though perhaps without deep specific application.

Level 1 (1-4 marks):
- Points are fragmented, superficial, or presented as a basic list.
- Shows limited understanding of the legal or ethical concepts.
- Does not effectively link the issues to the specific scenario of AI triage or wearable data.