2024 Cambridge IGCSE Computer Science (0478) 模拟试题及答案详解

The Program Counter is a CPU register in the Control Unit. Its primary role is to hold the memory address of the next instruction that needs to be fetched from memory, decoded, and executed. Once the address is sent, the PC is incremented to point to the next instruction in sequence.

One mark for each point (max 2): - Stores/holds the memory address of an instruction (1 mark) - ...of the next instruction to be fetched / decoded / executed (1 mark)

Unlike symmetric encryption which uses a single shared key, asymmetric encryption utilizes a key pair: a public key (which can be shared with anyone) and a private key (which is kept secret by the recipient). Data encrypted with the public key can only be decrypted with the corresponding private key.

One mark for each point (max 2): - Uses two different keys / a public key and a private key (1 mark) - Keys are mathematically related / one key is used for encryption and the other is used for decryption (1 mark)

In half-duplex transmission, communication is bi-directional, but the devices must take turns sending data (such as a walkie-talkie). In full-duplex transmission, communication is bi-directional and can happen at the same time (such as a telephone call).

One mark for each point (max 2): - Half-duplex: data is transmitted in both directions, but only one direction at a time / not simultaneously (1 mark) - Full-duplex: data is transmitted in both directions simultaneously / at the same time (1 mark)

An interrupt is a mechanism used to alert the processor that an external event or software process requires immediate attention. When the processor receives an interrupt signal, it suspends its current operations, saves its state, and executes an interrupt service routine (ISR) to handle the event before resuming its previous tasks.

One mark for each point (max 2): - A signal sent to the processor/CPU from a device/hardware or software program (1 mark) - Causes the processor to temporarily suspend its current task/instructions to service the interrupt (1 mark)

Pharming attacks do not rely on tricking the user into clicking a link (unlike phishing). Instead, malicious code is installed on the user's computer or a DNS server is poisoned, redirecting legitimate traffic to a fraudulent website that mimics the real one to harvest credentials or personal details.

One mark for each point (max 2): - Malicious code is installed on a user's computer/web server OR DNS server is poisoned/compromised (1 mark) - Redirects the user to a fake/malicious website without their consent/even if they typed the correct URL (1 mark)

Lossless compression reduces file size by identifying and eliminating redundancy rather than discarding information. Algorithms like Run-Length Encoding (RLE) are used. This type of compression is critical for files where any loss of information could make them unusable, such as text files, executable code, or medical images.

One mark for each point (max 2): - A method of reducing file size where no data/information is lost/discarded (1 mark) - The original file can be reconstructed exactly as it was / is identical to the original (1 mark)

1. Convert bits to bytes:
16 bits = 2 bytes.

2. Calculate total bytes:
File size = sample rate × sample resolution (in bytes) × duration × number of channels
File size = 8000 × 2 bytes × 32 seconds × 2 channels
File size = 1,024,000 bytes.

3. Convert bytes to KiB:
1,024,000 / 1024 = 1000 KiB.

1 mark for showing correct formula/substitution of values (8000 × 16 × 32 × 2).
1 mark for converting bits to bytes (dividing by 8) OR showing the correct intermediate total in bytes (1,024,000 bytes).
1 mark for dividing the byte total by 1024 to convert to KiB.
1 mark for the correct final answer of 1000 (KiB).

Binary Addition:
01011100
+ 00101010
----------
10000110

An overflow error has occurred because:
1. The maximum value that can be represented by an 8-bit signed two's complement integer is +127. Adding 92 (Integer A) and 42 (Integer B) equals 134, which exceeds this limit.
2. Adding two positive numbers (MSB of 0) has resulted in a negative number (MSB of 1).

1 mark for showing correct binary addition working (including carries).
1 mark for correct binary sum: 10000110.
1 mark for identifying that the sum (134 in denary) exceeds the maximum limit of +127 for an 8-bit signed representation.
1 mark for explaining that adding two positive numbers has incorrectly changed the sign bit / resulted in a negative number (MSB is 1).

1. Original size:
There are 20 characters, which equals 20 bytes.

2. Compressed size:
There are 4 distinct runs (5 A's, 3 B's, 4 C's, and 8 D's).
Each compressed run requires 2 bytes (1 byte for count, 1 byte for value).
Compressed size = 4 runs × 2 bytes = 8 bytes.

3. Reduction:
Size reduced = 20 bytes - 8 bytes = 12 bytes.

4. Percentage reduction:
(12 / 20) × 100 = 60%.

1 mark for identifying the correct original size of 20 bytes.
1 mark for calculating the correct compressed size of 8 bytes.
1 mark for calculating the savings difference in bytes (12 bytes).
1 mark for calculating the correct final percentage reduction of 60%.

1. The firewall intercepts the incoming data packet at the network boundary.
2. It reads the packet header to extract metadata such as the source IP address, destination IP address, port number, and protocol type.
3. It compares this extracted data against its configured database of security rules (Access Control List).
4. If the packet characteristics match an 'allow' rule, the packet is forwarded to the destination computer within the local network.
5. If the packet violates the rules or matches a 'deny' rule, the firewall blocks or drops the packet, and may log the security event.

Award 1 mark for each correct step described (maximum of 5 marks):
- Intercepting the incoming data packet at the network gateway.
- Extracting packet header information (accept examples such as source/destination IP, port number, protocol).
- Comparing packet header details against a predefined set of security rules / Access Control List (ACL).
- Permitting the packet to enter the network if it satisfies the security criteria.
- Blocking/dropping the packet if it violates the criteria, and optionally logging/alerting the administrator.

1. At the end of each instruction cycle, the CPU checks for any active interrupt signals.
2. If an interrupt is present, the CPU temporarily halts the execution of the current program.
3. The current contents of CPU registers, including the Program Counter (PC), are saved securely onto a memory stack.
4. The CPU loads the address of the corresponding Interrupt Service Routine (ISR) from an interrupt vector table into the Program Counter.
5. The CPU executes the ISR to handle the interrupt, and once complete, pops the saved register values back off the stack to resume the interrupted program from where it left off.

Award 1 mark for each correct step described (maximum of 5 marks):
- Checking for interrupts at the end of the current instruction cycle.
- Pausing/halting the execution of the active program.
- Saving the current processor state / register values (e.g. Program Counter) to a memory stack.
- Loading and executing the appropriate Interrupt Service Routine (ISR) / interrupt handler.
- Retrieving the saved state from the stack and resuming the original program at the next instruction.

1. Prior to transmission, the sender inputs the file data into a checksum generator algorithm.
2. The algorithm calculates a unique numeric value (the checksum) representing the data block.
3. This calculated checksum is appended to the payload of the data block and transmitted across the network.
4. Once received, the destination device inputs the received file payload into the exact same algorithm to produce a recalculated checksum.
5. The receiver compares the transmitted checksum value with its newly recalculated checksum; if they are identical, the file is verified as error-free; if they differ, the file is rejected and a retransmission is requested.

Award 1 mark for each correct step described (maximum of 5 marks):
- Sender applying a checksum algorithm to the data block prior to transmission.
- Appending the calculated checksum value to the data block payload.
- Transmitting both the data block and the checksum to the destination.
- Receiver executing the same mathematical algorithm on the received data payload to generate a recalculated checksum.
- Comparing the transmitted and recalculated checksums to detect errors (accepting if they match, flagging an error / requesting retransmission if they do not match).

(1) signal: An interrupt is a signal sent to the processor.
(2) CPU: The target that receives the interrupt request is the CPU.
(3) registers: Register values (such as the Program Counter and Accumulator) must be saved to preserve the state.
(4) interrupt service routine (ISR): This is the dedicated handler code executed for the specific interrupt.
(5) printer: A printer running out of paper is a classic hardware interrupt scenario.
(6) program: The CPU restores the saved register states and resumes the interrupted program.

One mark for each correct term in the correct position:
- (1) signal
- (2) CPU
- (3) registers
- (4) interrupt service routine (ISR)
- (5) printer
- (6) program // task

- Row 1 describes Pharming because it involves redirecting web traffic to a DNS-spoofed fake site.
- Row 2 describes a Brute-force attack as it involves trying all potential password combinations.
- Row 3 describes Phishing, which relies on deceptive emails.
- Row 4 describes Ransomware, which restricts access to files via encryption and demands payment.
- Row 5 describes a Trojan horse, which masquerades as legitimate software.
- Row 6 describes Spyware (such as keyloggers) which monitors and records user activity.

One mark for each correct threat identified:
- Row 1: Pharming
- Row 2: Brute-force attack // Brute-force
- Row 3: Phishing
- Row 4: Ransomware
- Row 5: Trojan horse // Trojan
- Row 6: Spyware

1. Symbol P is an OR gate followed by an inverter (indicated by the bubble at the output), which represents a NOR gate.
2. Symbol Q is an AND gate followed by an inverter (indicated by the bubble at the output), which represents a NAND gate.
3. Symbol R is an OR gate with an additional curved input line, which represents an Exclusive OR (XOR) gate.

Award 1 mark for each correct identification up to a maximum of 3 marks:
- NOR (1 mark)
- NAND (1 mark)
- XOR / Exclusive OR (1 mark)

1. Table X describes a NOR gate because its output is 1 only when all inputs are 0.
2. Table Y describes a NAND gate because its output is 0 only when both inputs are 1 (the inverse of an AND gate).
3. Table Z describes an XOR gate because its output is 1 only when the inputs are different (one is 1 and the other is 0).

Award 1 mark for each correct identification up to a maximum of 3 marks:
- Table X: NOR (1 mark)
- Table Y: NAND (1 mark)
- Table Z: XOR (1 mark)

1. Specification 1 describes the Exclusive OR (XOR) gate where output is high if the inputs are different.
2. Specification 2 describes the NOR gate where output is 1 only when both inputs are 0.
3. Specification 3 describes the NAND gate where the result of the AND logic is inverted.

Award 1 mark for each correct identification up to a maximum of 3 marks:
- Specification 1: XOR / Exclusive OR (1 mark)
- Specification 2: NOR (1 mark)
- Specification 3: NAND (1 mark)

Errors and Corrections:
1. Line 01: 'Min <- 0' should be 'Min <- Scores[1]' (or a very large number like 99999).
2. Line 03: 'IF Scores[Counter] > Min' should be 'IF Scores[Counter] < Min'.
3. Line 07: 'NEXT Min' should be 'NEXT Counter'.

Explanation:
Since all elements in the array are positive integers (greater than 0), the comparison 'Scores[Counter] < Min' (once corrected) will always evaluate to False if Min is initialized to 0. Consequently, Min will remain 0, which is incorrect as 0 is not a value in the array.

One mark for each correct error identification and correction (max 3 marks):
- Line 01: Change Min <- 0 to Min <- Scores[1]
- Line 03: Change Scores[Counter] > Min to Scores[Counter] < Min
- Line 07: Change NEXT Min to NEXT Counter

Two marks for explanation:
- Explaining that positive numbers will always be greater than 0, meaning the 'less than' condition is never met (1 mark).
- Concluding that Min will incorrectly remain 0 at the end of the execution (1 mark).

OUTPUT "Enter age:"
INPUT Age
WHILE Age < 11 OR Age > 18
OUTPUT "Invalid age. Please enter an age between 11 and 18:"
INPUT Age
ENDWHILE
OUTPUT "Age accepted"

(Alternative using REPEAT...UNTIL):
REPEAT
OUTPUT "Enter age:"
INPUT Age
IF Age < 11 OR Age > 18
THEN
OUTPUT "Invalid age."
ENDIF
UNTIL Age >= 11 AND Age <= 18
OUTPUT "Age accepted"

One mark for each point (max 5 marks):
- MP1: Initializing variable and setting up a conditional loop (WHILE or REPEAT...UNTIL).
- MP2: Prompting and getting input for age inside the loop.
- MP3: Correct validation condition checking range (e.g. Age < 11 OR Age > 18 for loop entry, or Age >= 11 AND Age <= 18 for loop exit).
- MP4: Outputting an appropriate error message inside the loop when input is invalid.
- MP5: Outputting 'Age accepted' only after exiting the validation loop.

Total <- 0
DryDays <- 0
FOR Day <- 1 TO 30
Total <- Total + Rainfall[Day]
IF Rainfall[Day] = 0
THEN
DryDays <- DryDays + 1
ENDIF
NEXT Day
OUTPUT "Total rainfall for the month is: ", Total
OUTPUT "Number of days with zero rainfall: ", DryDays

One mark for each point (max 5 marks):
- MP1: Initialise total and dry day counters to 0 before the loop.
- MP2: Set up a loop to iterate through all 30 elements of the array (e.g., FOR Day <- 1 TO 30).
- MP3: Accumulate the total rainfall inside the loop (Total <- Total + Rainfall[Day]).
- MP4: Check if rainfall is 0 and increment the dry days counter inside the loop.
- MP5: Output both the total rainfall and the number of dry days after the loop ends.

Errors and Corrections:
1. Line 01: 'Index <- 0' should be 'Index <- 1' (as the array index starts at 1).
2. Line 03: 'Found = FALSE OR Index < 100' should be 'Found = FALSE AND Index <= 100' (to prevent out-of-bounds and stop when found).
3. Line 10: 'NEXT Index' should be 'ENDWHILE' (closing the while loop).

Explanation of the OR error:
If the logical operator 'OR' is used, the loop condition remains True even if one sub-condition becomes False. If the item is found, 'Found' becomes True, but the loop continues because 'Index < 100' is still True. Alternatively, if the item is not found, when Index reaches 101, 'Index < 100' becomes False, but the loop continues because 'Found = FALSE' is still True, causing an 'index out of bounds' error.

One mark for each correct error identification and correction (max 3 marks):
- Line 01: Change Index <- 0 to Index <- 1
- Line 03: Change OR to AND (accept changing < 100 to <= 100 as part of this or as an alternate correct mark)
- Line 10: Change NEXT Index to ENDWHILE

Two marks for explanation of the 'OR' error:
- Explaining that 'OR' means the loop continues even after the target is found (1 mark).
- Explaining that 'OR' leads to an out-of-bounds array index error when the name is not in the list (1 mark).

(a) The field `BookID` is the most appropriate primary key because it contains unique values that uniquely identify each record (book) in the database.

(b) Suitable data types:
* `BookID`: Text/Alphanumeric because it contains letters and numbers (e.g., 'BK904').
* `YearPublished`: Integer because calendar years are whole numbers (e.g., 2018).
* `Available`: Boolean since it only requires two states: yes (True) or no (False).
* `Price`: Real/Decimal/Currency because it contains fractional values representing money (e.g., 14.99).

(c) Explanations of SQL Queries:
* **Query 1**: Finds the average value of the `Price` field across all book records.
* **Query 2**: Finds the total count of books where the `Available` status is FALSE (representing books currently checked out/unavailable).

(a)
* 1 mark for identifying `BookID`.

(b)
* 2 marks for all four correct data types.
* 1 mark if two or three are correct.
* 0 marks if fewer than two are correct.

(c)
* 1 mark for Query 1: correct identification of finding the average replacement cost/price of books.
* 2 marks for Query 2:
* 1 mark for identifying that it counts the records/number of books.
* 1 mark for identifying the condition (where they are unavailable / Available is false).

(a) Step-by-step trace process:
* `Counter ← 1`, `Total ← 0`, `Limit ← 4` are initialized.
* **Iteration 1**: `Value` = 12. Since 12 > 10, `Total` becomes 0 + 12 = 12. `Counter` is incremented to 2. Condition `Counter > Limit` (2 > 4) is FALSE.
* **Iteration 2**: `Value` = 5. Since 5 is not > 10, `Total` becomes 12 - 5 = 7. `Counter` is incremented to 3. Condition `Counter > Limit` (3 > 4) is FALSE.
* **Iteration 3**: `Value` = 15. Since 15 > 10, `Total` becomes 7 + 15 = 22. `Counter` is incremented to 4. Condition `Counter > Limit` (4 > 4) is FALSE.
* **Iteration 4**: `Value` = 8. Since 8 is not > 10, `Total` becomes 22 - 8 = 14. `Counter` is incremented to 5. Condition `Counter > Limit` (5 > 4) is TRUE, so the loop terminates.
* `Total` (14) is output.

(b) The algorithm iterates 4 times, taking a user input on each loop. If the input is greater than 10, it adds it to a running sum; if it is 10 or less, it subtracts it from that sum. It outputs the final cumulative total.

(a) Trace Table Marks [Max 4]:
* 1 mark for initialization: Counter = 1, Total = 0, Limit = 4 correctly logged.
* 1 mark for logging all values of `Value` in correct sequential rows (12, 5, 15, 8).
* 1 mark for calculating correct updates to `Total` at each step (12, 7, 22, 14).
* 1 mark for correct increment of `Counter` up to 5 and the correct final output value (14).

(b) Description Marks [Max 2]:
* 1 mark for identifying that it processes/inputs exactly 4 numbers.
* 1 mark for stating that numbers greater than 10 are added to a running sum, and numbers 10 or less are subtracted (and the total is output).

Below is an example solution written in pseudocode:

```text
// Set up warehouse grid
FOR Row <- 1 TO 6
FOR Column <- 1 TO 6
Warehouse[Row, Column] <- ""
NEXT Column
NEXT Row

// Generate random position for Package (P) avoiding start cell [1,1]
REPEAT
PRow <- ROUND((RANDOM() * 5) + 1, 0)
PCol <- ROUND((RANDOM() * 5) + 1, 0)
UNTIL PRow <> 1 OR PCol <> 1
Warehouse[PRow, PCol] <- "P"

// Generate random position for Obstacle (O) avoiding [1,1] and [PRow, PCol]
REPEAT
ORow <- ROUND((RANDOM() * 5) + 1, 0)
OCol <- ROUND((RANDOM() * 5) + 1, 0)
UNTIL (ORow <> 1 OR OCol <> 1) AND (ORow <> PRow OR OCol <> PCol)
Warehouse[ORow, OCol] <- "O"

// Initialize drone starting variables
DroneRow <- 1
DroneCol <- 1
Energy <- 8
Success <- FALSE

// Game loop
WHILE Energy > 0 AND NOT Success
OUTPUT "Current position: Row ", DroneRow, ", Column ", DroneCol
OUTPUT "Energy remaining: ", Energy
OUTPUT "Enter move (N = North, S = South, E = East, W = West): "
INPUT Move

MoveValid <- FALSE
TempRow <- DroneRow
TempCol <- DroneCol

// Process move inputs
IF Move = "N" THEN
TempRow <- DroneRow - 1
MoveValid <- TRUE
ELSEIF Move = "S" THEN
TempRow <- DroneRow + 1
MoveValid <- TRUE
ELSEIF Move = "E" THEN
TempCol <- DroneCol + 1
MoveValid <- TRUE
ELSEIF Move = "W" THEN
TempCol <- DroneCol - 1
MoveValid <- TRUE
ELSE
OUTPUT "Invalid input! Enter N, S, E, or W."
ENDIF

IF MoveValid THEN
// Boundary check
IF TempRow >= 1 AND TempRow <= 6 AND TempCol >= 1 AND TempCol <= 6 THEN
// Update actual drone position and consume base energy
DroneRow <- TempRow
DroneCol <- TempCol
Energy <- Energy - 1

// Check if cell has an obstacle
IF Warehouse[DroneRow, DroneCol] = "O" THEN
OUTPUT "Warning! Hit an obstacle! Lost 2 extra energy points."
Energy <- Energy - 2
ENDIF

// Check if cell contains the package
IF Warehouse[DroneRow, DroneCol] = "P" THEN
OUTPUT "Delivery Successful!"
Success <- TRUE
ENDIF
ELSE
OUTPUT "Boundary error! Drone cannot leave the warehouse area."
ENDIF
ENDIF
ENDWHILE

// Check end-of-game outcome
IF NOT Success THEN
OUTPUT "Delivery Failed! Out of energy."
ENDIF
```

### AO2: Apply knowledge and understanding (Max 9 marks)
* **R1: Game Setup (Max 3 marks)**
* Clearing all elements of the 2D array appropriately.
* Generating unique random coordinates for 'P' (not in cell [1,1]).
* Generating unique random coordinates for 'O' (not in cell [1,1] and not equal to 'P' cell).
* **R2: Input & Validation (Max 3 marks)**
* Looping continuously until energy is depleted or game is won.
* Inputting directions (N, S, E, W) and mapping to temporary coordinates.
* Checking if the planned moves are within the index range of 1 to 6.
* **R3: Game Logic & Outcomes (Max 3 marks)**
* Deducting 1 point of energy for valid moves, and handling boundary warnings without deducting energy.
* Deducting an additional 2 energy points (total 3 points) if 'O' is encountered.
* Outputting the correct win/loss termination messages.

### AO3: Provide solutions (Max 6 marks)
* **Comments (Max 2 marks)**
* *2 marks*: Program has been fully commented with relevant descriptions.
* *1 mark*: Program has some relevant comments.
* **Identifiers & Logic Flow (Max 2 marks)**
* *2 marks*: Highly meaningful variable names used throughout; clear logical sequence.
* *1 mark*: Majority of identifiers are appropriately named; solution has some minor structural flaws.
* **Completeness & Accuracy (Max 2 marks)**
* *2 marks*: Solution matches all the program specifications accurately without design flaws.
* *1 mark*: Solution contains a few operational logical errors but covers most aspects of the simulation.