2023 Cambridge IGCSE Computer Science (0478) 模擬試題連答案詳解

To convert 147 to binary: 147 = 128 + 16 + 2 + 1, which gives 10010011 in 8-bit binary. To convert 10010011 to hex: split into two nibbles: 1001 (= 9 in denary/hex) and 0011 (= 3 in denary/hex). Combining them gives 93 in hexadecimal.

1 mark for correct 8-bit binary representation (10010011). 1 mark for correct hexadecimal representation (93). 1 mark for showing correct working (either showing binary decomposition or nibble splitting).

An interrupt is a signal sent to the processor that temporarily suspends current execution. Common scenarios include hardware errors (e.g. printer paper jam, low battery), user inputs (e.g. keyboard key press, mouse click), or software-generated errors (e.g. division by zero, buffer overflow).

1 mark for each valid scenario up to a maximum of 3 marks. Do not accept general terms like 'running a program' without specific interrupt causes.

1. Soil moisture sensor continuously measures moisture levels and sends data to the microprocessor (analogue signals are converted to digital using an ADC). 2. The microprocessor compares the digital readings to preset threshold values. 3. If the moisture level is below the threshold, the microprocessor sends a signal to the actuator (e.g., water pump or valve) to turn it on.

1 mark for explaining that the sensor measures moisture and sends digital data to the microprocessor. 1 mark for explaining that the microprocessor compares this data to preset values. 1 mark for explaining that the microprocessor sends a signal to the actuator to act if the condition is met.

Before transmission, the sending device applies an algorithm to the data block to calculate a checksum value. This value is transmitted alongside the data. The receiving device recalculates the checksum using the exact same algorithm on the received data. Finally, the receiver compares the two checksum values; if they do not match, a transmission error is detected and a retransmission is requested.

1 mark for stating that the sender calculates a checksum from the data before transmission. 1 mark for stating that the checksum is sent along with the data. 1 mark for stating that the receiver recalculates the checksum and compares it, indicating an error if they mismatch.

An expert system consists of three primary components: 1. User Interface: The screen/form through which the doctor inputs symptoms and receives the diagnosis. 2. Knowledge Base: The database containing the accumulated facts and rules from medical experts. 3. Inference Engine: The processing engine that applies rules to facts to draw logical conclusions and make diagnoses.

1 mark for identifying the User Interface and its purpose of facilitating user interaction. 1 mark for identifying the Knowledge Base and its purpose of storing facts and rules. 1 mark for identifying the Inference Engine and its purpose of applying rules to facts to reach a conclusion.

(a) Recommended medium: Solid State Drive (SSD) / Flash Memory.
Reasons:
1. No moving parts: SSDs are highly resistant to physical shocks, vibrations, and high G-forces experienced during balloon launch, ascent, and landing/impact, whereas HDDs have spinning platters and read/write heads that can be easily damaged or misaligned.
2. Lightweight: SSDs have a significantly lower mass/weight compared to HDDs, which reduces the total payload weight of the balloon, helping it reach higher altitudes.
3. Lower power consumption: SSDs do not require an electric motor to spin magnetic platters, meaning they use less power, preserving the balloon's battery life in extreme conditions.
4. Temperature tolerance: SSDs can operate reliably across a much wider temperature range than HDDs, which are prone to failure at extremely low temperatures due to lubricant contraction or mechanical seizing.

(b) NAND flash memory physical operation:
1. NAND flash memory contains millions of tiny memory cells arranged in a grid.
2. Each cell consists of a floating gate transistor designed to store an electrical charge.
3. High voltage is used to push/trap electrons into the floating gate (tunnel injection) or remove them.
4. The presence or absence of trapped electrons (charge) changes the conductivity of the cell, which is read as a binary '1' or '0'.
5. NAND flash is non-volatile, so it retains these electrical charges (the stored data) even when the power supply is completely disconnected.

(a) [4 marks]
- 1 mark for recommending Solid State Drive / SSD / Flash memory.
- 1 mark each for any three valid reasons linked to scenario (e.g., no moving parts/durability against shock/vibration, lightweight/payload limits, lower power consumption/battery preservation, operating temperature limits).
- Note: Do NOT award marks for speed unless linked to high-definition video recording bandwidth, but durability/weight/power/temperature are much more critical to the balloon scenario.

(b) [4 marks]
- 1 mark for identifying NAND flash consists of transistors / memory cells.
- 1 mark for mentioning the floating gate (transistor) / trapping electrons.
- 1 mark for explaining that trapping/removing charge (electrons) determines the binary state (1 or 0) / cell conductivity.
- 1 mark for stating that NAND flash is non-volatile memory (keeps data without power).

(a) Row and Column identification:
- Row 3 has a parity error. (The row contains three 1s: 1+0+0+1+1+0+0 = 3, plus parity bit 0 = 3, which is odd instead of even).
- Column 3 has a parity error. (The column contains one 1: 0+1+0+1 = 2, plus parity row bit 1 = 3, which is odd instead of even).
- The error is located at the intersection of Row 3 and Column 3.
- To correct the error, the value at Row 3, Column 3 (currently 0) is flipped to 1.

(b) Checksum process:
1. Before transmission, the sender calculates a checksum value using a specific algorithm applied to the block of data (e.g., summing all the byte values).
2. The calculated checksum value is appended to the data packet and transmitted.
3. On receipt of the data, the receiver performs the same calculation/algorithm on the received block of data to generate its own checksum.
4. The receiver compares its calculated checksum with the received checksum value. If they are equal, the data is assumed correct; if they differ, an error has occurred, and the receiver requests a retransmission.

(a) [4 marks]
- 1 mark for correctly identifying that Row 3 has an odd number of 1s (fails parity check).
- 1 mark for correctly identifying that Column 3 has an odd number of 1s (fails parity check).
- 1 mark for explaining that the intersection of Row 3 and Column 3 pinpoints the faulty bit.
- 1 mark for stating that the bit value at Row 3, Column 3 must be inverted/flipped from 0 to 1.

(b) [4 marks]
- 1 mark for explaining that the sender calculates a checksum value using an algorithm on the data block.
- 1 mark for stating that the checksum is transmitted along with the data block.
- 1 mark for explaining that the receiver recalculates the checksum using the same algorithm.
- 1 mark for explaining that the receiver compares the two values: if they match, no error; if they do not match, an error is detected (and retransmission is requested).

(a) Boolean expression:
\(X = (A \text{ AND NOT } C) \text{ OR } (B \text{ AND NOT } C)\)

(b) Truth Table:
| A | B | C | X |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 0 | 0 | 1 | 0 |
| 0 | 1 | 0 | 1 |
| 0 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 |
| 1 | 0 | 1 | 0 |
| 1 | 1 | 0 | 1 |
| 1 | 1 | 1 | 0 |

(c) Simplification:
- By applying the distributive law, the common term \text{NOT } C can be factored out:
\(X = (A \text{ OR } B) \text{ AND NOT } C\)
- The logic gates required for this simplified version are:
1. One OR gate (to find \(A \text{ OR } B\))
2. One NOT gate (to find \text{NOT } C)
3. One AND gate (to combine them)

(a) [2 marks]
- 2 marks for the correct logic expression: \(X = (A \text{ AND NOT } C) \text{ OR } (B \text{ AND NOT } C)\).
- Accept alternative standard notations: \(X = (A \cdot \overline{C}) + (B \cdot \overline{C})\) or \(X = (A \land \neg C) \lor (B \land \neg C)\).
- Award 1 mark if one of the terms is correct (e.g., \(A \text{ AND NOT } C\)) or if there is a minor syntax error.

(b) [4 marks]
- 4 marks for all 8 rows correct.
- 3 marks for 6 or 7 rows correct.
- 2 marks for 4 or 5 rows correct.
- 1 mark for 2 or 3 rows correct.
- 0 marks for 0 or 1 row correct.
- Expected outputs:
(0,0,0) -> 0; (0,0,1) -> 0; (0,1,0) -> 1; (0,1,1) -> 0;
(1,0,0) -> 1; (1,0,1) -> 0; (1,1,0) -> 1; (1,1,1) -> 0.

(c) [2 marks]
- 1 mark for the correct simplified expression: \(X = (A \text{ OR } B) \text{ AND NOT } C\) or equivalent notation.
- 1 mark for listing the correct set of gates: 1 OR gate, 1 NOT gate, and 1 AND gate.

(a)(i) To convert \(154\) to binary, determine which power of 2 fit into the number:
\(154 - 128 = 26\)
\(26 - 16 = 10\)
\(10 - 8 = 2\)
\(2 - 2 = 0\)
This gives: \(128 + 16 + 8 + 2\) which in 8-bit binary is \(10011010\).

(ii) To convert \(10011010\) to Hexadecimal, split into two 4-bit nibbles:
\(1001 = 9\)
\(1010 = 10 = \text{A}\)
Combine them to get \(9\text{A}\).

(b) Adding the two binary numbers:
\(10110110 + 01101101\):
\(0 + 1 = 1\)
\(1 + 0 = 1\)
\(1 + 1 = 0\) (carry 1)
\(0 + 1 + 1\text{ (carry)} = 0\) (carry 1)
\(1 + 0 + 1\text{ (carry)} = 0\) (carry 1)
\(1 + 1 + 1\text{ (carry)} = 1\) (carry 1)
\(0 + 1 + 1\text{ (carry)} = 0\) (carry 1)
\(1 + 0 + 1\text{ (carry)} = 0\) (carry 1)
This yields a final 9-bit result: \(100100011\).
Because the register is only 8 bits, the leftmost '1' causes an **overflow error**.

(c) To represent \(-45\) in 8-bit Two's Complement:
1. Convert positive \(+45\) to binary: \(00101101\).
2. Invert all the bits (One's Complement): \(11010010\).
3. Add 1 to the result: \(11010011\).

(d) To convert \(\text{A7}\) from Hexadecimal to Denary:
\(\text{A} = 10\)
\((10 \times 16) + 7 = 160 + 7 = 167\).

Part (a)(i) [2 marks]:
- 1 mark for correct working (e.g., table structure, division method, or sum of powers).
- 1 mark for correct binary value: 10011010.

Part (a)(ii) [2 marks]:
- 1 mark for showing split of nibbles or division by 16.
- 1 mark for correct hexadecimal value: 9A.

Part (b) [4 marks]:
- 1 mark for showing correct column addition carries.
- 1 mark for correct binary sum (either 100100011 or the 8-bit part 00100011).
- 1 mark for identifying the issue as an "overflow error".
- 1 mark for explaining that the result is 9 bits and cannot fit in an 8-bit register.

Part (c) [3 marks]:
- 1 mark for writing positive 45 in binary (00101101).
- 1 mark for showing the correct conversion step (either One's Complement 11010010 or correct mental math using place values \(-128, 64, \dots\)).
- 1 mark for correct final binary representation: 11010011.

Part (d) [2 marks]:
- 1 mark for showing correct conversion working: (10 * 16) + 7.
- 1 mark for correct denary value: 167.

To design the circuit correctly from the problem statement, we translate the conditions into Boolean logic terms:

1. "temperature is high AND humidity is high" is represented by the expression: A AND B. Since input A and input B are connected to Gate 1, Gate 1 must be an AND gate.
2. "humidity is NOT high" is represented by the expression: NOT B. Since input B is connected to Gate 2, Gate 2 must be a NOT gate.
3. "humidity is NOT high AND CO2 level is high" is represented by the expression: (NOT B) AND C. Since the output of Gate 2 (NOT B) and input C are connected to Gate 3, Gate 3 must be an AND gate.
4. These two main conditions are joined by OR ("OR... humidity is NOT high..."). Therefore, the outputs of Gate 1 and Gate 3 must be combined using an OR gate. Since these outputs are connected to Gate 4, Gate 4 must be an OR gate.

Award 1 mark for each correct gate up to a maximum of 4 marks:
- Gate 1: AND (1 mark)
- Gate 2: NOT (1 mark)
- Gate 3: AND (1 mark)
- Gate 4: OR (1 mark)

Accept lowercase equivalents (and, not, or).

To design the circuit correctly from the problem statement, we translate the conditions into Boolean logic terms:

1. "temperature is high AND humidity is high" is represented by the expression: A AND B. Since input A and input B are connected to Gate 1, Gate 1 must be an AND gate.
2. "humidity is NOT high" is represented by the expression: NOT B. Since input B is connected to Gate 2, Gate 2 must be a NOT gate.
3. "humidity is NOT high AND CO2 level is high" is represented by the expression: (NOT B) AND C. Since the output of Gate 2 (NOT B) and input C are connected to Gate 3, Gate 3 must be an AND gate.
4. These two main conditions are joined by OR ("OR... humidity is NOT high..."). Therefore, the outputs of Gate 1 and Gate 3 must be combined using an OR gate. Since these outputs are connected to Gate 4, Gate 4 must be an OR gate.

Award 1 mark for each correct gate up to a maximum of 4 marks:
- Gate 1: AND (1 mark)
- Gate 2: NOT (1 mark)
- Gate 3: AND (1 mark)
- Gate 4: OR (1 mark)

Accept lowercase equivalents (and, not, or).

Let us trace the algorithm step-by-step:
1. Initially, X is set to 15 and Y is set to 4.
2. The loop condition is X > Y. Since 15 > 4 is True, the loop starts.
3. X becomes X - Y (15 - 4 = 11). Y becomes Y + 1 (4 + 1 = 5).
4. Check the condition again: 11 > 5 is True, so the loop continues.
5. X becomes X - Y (11 - 5 = 6). Y becomes Y + 1 (5 + 1 = 6).
6. Check the condition again: 6 > 6 is False, so the loop terminates.
7. The final values are X = 6 and Y = 6. This corresponds to Option B.

Award 1 mark for the correct selection of Option B.

Let us trace the FOR loop step-by-step:
- Initially, Temp is set to 1.
- Index = 2: Scores[2] is 8, and Scores[Temp] (Scores[1]) is 12. Since 8 < 12 is True, Temp is updated to 2.
- Index = 3: Scores[3] is 15, and Scores[Temp] (Scores[2]) is 8. Since 15 < 8 is False, Temp remains 2.
- Index = 4: Scores[4] is 5, and Scores[Temp] (Scores[2]) is 8. Since 5 < 8 is True, Temp is updated to 4.
- Index = 5: Scores[5] is 10, and Scores[Temp] (Scores[4]) is 5. Since 10 < 5 is False, Temp remains 4.
- The loop ends. The final value of Temp is 4, which is the array index of the minimum element (5). This matches Option C.

Award 1 mark for the correct selection of Option C.

Let's trace the loop executions step-by-step:
- i = 1: Data[1] = 12. Compare with all elements. 12 matches at k = 1 and k = 3. Count = 2. Since Count is not 1, Temp is unchanged and j remains 1.
- i = 2: Data[2] = 15. Matches at k = 2 and k = 5. Count = 2. Temp is unchanged, j remains 1.
- i = 3: Data[3] = 12. Matches at k = 1 and k = 3. Count = 2. Temp is unchanged, j remains 1.
- i = 4: Data[4] = 18. Only matches at k = 4. Count = 1. Temp[j] (Temp[1]) becomes 18. j increments to 2.
- i = 5: Data[5] = 15. Matches at k = 2 and k = 5. Count = 2. Temp is unchanged, j remains 2.
- i = 6: Data[6] = 9. Only matches at k = 6. Count = 1. Temp[j] (Temp[2]) becomes 9. j increments to 3.

At the end of the loop, the final values are:
- i = 6
- k = 6
- Count = 1
- j = 3
- Temp[1] = 18
- Temp[2] = 9

- 1 mark: Correctly tracing the loop variable i (ends at 6).
- 1 mark: Correctly tracing the nested loop variable k (ends at 6).
- 2 marks: Correctly calculating the correct Count values for all i iterations (2, 2, 2, 1, 2, 1). Deduct 1 mark for any incorrect Count value.
- 1 mark: Correctly tracing variable j starting at 1, changing to 2 when i = 4, and ending at 3 when i = 6.
- 1 mark: Correctly assigning 18 to Temp[1].
- 1 mark: Correctly assigning 9 to Temp[2].

Let's evaluate each blank to fulfill the logic:
- (1) requires a logical operator to ensure BOTH conditions are met (0 to 100 inclusive), which is AND.
- (2) adds the current valid input to the running total, which is Mark.
- (3) increments the running total count of valid marks, which is ValidCount.
- (4) increments the count of invalid marks, which is InvalidCount + 1.
- (5) closes the IF statement block, which is ENDIF.
- (6) calculates the average by dividing the total of valid marks by the count of valid marks, which is Total / ValidCount.
- (7) outputs the final total of invalid marks, which is InvalidCount.

- 1 mark for (1): AND
- 1 mark for (2): Mark
- 1 mark for (3): ValidCount
- 1 mark for (4): InvalidCount + 1
- 1 mark for (5): ENDIF
- 1 mark for (6): Total / ValidCount
- 1 mark for (7): InvalidCount

Accept case-insensitive variations (e.g., and, endif). Do not accept symbols like && for AND.

To find both the maximum temperature and its frequency, we first initialize the maximum value to the first element in the array (Temps[1]) and set our frequency count to 1. We then loop through the remaining elements (index 2 to 50) of the array. For each element, if it is greater than our current maximum, we update the maximum to this new temperature and reset our frequency counter back to 1. If the element is equal to our current maximum, we increment the frequency counter. At the end of the loop, we output both the calculated maximum value and its frequency.

- 1 mark: Initializing maximum temperature to Temps[1] and initializing frequency count to 1 (or appropriate initialization values such as a very low value and 0 count).
- 1 mark: Setting up a loop to iterate through the array from 1 (or 2) to 50.
- 1 mark: Correct conditional statement checking if the current element is greater than the current maximum temperature.
- 1 mark: Updating maximum temperature to the current element when a higher value is found.
- 1 mark: Resetting the frequency count to 1 when a new higher maximum temperature is set.
- 1 mark: Correct conditional statement to check if the current temperature equals the maximum temperature, and incrementing the count by 1 in this case.
- 1 mark: Printing/outputting both the final maximum temperature and the count with appropriate messages.

Let's analyze the function:
1. The variable Result is initialized to 0. Since calculating factorials involves repeated multiplication, initializing to 0 would lead to a final product of 0 once corrected to multiply. It must be initialized to 1.
2. Inside the FOR loop, the code performs addition (Result <-- Result + Loop) instead of multiplication. Factorial is a product, so we must multiply (Result <-- Result * Loop).
3. The RETURN statement returns the input parameter N instead of returning the computed variable Result.
4. Since the code runs without crashing but produces incorrect results, these are classified as logic errors.

- 2 marks: Identifying that initializing Result to 0 is incorrect (1 mark) and providing the correction: "Result <-- 1" (1 mark).
- 2 marks: Identifying that addition is used inside the loop instead of multiplication (1 mark) and providing the correction: "Result <-- Result * Loop" (1 mark).
- 2 marks: Identifying that returning N is incorrect because it outputs the input value (1 mark) and providing the correction: "RETURN Result" (1 mark).
- 1 mark: Identifying the category of errors as "Logic error(s)".

(a) Step-by-step translation to a Boolean expression:
- "Temperature is high AND humidity is high" becomes: T AND H
- "Manual override switch is ON AND temperature is NOT high" becomes: M AND NOT T
- Combining these two with OR gives: W = (T AND H) OR (M AND NOT T)

(b) Truth table derivation:
- Row 1 (0, 0, 0): (0 AND 0) OR (0 AND NOT 0) = 0 OR 0 = 0
- Row 2 (0, 0, 1): (0 AND 0) OR (1 AND NOT 0) = 0 OR 1 = 1
- Row 3 (0, 1, 0): (0 AND 1) OR (0 AND NOT 0) = 0 OR 0 = 0
- Row 4 (0, 1, 1): (0 AND 1) OR (1 AND NOT 0) = 0 OR 1 = 1
- Row 5 (1, 0, 0): (1 AND 0) OR (0 AND NOT 1) = 0 OR 0 = 0
- Row 6 (1, 0, 1): (1 AND 0) OR (1 AND NOT 1) = 0 OR 0 = 0
- Row 7 (1, 1, 0): (1 AND 1) OR (0 AND NOT 1) = 1 OR 0 = 1
- Row 8 (1, 1, 1): (1 AND 1) OR (1 AND NOT 1) = 1 OR 0 = 1

(c)
(i) The gate that behaves as the inversion of AND is the NAND (NOT-AND) gate.
(ii) A NAND gate produces an output of 1 unless both inputs are 1. By connecting both inputs together, they must always share the same value. If the input is 0, both inputs are 0, giving an output of 1. If the input is 1, both inputs are 1, giving an output of 0. This successfully mimics a NOT gate.

Part (a) [Max 4 marks]:
- 1 mark for: T AND H
- 1 mark for: NOT T
- 1 mark for: M AND NOT T
- 1 mark for joining terms with OR
(Accept equivalent boolean representations: W = (T . H) + (M . T') )

Part (b) [Max 4 marks]:
- 4 marks for all 8 output values correct (0, 1, 0, 1, 0, 0, 1, 1)
- 3 marks for 6 or 7 output values correct
- 2 marks for 4 or 5 output values correct
- 1 mark for 2 or 3 output values correct

Part (c) [Max 3 marks]:
- (i) 1 mark for naming: NAND gate (Do not accept AND gate followed by NOT gate as it asks for a single logic gate)
- (ii) 2 marks:
- 1 mark for explaining that both inputs of the 2-input NAND gate must be tied/joined together (to a single input line).
- 1 mark for explaining the logic (e.g., if input is 1, NAND output is 0; if input is 0, NAND output is 1).

Part (a): FlightID is the correct primary key because it is unique for each flight record, whereas destinations, departure times, capacities, prices, and delay statuses can be repeated across different flights.

Part (b):
- FlightID: Text/Alphanumeric because it contains both letters and numbers.
- DepartureTime: Time (or Date/Time) to capture hours and minutes accurately.
- Capacity: Integer because it represents a count of physical seats (cannot have fractions of a seat).
- Price: Real / Currency / Decimal to support fractional numbers (e.g., 120.50).
- Delay: Boolean because it represents binary states (True/False).

Part (c): The query must select 'FlightID' and 'Destination', filter using '< 150.00' and 'Delay = False', and sort using 'ORDER BY Price ASC' (or simply 'ORDER BY Price' as ASC is the default).

Part (a) [1 mark]:
- 1 mark: FlightID

Part (b) [2.5 marks]:
- 0.5 marks: FlightID -> Text / Alphanumeric / String
- 0.5 marks: DepartureTime -> Time / Date/Time
- 0.5 marks: Capacity -> Integer
- 0.5 marks: Price -> Real / Decimal / Currency
- 0.5 marks: Delay -> Boolean / Logical

Part (c) [5 marks]:
- 1 mark: SELECT FlightID, Destination
- 1 mark: FROM tblFlights
- 1 mark: WHERE Price < 150.00
- 1 mark: ... AND Delay = False (accept equivalent syntax like Delay = 0 or NOT Delay)
- 1 mark: ORDER BY Price (ASC/ascending is optional but correct)

Part (a): BookID is the primary key. Explanation: A library might have multiple copies of the exact same book (same Title, Author, Genre, and YearPublished), meaning non-key attributes are not guaranteed to be unique. BookID uniquely identifies each unique book copy.

Part (b): A Range Check is appropriate because it verifies that the input year falls within a realistic historical and modern boundary (e.g., between 1440 and the current calendar year).

Part (c):
- SELECT Title, Author
- FROM tblBooks
- WHERE (Genre = 'Science' OR Genre = 'History') AND OnLoan = False
- ORDER BY Author ASC
(Note: parentheses around the OR condition are critical so that the AND operator evaluates correctly across both genres).

Part (a) [2.5 marks]:
- 1 mark: BookID
- 1.5 marks: Correct explanation pointing out that multiple books can share the same title, author, or publisher, meaning a custom unique identifier is required to distinguish individual items in the inventory.

Part (b) [1 mark]:
- 1 mark: Range check / Limit check with correct logic defined (e.g., checking if value is >= 1440 and <= current year).

Part (c) [5 marks]:
- 1 mark: SELECT Title, Author
- 1 mark: FROM tblBooks
- 1 mark: WHERE (Genre = 'Science' OR Genre = 'History') (Accept OR logic, but require correct parentheses context when combined with AND)
- 1 mark: ... AND OnLoan = False (accept OnLoan = 0 or NOT OnLoan)
- 1 mark: ORDER BY Author (ASC/ascending is optional but correct)

Here is the complete structured pseudocode solution:

DECLARE CarPark : ARRAY[1:5, 1:10] OF STRING
DECLARE Choice, RegPlate : STRING
DECLARE Floor, Space, EmptyCount, OccupiedCount, Row, Col : INTEGER

// Initialize array
FOR Row <- 1 TO 5
  FOR Col <- 1 TO 10
    CarPark[Row, Col] <- "Empty"
  NEXT Col
NEXT Row

Choice <- ""
WHILE Choice <> "Exit" DO
  OUTPUT "Enter choice (Park, Leave, Display, Exit): "
  INPUT Choice
  IF Choice = "Park" THEN
    OUTPUT "Enter floor (1-5): "
    INPUT Floor
    OUTPUT "Enter space (1-10): "
    INPUT Space
    IF Floor >= 1 AND Floor <= 5 AND Space >= 1 AND Space <= 10 THEN
      IF CarPark[Floor, Space] = "Empty" THEN
        OUTPUT "Enter registration plate: "
        INPUT RegPlate
        CarPark[Floor, Space] <- RegPlate
        OUTPUT "Car parked successfully."
      ELSE
        OUTPUT "Error: Space is already occupied."
      ENDIF
    ELSE
      OUTPUT "Error: Invalid floor or space."
    ENDIF
  ELSEIF Choice = "Leave" THEN
    OUTPUT "Enter floor (1-5): "
    INPUT Floor
    OUTPUT "Enter space (1-10): "
    INPUT Space
    IF Floor >= 1 AND Floor <= 5 AND Space >= 1 AND Space <= 10 THEN
      IF CarPark[Floor, Space] <> "Empty" THEN
        CarPark[Floor, Space] <- "Empty"
        OUTPUT "Space is now vacant."
      ELSE
        OUTPUT "Error: Space is already empty."
      ENDIF
    ELSE
      OUTPUT "Error: Invalid floor or space."
    ENDIF
  ELSEIF Choice = "Display" THEN
    EmptyCount <- 0
    OccupiedCount <- 0
    FOR Row <- 1 TO 5
      FOR Col <- 1 TO 10
        IF CarPark[Row, Col] = "Empty" THEN
          EmptyCount <- EmptyCount + 1
        ELSE
          OccupiedCount <- OccupiedCount + 1
        ENDIF
      NEXT Col
    NEXT Row
    OUTPUT "Total empty spaces: ", EmptyCount
    OUTPUT "Total occupied spaces: ", OccupiedCount
  ELSEIF Choice <> "Exit" THEN
    OUTPUT "Invalid choice. Please try again."
  ENDIF
ENDWHILE

Award 1 mark for each of the following (up to 15 marks total):
1. Initializing 2D array elements using nested loops.
2. Correct loop boundaries for initialization (1 to 5, and 1 to 10).
3. Setting all array elements to 'Empty'.
4. Continuous loop (WHILE ... DO or REPEAT ... UNTIL) controlled by the exit condition 'Exit'.
5. Prompting for and inputting the user choice inside the main loop.
6. Validation of inputs for Floor (1 to 5) and Space (1 to 10).
7. Checking if space is empty ('Empty') before parking.
8. Prompting and storing registration plate in correct index: CarPark[Floor, Space].
9. Outputting error message if spot is occupied when parking.
10. Checking if space is NOT empty before freeing (for Leave choice).
11. Resetting correct coordinate in array to 'Empty' when leaving.
12. Outputting error message if spot is already empty when leaving.
13. Resetting counting variables (EmptyCount, OccupiedCount) to 0 inside 'Display' block before loops.
14. Correct nested loops and conditions to count empty and occupied spots.
15. Outputting final counts with explanatory text.