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

Description A matches 'Full-duplex serial' because data flows in both directions simultaneously (full-duplex) using a single communication channel (serial).
Description B matches 'Simplex parallel' because data flows in only one direction (simplex) across multiple wires simultaneously (parallel).
Description C matches 'Half-duplex serial' because data flows in both directions but only one direction at a time (half-duplex) using a single channel (serial).

Award marks as follows (total 1.5 marks):
- 0.5 marks for correctly identifying Description A as Full-duplex serial.
- 0.5 marks for correctly identifying Description B as Simplex parallel.
- 0.5 marks for correctly identifying Description C as Half-duplex serial.

Statement A describes spyware (specifically a keylogger), which secretly records keyboard inputs to steal data.
Statement B describes pharming, which redirects web traffic to fraudulent websites by altering DNS tables or host files.
Statement C describes phishing, which relies on social engineering via deceptive emails to capture private user information.

Award marks as follows (total 1.5 marks):
- 0.5 marks for identifying Statement A as Spyware or Keylogger.
- 0.5 marks for identifying Statement B as Pharming.
- 0.5 marks for identifying Statement C as Phishing.

Function A is performed by a Microprocessor, which executes comparison logic and decides if any actions are required.
Function B is performed by a Sensor (specifically a temperature sensor), which reads physical properties of the environment.
Function C is performed by an Actuator (such as a motor), which executes a physical action to change the system's state.

Award marks as follows (total 1.5 marks):
- 0.5 marks for matching Function A to Microprocessor.
- 0.5 marks for matching Function B to Sensor.
- 0.5 marks for matching Function C to Actuator.

Technology A describes Optical storage (such as CDs, DVDs, and Blu-rays) using optical lasers and physical pits and lands.
Technology B describes Solid State storage (such as SSDs and USB drives) which use microchips with no mechanical parts.
Technology C describes Magnetic storage (such as Hard Disk Drives) which write data patterns using magnetizable platters.

Award marks as follows (total 1.5 marks):
- 0.5 marks for matching Technology A to Optical.
- 0.5 marks for matching Technology B to Solid State.
- 0.5 marks for matching Technology C to Magnetic.

Scenario A describes a Media Access Control (MAC) address, which uniquely identifies physical network components.
Scenario B describes HTML/CSS color codes, which use 2 hexadecimal digits for each of the red, green, and blue intensities.
Scenario C describes memory addresses, which are frequently represented in hexadecimal during software development and debugging to keep the numbers short and readable.

Award marks as follows (total 1.5 marks):
- 0.5 marks for matching Scenario A to MAC address.
- 0.5 marks for matching Scenario B to HTML color code (or Hex color code).
- 0.5 marks for matching Scenario C to Assembly memory address (or Memory address).

At the start of the cycle, the Program Counter (PC) holds the memory address of the next instruction to be fetched. This address is sent over the address bus to the Memory Address Register (MAR). At the same time, the PC is incremented by 1 so that it points to the next instruction in sequence. The MAR holds this address while a control signal is sent to primary memory to fetch the instruction from that specific location, placing it on the data bus to be sent to the Memory Data Register (MDR).

Award marks as follows (Max 4.5 marks):
- 1 mark: For stating that the PC holds/stores the address of the next instruction to be fetched.
- 1 mark: For explaining that the address is copied from the PC to the MAR.
- 1 mark: For explaining that the PC is incremented (by 1) to point to the next instruction.
- 1 mark: For explaining that the MAR holds this address while the primary memory is accessed to retrieve the data/instruction.
- 0.5 mark: For mentioning that the fetched instruction is then loaded into the Memory Data Register (MDR) via the data bus.

Over a long distance of 2 km, parallel transmission suffers from data skew where bits travel at slightly different speeds and arrive out of alignment, corrupting the data. Serial transmission sends data one bit at a time down a single channel, eliminating skew. It is also significantly cheaper as it requires fewer physical wires. Simplex is selected because the sensor only needs to send data unidirectionally to the control center; there is no operational requirement for the control center to send data back to the sensor, making duplex redundant.

Award marks as follows (Max 4.5 marks):
- 1 mark: Serial transmission prevents data skew (bits arriving out of synchronization) over long distances (2 km).
- 1 mark: Serial transmission is significantly cheaper / easier to install over long distances because it uses a single physical channel / fewer wires.
- 1 mark: Simplex data transmission allows data to flow in one direction only, which matches the requirements of sensors sending data to a central controller.
- 1 mark: Parallel transmission would be highly susceptible to crosstalk / skewing over 2 km and require expensive cabling.
- 0.5 mark: Duplex transmission is unnecessary because bidirectional communication is not required for passive sensor logging.

The automated system begins with the soil moisture sensors taking physical readings. These analog readings are converted to digital signals using an Analog-to-Digital Converter (ADC). The digital data is sent to the microprocessor, which continuously compares the incoming values against pre-stored optimal values. If the moisture is too low, the microprocessor outputs a control signal to an actuator (such as a motor or solenoid valve) to turn on the water. The system continuously samples and compares values, turning off the actuator once the moisture returns to the safe range.

Award marks as follows (Max 4.5 marks):
- 1 mark: Sensors continuously measure physical soil moisture levels and send analog signals.
- 1 mark: Analog signals are converted to digital signals using an ADC (Analog-to-Digital Converter) so the microprocessor can read them.
- 1 mark: The microprocessor compares the digital inputs against pre-set / target thresholds stored in its memory.
- 1 mark: The microprocessor sends a command to an actuator (e.g., motor or valve) to open/close based on the comparison results.
- 0.5 mark: Explicitly states that this process is executed in a continuous, endless loop.

The domain name typed by the user is sent by the browser to a local DNS server. The DNS server acts as an address book, mapping human-readable domain names to computer-friendly IP addresses. It searches its database; if it finds the IP address matching the domain, it returns it to the browser. If it is not found, the query is passed up to authoritative DNS servers. Once the browser receives the numerical IP address, it sends an HTTP/HTTPS request directly to the server at that IP address to fetch the webpage resources.

Award marks as follows (Max 4.5 marks):
- 1 mark: The browser queries the DNS server with the domain name / URL entered by the user.
- 1 mark: The DNS server looks up the domain name in its database to find its matching IP address.
- 1 mark: The DNS server returns the numerical IP address to the user's web browser.
- 1 mark: The browser uses this IP address to establish communication and request webpage files directly from the hosting web server.
- 0.5 mark: Note that if the local DNS server does not have the record, it queries other / recursive / authoritative DNS servers to resolve it.

A firewall sits between the company's internal LAN and the external Internet. It monitors all data packets entering and leaving the network. By comparing these packets against pre-configured security criteria (rules), the firewall decides whether to allow them through or block them. For instance, it can block incoming traffic from unrecognized IP addresses, prevent access to malicious websites, or block unauthorized protocols on specific ports. It also keeps logs of network activities to help identify intrusion attempts.

Award marks as follows (Max 4.5 marks):
- 1 mark: Monitors / filters both incoming and outgoing network traffic.
- 1 mark: Uses a list of pre-defined security rules / criteria to permit or block data packets.
- 1 mark: Blocks unauthorized external access attempts, hackers, or suspicious data packets from entering the LAN.
- 1 mark: Can restrict access to specific protocols, ports, IP addresses, or domain names.
- 0.5 mark: Keeps log files of traffic / flags unusual traffic spikes to alert the network administrator of potential attacks.

SSDs are far superior for portable laptops due to their physical and operational architecture. First, SSDs contain no moving parts (unlike the spinning platters and read/write heads of HDDs), making them highly durable and resistant to physical damage when the laptop is bumped or dropped during travel. Second, because they use microchips instead of electric motors, they require significantly less power, extending the laptop's battery run-time. Third, SSD chips are much smaller and lighter than mechanical drives, allowing manufacturers to create lighter, more compact laptops.

Award marks as follows (Max 4.5 marks):
- Up to 1.5 marks (0.5 marks each) for identifying three distinct features of SSDs:
- Feature 1: No moving parts.
- Feature 2: Lower power consumption.
- Feature 3: Lighter weight / smaller physical size (compactness).
- (Accept: Faster read/write startup speeds as an operational feature).
- Up to 3 marks (1 mark each) for linking each identified feature to its specific benefit for a portable laptop:
- Explanation 1: No moving parts means it is shock-resistant and won't fail if the laptop is dropped or shaken during travel.
- Explanation 2: Lower power consumption increases battery life, allowing the laptop to be used longer without a power source.
- Explanation 3: Being lighter and smaller makes the laptop more portable, thinner, and easier to carry.
- Explanation 4 (Alternative): Faster read/write speed means the system boots up and loads programs much quicker on the go.

Part (a):
1. Identify the formula for audio file size:
File Size (bits) = Sample Rate × Sample Resolution × Duration × Number of Channels
2. Substitute the given values into the formula:
File Size = 12,000 Hz × 16 bits × 40 seconds × 1 channel
3. Perform the calculation:
12,000 × 16 = 192,000
192,000 × 40 = 7,680,000 bits
4. Convert bits to bytes (divide by 8):
7,680,000 / 8 = 960,000 bytes
(Alternative: 16 bits = 2 bytes, so 12,000 × 2 × 40 = 960,000 bytes)
5. Convert bytes to Kilobytes (divide by 1,000 as specified):
960,000 / 1,000 = 960 KB

Part (b):
- "Uses lossy compression to reduce file size": MP3 uses lossy compression (perceptual coding).
- "Stores individual instrumental notes and commands...": MIDI contains performance data (pitch, volume, tempo) rather than actual audio recordings.
- "Contains raw, uncompressed audio data": WAV typically stores raw, uncompressed PCM audio.
- "Files are typically the largest...": WAV is uncompressed and therefore much larger than MIDI or MP3.
- "Does not contain any vocal tracks...": MIDI only stores synthesizer and control commands; it cannot record vocals natively.

Part (a) [3 Marks]:
- 1 mark for showing correct formula setup: 12,000 × 16 × 40 (or 12,000 × 2 × 40).
- 1 mark for correct intermediate calculation (e.g., 7,680,000 bits or 960,000 bytes).
- 1 mark for correct final answer with units: 960 KB.

Part (b) [5 Marks]:
- 1 mark for ticking 'MP3' for row 1.
- 1 mark for ticking 'MIDI' for row 2.
- 1 mark for ticking 'WAV' for row 3.
- 1 mark for ticking 'WAV' for row 4.
- 1 mark for ticking 'MIDI' for row 5.

Part (a):
1. Perform binary addition:
Carries: 1 1 1 1 1 0 0
0 1 0 1 1 1 0 0 (92 in denary)
+ 0 0 1 0 1 0 1 1 (43 in denary)
-----------------
1 0 0 0 0 1 1 1 (135 in denary)
2. Convert 10000111 to Hexadecimal by splitting into two 4-bit nibbles:
- Left nibble: 1000 = 8
- Right nibble: 0111 = 7
- Hexadecimal result = 87

Part (b):
- For Denary 83:
- Convert to Binary: 64 + 16 + 2 + 1 = 83, which is 01010011 (i).
- Convert to Hexadecimal: Split 01010011 into 0101 (5) and 0011 (3), which is 53 (ii).
- For Binary 10011100:
- Convert to Denary: 128 + 16 + 8 + 4 = 156 (iii).
- Convert to Hexadecimal: Split 10011100 into 1001 (9) and 1100 (12, which is C), which is 9C (iv).

Part (a) [4 Marks]:
- 1 mark for showing correct binary carry operations during addition.
- 1 mark for correct binary addition result: 10000111.
- 1 mark for showing method of splitting binary sum into nibbles to convert to hex.
- 1 mark for correct final hexadecimal answer: 87 (or 0x87).

Part (b) [4 Marks]:
- 1 mark for correct binary value (i): 01010011.
- 1 mark for correct hexadecimal value (ii): 53.
- 1 mark for correct denary value (iii): 156.
- 1 mark for correct hexadecimal value (iv): 9C.

Step-by-step trace of the pseudocode execution:
1. Initial state: Count = 1, MaxRun = 1.
2. i = 2: Numbers[2] (4) equals Numbers[1] (4). Condition is TRUE. Count increments to 2.
3. i = 3: Numbers[3] (7) does not equal Numbers[2] (4). Condition is FALSE. Count (2) > MaxRun (1) is TRUE, so MaxRun becomes 2. Count resets to 1.
4. i = 4: Numbers[4] (7) equals Numbers[3] (7). Condition is TRUE. Count increments to 2.
5. i = 5: Numbers[5] (7) equals Numbers[4] (7). Condition is TRUE. Count increments to 3.
6. i = 6: Numbers[6] (2) does not equal Numbers[5] (7). Condition is FALSE. Count (3) > MaxRun (2) is TRUE, so MaxRun becomes 3. Count resets to 1.
7. Post-loop: Count (1) > MaxRun (3) is FALSE. Output is MaxRun, which is 3.

Award 1 mark for each of the following (up to 5 marks total):
- 1 mark: Correct values of loop variable 'i' (sequentially tracking 2, 3, 4, 5, 6).
- 1 mark: Correct intermediate values of 'Count' (2, then 1, then 2, then 3, then 1).
- 1 mark: Correct update of 'MaxRun' to 2 when i = 3.
- 1 mark: Correct update of 'MaxRun' to 3 when i = 6.
- 1 mark: Correct final output value of 3.

Detailed step-by-step tracing of the loop execution:
1. Initial values: Num = 384, Reverse = 0, EvenCount = 0.
2. Loop Iteration 1 (Num > 0 is true):
  - Digit = 384 MOD 10 = 4.
  - Reverse = (0 * 10) + 4 = 4.
  - Digit MOD 2 = 0 is true, so EvenCount = 1.
  - Num = 384 DIV 10 = 38.
3. Loop Iteration 2 (Num > 0 is true):
  - Digit = 38 MOD 10 = 8.
  - Reverse = (4 * 10) + 8 = 48.
  - Digit MOD 2 = 0 is true, so EvenCount = 2.
  - Num = 38 DIV 10 = 3.
4. Loop Iteration 3 (Num > 0 is true):
  - Digit = 3 MOD 10 = 3.
  - Reverse = (48 * 10) + 3 = 483.
  - Digit MOD 2 = 0 is false, so EvenCount remains 2.
  - Num = 3 DIV 10 = 0.
5. Loop Terminated (Num > 0 is false).
6. Output: 483, 2.

Award marks as follows (total 5 marks):
- 1 mark: Correct trace of 'Digit' values (4, 8, 3 in correct sequence).
- 1 mark: Correct updates of 'Reverse' column (4, 48, 483).
- 1 mark: Correct updates of 'EvenCount' (1, 2).
- 1 mark: Correct sequence of 'Num' division updates (38, 3, 0).
- 1 mark: Correct final output displayed as '483, 2'.

Let us evaluate the output for each gate step-by-step:
- P = A AND (NOT B):
  - P is 1 only when A = 1 and B = 0. This occurs in rows 5 and 6.
  - For all other rows, P = 0.
- Q = B XOR C:
  - Q is 1 when B and C have different logic states (one is 1, the other is 0).
  - This occurs in rows 2, 3, 6, and 7. For other rows, Q = 0.
- X = P OR Q:
  - X is 1 if either P = 1, Q = 1, or both are 1.
  - Row 1: 0 OR 0 = 0
  - Row 2: 0 OR 1 = 1
  - Row 3: 0 OR 1 = 1
  - Row 4: 0 OR 0 = 0
  - Row 5: 1 OR 0 = 1
  - Row 6: 1 OR 1 = 1
  - Row 7: 0 OR 1 = 1
  - Row 8: 0 OR 0 = 0

Award marks as follows (total 5 marks):
- 1 mark: Correct P column values (0, 0, 0, 0, 1, 1, 0, 0).
- 2 marks: Correct Q column values (0, 1, 1, 0, 0, 1, 1, 0). Deduct 1 mark if 1 or 2 errors are made; 0 marks for 3 or more errors.
- 2 marks: Correct X column values (0, 1, 1, 0, 1, 1, 1, 0). Deduct 1 mark if 1 or 2 errors are made. Allow follow-through logic based on candidate's P and Q columns.

(a)
```sql
SELECT CommonName, Price, InStock
FROM PLANTS
WHERE (Category = 'Shrub' OR Category = 'Tree')
AND Price < 20.00
AND Evergreen = TRUE;
```
(Note: Accepting syntax variations like `Evergreen = True` or omitting `TRUE` as `Evergreen` is a boolean, and variations of quotes around text values like "Shrub").

(b)
- A primary key uniquely identifies each record in the table.
- Each plant variety will have a distinct `PlantID` (no two rows can have the same ID), ensuring no duplication of records.

(a) [4 marks]
- 1 mark: Correct `SELECT` clause listing only `CommonName`, `Price`, and `InStock` separated by commas.
- 1 mark: Correct `FROM PLANTS` clause.
- 1 mark: Correct boolean logic for category: `(Category = 'Shrub' OR Category = 'Tree')` (must include parentheses or logically equivalent construct to ensure correct precedence).
- 1 mark: Correct comparison logic for price and evergreen: `Price < 20.00 AND Evergreen = TRUE` (or `Evergreen = True` or `Evergreen`). All conditions must be correctly joined by AND.

(b) [2 marks]
- 1 mark: State that a primary key must uniquely identify each record (row) in the table.
- 1 mark: Explain that each plant will have its own unique `PlantID` (preventing duplicates / guaranteeing uniqueness).

(a)
- `FlightNumber`: Text / Alphanumeric / String (It contains both letters and numbers, so arithmetic is not performed on it).
- `Capacity`: Integer / Whole Number (A whole number representing count of passengers).
- `Delayed`: Boolean / Yes/No (A binary state indicating whether the flight is delayed or not).

(b)
```sql
SELECT FlightNumber, Destination
FROM FLIGHTS
WHERE Capacity > 150 AND Delayed = TRUE;
```
(Note: `Delayed = True` or simply `Delayed` are acceptable variations).

(a) [3 marks]
- 1 mark: Text / Alphanumeric / String for `FlightNumber`
- 1 mark: Integer / Whole Number for `Capacity`
- 1 mark: Boolean / Yes/No / Logical for `Delayed`

(b) [3 marks]
- 1 mark: Correct `SELECT FlightNumber, Destination FROM FLIGHTS`
- 1 mark: Correct criteria for capacity: `Capacity > 150`
- 1 mark: Correct criteria for delay: `AND Delayed = TRUE` (or `AND Delayed` or `AND Delayed = Yes` depending on database context)

(a) Three of the following errors should be identified:
- Error 1: The `SELECT` list unnecessarily includes `ClassCode` (the specification only asked to display `FirstName`, `LastName`, and `Score`).
- Error 2: `ClassCode IS CS101` uses `IS` instead of `=` and/or is missing quotes around the string literal `'CS101'`.
- Error 3: `Score >= 80` is incorrect because the requirement is "scored more than 80" (should be `Score > 80`).
- Error 4: `ORDER BY Score ASC` sorts the scores in ascending order, but they should be sorted from highest to lowest (which requires `ORDER BY Score DESC`).

(b)
```sql
SELECT FirstName, LastName, Score
FROM STUDENTS
WHERE ClassCode = 'CS101' AND Score > 80
ORDER BY Score DESC;
```

(a) [3 marks]
- 1 mark for each valid error identified (up to 3 max):
- Identified that `ClassCode` should not be selected / in the `SELECT` clause.
- Identified that `ClassCode IS CS101` needs `=` instead of `IS` OR identified that `'CS101'` must be enclosed in single/double quotes.
- Identified that `>= 80` should be `> 80` (strictly greater than).
- Identified that `ORDER BY Score ASC` should be `DESC` (for descending/highest to lowest order).

(b) [3 marks]
- 1 mark: Correct `SELECT FirstName, LastName, Score FROM STUDENTS` (no ClassCode in select list).
- 1 mark: Correct WHERE clause condition: `WHERE ClassCode = 'CS101' AND Score > 80` (allow double quotes around "CS101").
- 1 mark: Correct ordering: `ORDER BY Score DESC` (or `ORDER BY Score DESCENDING`).

The solution involves writing a fully structured pseudocode algorithm. It is split into three main parts:
1. Array Initialization: Using a FOR loop running from 1 to 30 to assign sequential values to DroneID, 'Idle' to DroneStatus, and 0 to TotalDeliveries.
2. Iterative Process Control: A REPEAT-UNTIL or WHILE loop controlled by checking if user input is not -1. Inside this, nested IF statements validate user actions (Dispatch vs. Return), range-check input IDs (1 to 30), verify current drone states before changing them, update appropriate arrays, and produce clean error messages.
3. Summary Calculations: A sequential loop through the arrays to sum instances of 'Active' statuses, and a standard linear search algorithm initialized with the first elements to find the index containing the highest value in the TotalDeliveries array. The outputs are presented clearly.

Award marks based on the following criteria (Max 15 marks):

- Array Initialization (2 marks):
* 1 mark: Using a FOR loop from 1 to 30 to initialize arrays.
* 1 mark: Initializing all three arrays with correct corresponding types (DroneID = Index, DroneStatus = "Idle", TotalDeliveries = 0).

- Loop Structure (2 marks):
* 1 mark: An outer loop (REPEAT/UNTIL or WHILE) that correctly repeats until -1 is input.
* 1 mark: Prompting and taking inputs within the loop correctly.

- Selection Logic & Validation (5 marks):
* 1 mark: Correct conditions separating Choice 1, Choice 2, and others.
* 1 mark: Checking that entered Drone ID is within boundary limits (1 to 30 inclusive).
* 1 mark: Validating drone is "Idle" before Dispatch and "Active" before Return.
* 1 mark: Setting drone status correctly to "Active" (Dispatch) or "Idle" (Return).
* 1 mark: Correctly outputting appropriate error messages when validation checks fail.

- Delivery Incrementation (1 mark):
* 1 mark: Incrementing TotalDeliveries array count by 1 for the correct drone ID upon successful return.

- Final Calculations & Outputs (5 marks):
* 1 mark: Initializing and correctly counting currently "Active" drones using a loop.
* 1 mark: Outputting the total active drone count outside the main loop.
* 1 mark: Correct algorithm to search for the highest delivery count (initializing max with first element and looping remaining elements).
* 1 mark: Correctly storing and locating the matching Drone ID with the highest delivery count.
* 1 mark: Outputting both the drone ID and its delivery count clearly.