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

Hexadecimal representations are significantly shorter and more compact than equivalent binary representations, which makes them easier for programmers to read, write, and remember. Furthermore, because there are fewer characters to enter, programmers are far less likely to make typing/transcription errors.

Award 1 mark for each valid reason up to a maximum of 2 marks:
- Easier for programmers to read/write/remember
- Less prone to typing or transcription errors
- Easier to debug/spot patterns

Increasing the sample rate means more measurements of the analog sound wave are captured per second. This results in a more accurate digital representation of the sound (higher quality/fidelity). However, because more data points are recorded and stored, the file size of the sound file increases.

Award 1 mark for effect on sound quality:
- Sound reproduction is higher quality // more accurate to original analog wave // wider frequency range captured
Award 1 mark for effect on resources:
- File size of the recording increases // requires more storage space or transmission bandwidth

A programmer may choose assembly language to gain direct manipulation over CPU registers and system hardware. Additionally, low-level programs can be highly optimized to execute much faster and require less memory storage than programs written in high-level languages.

Award 1 mark for each valid reason up to a maximum of 2 marks:
- Allows direct control/manipulation of hardware/CPU registers/input-output ports
- Code can be optimized to execute more quickly
- Code requires less memory/storage space
- Can write code directly suited for embedded controllers/real-time systems

The Control Unit (CU) manages the components of the CPU during the Fetch-Decode-Execute cycle. Its functions include decoding the instructions fetched from memory to determine what operation to perform, and directing/coordinating the flow of control and data signals between the CPU components (such as the ALU and registers).

Award 1 mark for each distinct function up to a maximum of 2 marks:
- Decodes instructions (during the FDE cycle)
- Controls/directs the flow of data/signals within the CPU
- Coordinates and synchronizes instructions using the system clock
- Sends control signals to other registers/components (e.g., ALU, memory)

Before data is sent, the sender applies an algorithm to the block of data to calculate a numerical value known as a checksum, which is appended to the payload. Upon arrival, the receiver performs the same calculation on the incoming data. If the recalculated checksum matches the received checksum, the data is assumed to be error-free; if they differ, an error has occurred.

Award 1 mark for generation/sending phase:
- Checksum is calculated from the block of data using a formula/algorithm prior to transmission and sent alongside the data.
Award 1 mark for verification/comparison phase:
- The receiving computer recalculates the checksum and compares it with the sent checksum; a mismatch signals a transmission error has occurred.

A sensor acts as an input device that detects and measures physical properties or changes in the environment (such as light levels, temperature, or distance) and sends this data to the robotic controller. An actuator is an output device that converts electrical signals from the controller into physical movement or action (such as turning a wheel or closing a gripper).

Award 1 mark for correct description of a sensor:
- Sensor: Input device that measures or detects environmental physical variables and sends data/signals to the processor.
Award 1 mark for correct description of an actuator:
- Actuator: Output device that carries out mechanical actions, physical movements, or structural adjustments based on signals from the processor.

Phishing is a social engineering attack where a user is sent fraudulent messages (like emails) containing links designed to trick them into navigating to a fake website and entering credentials. Pharming is a malicious software or system attack where DNS server records or local host files are manipulated, causing the user to be automatically redirected to a fake website even when they type the correct URL in their browser.

Award 1 mark for phishing explanation:
- Phishing: Uses spam/deceptive emails or messages with fake links to trick users into giving away personal details.
Award 1 mark for pharming explanation:
- Pharming: Infects computers or DNS servers with malicious code to automatically redirect users to fake sites (independent of clicking an email link).

An interrupt is a signal generated by hardware or software sent to the CPU, requesting immediate attention. It allows the CPU to temporarily suspend its current execution cycle, save its progress, handle the urgent event (such as disk input/output or device errors) via an Interrupt Service Routine (ISR), and then resume the original task.

Award 1 mark for signal/halting aspect:
- A signal sent from hardware/software to suspend/interrupt the CPU's current execution cycle.
Award 1 mark for handling/multitasking aspect:
- Enables the system to respond efficiently to urgent/asynchronous events (using Interrupt Service Routines) and then return to original tasks.

First, convert the positive value 43 to 8-bit binary: 43 = 32 + 8 + 2 + 1, which is 00101011. Next, perform the one's complement by inverting all the bits to get 11010100. Finally, add 1 to the result to get the two's complement: 11010100 + 1 = 11010101.

1 mark for correct binary representation of positive 43 (00101011). 1 mark for showing correct method of working (e.g. inverting the bits or subtracting from 256). 1 mark for correct final 8-bit two's complement value (11010101).

Convert each individual hexadecimal digit into its 4-bit binary equivalent: C in hexadecimal is 12 in denary, which is 1100 in binary. 4 in hexadecimal is 4 in denary, which is 0100 in binary. B in hexadecimal is 11 in denary, which is 1011 in binary. Combining these yields: 110001001011.

1 mark for correct binary conversion of C (1100). 1 mark for correct binary conversion of 4 (0100). 1 mark for correct binary conversion of B (1011).

Align the values: 01101100 + 01010011. Working from right to left: 0+1=1, 0+1=1, 1+0=1, 1+0=1, 0+1=1, 1+0=1, 1+1=0 with carry 1, 0+0+1(carry)=1. The final combined binary string is 10111111.

1 mark for showing correct carry bits or demonstrating a valid addition method. 1 mark for correct right nibble (1111). 1 mark for correct left nibble (1011).

Substitute the inputs into the expression: X = (1 AND NOT 1) OR (1 XOR 0). Step 1: Evaluate the left term: NOT 1 = 0, so (1 AND 0) = 0. Step 2: Evaluate the right term: (1 XOR 0) = 1. Step 3: Combine the two terms using OR: 0 OR 1 = 1.

1 mark for evaluating the left term (A AND NOT B) as 0. 1 mark for evaluating the right term (B XOR C) as 1. 1 mark for the correct final value of X as 1.

Total pixels = 1024 * 512 = 524288 pixels. With a colour depth of 8 bits (which equals 1 byte) per pixel, the total file size in bytes is 524288 bytes. To convert bytes to kibibytes, divide by 1024: 524288 / 1024 = 512 KiB.

1 mark for calculating the total pixels or showing the correct multiplication formula. 1 mark for showing division by 1024 to convert bytes to KiB. 1 mark for correct final answer of 512.

Even parity means each byte must contain an even number of 1s. Let's count the number of 1s in each byte: Byte 1 (01101010) has four 1s (even, valid). Byte 2 (10011100) has five 1s (odd, invalid). Byte 3 (11100011) has six 1s (even, valid). Therefore, Byte 2 contains a transmission error.

1 mark for identifying Byte 2 contains the error. 1 mark for explaining that Byte 2 has an odd number of 1s (5 ones). 1 mark for stating that a valid byte must contain an even number of 1s because the system uses even parity.

Decreasing colour depth to 8 bits reduces the number of bits stored per pixel, lowering the overall file size. However, it severely limits the colour palette to 256 colours, resulting in colour banding and lower quality. Decreasing the resolution to 960 by 540 reduces the total number of pixels by 75% (to a quarter of the original count), which drastically reduces the file size. However, the image will lose fine details and look pixelated if displayed on high-resolution screens.

1 mark: Explaining that reducing colour depth to 8 bits reduces file size by reducing bits per pixel. 1 mark: Explaining the quality impact of 8-bit depth (reduction to 256 colours causing colour banding). 1 mark: Explaining that reducing resolution to 960x540 significantly reduces file size because the total pixel count drops by 75 percent. 1 mark: Explaining the quality impact of lower resolution (loss of fine details and pixelation when scaled up).

Solid State Drives (SSDs) use flash memory and have no moving parts, which provides faster read/write times and greater physical durability against shocks compared to Hard Disk Drives (HDDs). On the other hand, HDDs use magnetic platters and read/write heads, making them cheaper per gigabyte and offering longer write endurance, as SSD flash cells degrade over multiple write cycles.

1 mark per valid SSD advantage (max 2): faster read/write speeds, lower power consumption, silent operation, high physical durability. 1 mark per valid HDD advantage (max 2): lower cost per gigabyte, higher read/write cycle endurance, easier data recovery from damaged drives.

A compiler translates the entire source code into machine code all at once, creating an executable file before execution starts, whereas an interpreter translates and executes the source code line-by-line in real time. For debugging, a compiler produces a complete list of syntax errors only after attempting to compile the whole program, which can make debugging harder as the developer must look at multiple errors at once. Conversely, an interpreter stops execution the moment it encounters an error on a specific line, making it much easier to pinpoint and resolve runtime bugs dynamically.

1 mark: Explaining that a compiler translates the entire code at once while an interpreter translates and executes line-by-line. 1 mark: Explaining that a compiler produces an executable file whereas an interpreter runs the source code directly. 1 mark: Explaining that a compiler's error report is only produced at the end of translation, listing all syntax errors. 1 mark: Explaining that an interpreter stops execution immediately at an error, easing line-by-line debugging.

Symmetric encryption uses one single secret key that both the sender and receiver must possess to encrypt and decrypt the message. Asymmetric encryption uses a mathematically linked key pair: a public key (shared openly) to encrypt the message, and a private key (kept secret by the owner) to decrypt it. Asymmetric encryption is more secure for the internet because the private key never needs to be sent across the network, avoiding the risk of key interception that exists when exchanging a symmetric key.

1 mark: Explaining that symmetric encryption uses the same single key for encryption and decryption. 1 mark: Explaining that asymmetric encryption uses a public key to encrypt and a private key to decrypt. 1 mark: Identifying the risk of key exchange in symmetric encryption (intercepted key compromises everything). 1 mark: Explaining that asymmetric encryption resolves this because the decryption key (private key) is never transmitted.

A parity check allocates an extra bit (parity bit) to a byte of data before transmission to make the total count of 1s either even or odd. The receiving device counts the 1s to detect single-bit transmission errors. A check digit is calculated using an algorithm (such as Luhn's or modulo 11) on a numerical sequence and is appended to the data; it is recalculated upon data entry to verify its integrity. A key limitation of parity check is that it cannot detect transposition errors or an even number of swapped bits. A check digit resolves this because the algorithm applies unique positional weights, ensuring that swapped adjacent digits are flagged.

1 mark: Describing how parity checks work (adding a parity bit to make 1s count even or odd). 1 mark: Describing how check digits work (calculated on a sequence of digits using an algorithm and appended). 1 mark: Explaining the parity check limitation (cannot detect an even number of bit changes or transposition). 1 mark: Explaining how check digits resolve transposition errors due to weighted algorithms.

System software consists of files and programs that manage and control the computer's hardware and resources directly, ensuring the system operates efficiently. An example is the Operating System (e.g., macOS) or utility software (e.g., disk defragmenter). Application software consists of programs designed to allow the end-user to perform specific activities or tasks. Examples include Web Browsers (e.g., Chrome) and Word Processors (e.g., MS Word). The main difference in purpose is that system software works in the background to keep the hardware functioning, while application software acts as a productivity tool for the user's specific goals.

1 mark: Defining system software as programs managing the hardware and system performance. 1 mark: Providing a correct example of system software (OS, compilers, device drivers, utilities). 1 mark: Defining application software as programs designed for users to complete specific tasks. 1 mark: Providing a correct example of application software (word processor, web browser, spreadsheets).

The Memory Address Register (MAR) is used to store the address of the memory location (in RAM) currently being accessed for a read or write operation. The Memory Data Register (MDR) stores the actual data or instruction that is read from or about to be written to that address. During a read operation, the address of the required instruction is copied from the Program Counter to the MAR. The MAR sends this address along the address bus to memory, and the data stored at that address is sent back along the data bus, where it is stored in the MDR before being decoded.

1 mark: Describing MAR role (storing the memory address currently being read from or written to). 1 mark: Describing MDR role (storing the data or instruction fetched from RAM or waiting to be written). 1 mark: Explaining the read interaction (address in MAR is used to locate data, which is then copied into MDR). 1 mark: Specifying the use of buses in this interaction (address bus used by MAR, data bus used by MDR).

Sensors continuously measure environmental conditions (e.g., temperature, moisture) and convert these physical readings into electrical signals, which are converted to digital data using an ADC and sent to the microprocessor. Actuators are physical mechanical devices (e.g., motors, valves, heaters) that perform actions to alter the physical environment. The microprocessor continuously compares the incoming sensor readings with predefined optimal threshold values. If a sensor value exceeds or drops below a threshold, the microprocessor sends a control signal to the corresponding actuator (e.g., opening a window motor or turning on a water pump) to restore conditions to normal, completing a feedback loop.

1 mark: Describing the role of sensors in taking continuous physical readings and sending them to the CPU (with ADC conversion). 1 mark: Describing the role of actuators in performing mechanical work to alter the environment. 2 marks: Explaining the feedback interaction (microprocessor compares data against preset thresholds; if outside limits, it commands the actuators to trigger an adjustment).

An SSD is superior for a portable tablet because:
1. It lacks moving parts, providing high physical durability and impact resistance when dropped.
2. It has low energy consumption, preserving battery charge for mobile use.
3. It is much lighter and smaller in size, allowing the tablet to remain thin and lightweight.
4. It has much faster read/write speeds, enabling faster boot-up and application loading times.

Max 4 marks. Award up to 2 marks per reason (1 mark for identifying a valid advantage of SSDs compared to HDDs, and 1 mark for explaining why this is beneficial specifically for a portable tablet computer):

- SSDs have no moving parts / are more durable / robust (1 mark)
- ...so they are less likely to be damaged when dropped or carried around (1 mark)
- SSDs consume less power / are more energy-efficient (1 mark)
- ...which extends the battery life of the tablet (1 mark)
- SSDs are lighter / physically smaller (1 mark)
- ...which helps keep the tablet thin and lightweight (1 mark)
- SSDs have faster read/write/access speeds (1 mark)
- ...allowing the device to boot up and load apps much faster (1 mark)

Symmetric encryption uses only one private key for both encryption and decryption. This key must be securely shared. Asymmetric encryption uses two separate but linked keys: a public key, which is made public to allow encryption, and a private key, which is kept completely secret and used to decrypt.

Award 1 mark per point up to a maximum of 4 marks:
- Symmetric encryption uses a single/same key for both encryption and decryption (1 mark)
- This single key must be shared/exchanged, which creates a security risk if intercepted (1 mark)
- Asymmetric encryption uses a key pair consisting of a public key and a private key (1 mark)
- The public key is widely available and is used only to encrypt the data (1 mark)
- The private key is kept secret/private by the receiver and is used to decrypt the data (1 mark)
- Asymmetric encryption is more secure because the decryption key is never transmitted or shared (1 mark)

- **Input** matches **A** because reading sensor data (temperature and humidity) is the phase where data is received by the system.
- **Process** matches **B** because comparing the values against a threshold is a computation/decision-making step.
- **Output** matches **C** because turning on the physical fan is the action or result produced by the system.
- **D** is not used as it is irrelevant to the active components of decomposition.

One mark for each correct match, up to a maximum of 3 marks:
- Input matched with A (1 mark)
- Process matched with B (1 mark)
- Output matched with C (1 mark)

- **Input** matches **A** because capturing vehicle details and weight is the retrieval of data.
- **Process** matches **B** because calculating the toll price using an algorithm is the manipulation/processing of data.
- **Output** matches **C** because displaying the fee and opening the barrier gate is the system's output response.
- **D** is an unused description because the number of lanes is an environmental attribute, not a dynamic functional part of the decomposed transaction.

One mark for each correct match, up to a maximum of 3 marks:
- Input matched with A (1 mark)
- Process matched with B (1 mark)
- Output matched with C (1 mark)

- **Input** matches **A** because retrieving weight, duration, and heart rate values provides the raw data required for calculation.
- **Process** matches **B** because computing the calories burned using the mathematical formula is the processing stage.
- **Output** matches **C** because displaying the final calculated results on the screen represents the output stage.
- **D** is not used because the color of the wristband is an irrelevant aesthetic detail (abstraction removes this).

One mark for each correct match, up to a maximum of 3 marks:
- Input matched with A (1 mark)
- Process matched with B (1 mark)
- Output matched with C (1 mark)

Let us trace the algorithm step-by-step:
1. Initialize `MaxRun ← 0` and `CurrentRun ← 0`.
2. `Index = 1`: `Temp[1] = -2 < 0` is True. `CurrentRun` becomes `1`. Since `1 > 0`, `MaxRun` becomes `1`.
3. `Index = 2`: `Temp[2] = -5 < 0` is True. `CurrentRun` becomes `2`. Since `2 > 1`, `MaxRun` becomes `2`.
4. `Index = 3`: `Temp[3] = 3 < 0` is False. `CurrentRun` becomes `0`.
5. `Index = 4`: `Temp[4] = -1 < 0` is True. `CurrentRun` becomes `1`. Since `1 > 2` is False, `MaxRun` remains `2`.
6. `Index = 5`: `Temp[5] = -4 < 0` is True. `CurrentRun` becomes `2`. Since `2 > 2` is False, `MaxRun` remains `2`.
7. `Index = 6`: `Temp[6] = -3 < 0` is True. `CurrentRun` becomes `3`. Since `3 > 2` is True, `MaxRun` becomes `3`.
8. After the loop, the algorithm outputs: `"Max frost run: ", 3`.

One mark per correct column or sequence:
- MP1: Correct `Index` values from 1 to 6 in order.
- MP2: Correct trace of `CurrentRun` updates (`1`, `2`, `0`, `1`, `2`, `3`).
- MP3: Correct trace of `MaxRun` updates (changing to `1`, then `2`, then staying empty/unchanged until updating to `3` on the final step).
- MP4: Correct output message `"Max frost run: 3"` on the final line (or similar representation).

Let us trace the loop iterations with the initial input `Code = 3524`:
- Initial state: `Sum = 0`, `Weight = 4`.
- **Iteration 1**:
- `Digit ← 3524 MOD 10 = 4`
- `Sum ← 0 + (4 * 4) = 16`
- `Code ← 3524 DIV 10 = 352`
- `Weight ← 4 - 1 = 3`
- **Iteration 2**:
- `Digit ← 352 MOD 10 = 2`
- `Sum ← 16 + (2 * 3) = 22`
- `Code ← 352 DIV 10 = 35`
- `Weight ← 3 - 1 = 2`
- **Iteration 3**:
- `Digit ← 35 MOD 10 = 5`
- `Sum ← 22 + (5 * 2) = 32`
- `Code ← 35 DIV 10 = 3`
- `Weight ← 2 - 1 = 1`
- **Iteration 4**:
- `Digit ← 3 MOD 10 = 3`
- `Sum ← 32 + (3 * 1) = 35`
- `Code ← 3 DIV 10 = 0`
- `Weight ← 1 - 1 = 0`
- The loop terminates since `Code > 0` is now False (`Code = 0`).
- Output: `"Checksum: 35"`.

Marking breakdown (5 marks total):
- MP1: Correct initial row setup with Code as `3524`, Sum as `0`, and Weight as `4`.
- MP2: Correct trace of the `Digit` column sequence (`4`, `2`, `5`, `3`).
- MP3: Correct trace of the decreasing `Code` values (`352`, `35`, `3`, `0`).
- MP4: Correct trace of the accumulating `Sum` values (`16`, `22`, `32`, `35`) and `Weight` decreases (`3`, `2`, `1`, `0`).
- MP5: Correct final output `"Checksum: 35"` recorded below the main processing loops.

Error 1: Line 06
Correction: `PassCount <- 0`

Error 2: Line 09
Correction: `IF Scores[Index] >= 50`

Error 3: Line 11
Correction: `PassTotal <- PassTotal + Scores[Index]`

Error 4: Line 15
Correction: `AveragePass <- PassTotal / PassCount`

1 mark per correct line number and corresponding correction, up to a maximum of 4 marks.
- Line 06 correction: PassCount should be initialized to 0.
- Line 09 correction: Condition should check >= 50 instead of > 50.
- Line 11 correction: Scores should be accumulated rather than overwritten (PassTotal <- PassTotal + Scores[Index]).
- Line 15 correction: Total score should be divided by PassCount instead of 100.

```pseudocode
DECLARE MaxDiff : INTEGER
DECLARE Diff : INTEGER
DECLARE Index : INTEGER
MaxDiff <- 0
// Loop through the array comparing each element with the next
FOR Index <- 1 TO 49
Diff <- ABS(Temp[Index] - Temp[Index + 1])
// Check if the current difference is larger than the maximum found so far
IF Diff > MaxDiff
THEN
MaxDiff <- Diff
ENDIF
NEXT Index
OUTPUT "The largest difference is: ", MaxDiff
```

One mark per mark point, max four:
- MP1: Correct variable declarations for `MaxDiff`, `Diff`, and `Index`.
- MP2: A loop running from 1 to 49 to process consecutive element pairs.
- MP3: Correct calculation of absolute difference between `Temp[Index]` and `Temp[Index + 1]`.
- MP4: Selection statement checking if current difference is greater than `MaxDiff` and updating `MaxDiff` accordingly, with final output of the maximum difference.

Error 1: Line 10
Correction: `FOR Index <- 1 TO Length`

Error 2: Line 11
Correction: `IF SUBSTRING(Phrase, Index, 1) = Target`

Error 3: Line 13
Correction: `Count <- Count + 1`

Error 4: Line 16
Correction: `OUTPUT "Total occurrences: ", Count`

One mark per correct error and correction:
- Line 10: In 1-indexed string representation, the loop must start at index 1 instead of 0.
- Line 11: The parameters for SUBSTRING should be `Phrase, Index, 1` to inspect one character at a time.
- Line 13: Increment count by 1 instead of adding `Index`.
- Line 16: Output the value of the `Count` variable instead of the search character `Target`.

```pseudocode
DECLARE Found : BOOLEAN
DECLARE Index : INTEGER
DECLARE SearchName : STRING

INPUT SearchName
Found <- FALSE
Index <- 1

WHILE Found = FALSE AND Index <= 100 DO
IF Names[Index] = SearchName
THEN
Found <- TRUE
ELSE
Index <- Index + 1
ENDIF
ENDWHILE

IF Found = TRUE
THEN
OUTPUT "Name found at index: ", Index
ELSE
OUTPUT "Name not found"
ENDIF
```

One mark per mark point, max four:
- MP1: Initialization of `Found` to `FALSE` and `Index` to 1.
- MP2: `WHILE` loop with correct conditional expression `Found = FALSE AND Index <= 100`.
- MP3: Correct comparison inside the loop, updating `Found` to `TRUE` if matches, otherwise incrementing `Index`.
- MP4: Conditional statement after the loop to output the search results correctly.

To retrieve the name and destination of the missions, we use `SELECT Name, Destination`.
To filter for successful missions, the WHERE clause must check if the `Success` field is equal to `TRUE` (or `True` / `1`).

The completed statement is:
`SELECT Name, Destination`
`FROM SpaceMission`
`WHERE Success = TRUE;`

One mark for each correct answer:
- [Blank 1]: Name, Destination (both fields required, any order)
- [Blank 2]: Success
- [Blank 3]: TRUE (accept True or 1)

We need to filter by the `Genre` field being equal to `'Sci-Fi'`. Thus [Blank 1] is `Genre` and [Blank 2] is `'Sci-Fi'` (enclosed in single or double quotes to indicate text value).
We need to sort the results in descending order of price, so [Blank 3] is `Price DESC`.

The complete statement is:
`SELECT Title, Price`
`FROM BookInventory`
`WHERE Genre = 'Sci-Fi'`
`ORDER BY Price DESC;`

One mark for each correct answer:
- [Blank 1]: Genre
- [Blank 2]: 'Sci-Fi' or "Sci-Fi" (do not accept Sci-Fi without quotes)
- [Blank 3]: Price DESC (accept DESCENDING or desc)