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

Lossless compression compresses files by looking for patterns and representing them more efficiently, meaning no original data is lost and the exact original file can be reconstructed. Lossy compression removes unnecessary or less noticeable data permanently to significantly reduce file size, which means the original file cannot be reconstructed exactly.

Award 1 mark for each distinct difference up to a maximum of 2 marks.
- Lossless keeps all data/quality intact whereas lossy permanently removes data/quality. (1 mark)
- Lossy achieves a higher compression ratio / smaller file size than lossless. (1 mark)
- Lossless allows exact reconstruction of the original file, lossy does not. (1 mark)

Ransomware is a type of malicious software designed to block access to a computer system or encrypt its files until a sum of money (a ransom) is paid to the attacker.

Award 1 mark for each valid characteristic up to a maximum of 2 marks:
- Encrypts files / locks the system (1 mark)
- Demands payment / cryptocurrency ransom to unlock files (1 mark)
- Often spreads via malicious email attachments or unpatched software vulnerabilities (1 mark)

An interrupt is a signal generated by hardware or software that alerts the processor to an event that needs immediate attention. The CPU pauses its current execution, saves its state, and runs an Interrupt Service Routine (ISR) to handle the interrupt before resuming.

Award 1 mark for each point:
- It is a signal sent from a device or software to the CPU / processor. (1 mark)
- It causes the processor to temporarily pause its current task to handle the event / execute an ISR. (1 mark)

A checksum is an error-detection method. Before transmission, an algorithm is applied to the data block to produce a numerical checksum. This checksum is sent alongside the data. On receipt, the same algorithm is run by the receiver on the incoming data. If the calculated checksum matches the received checksum, the data is assumed correct; otherwise, an error has occurred.

Award 1 mark for each point up to a maximum of 2:
- Sender calculates a checksum based on the data and sends it with the block. (1 mark)
- Receiver recalculates the checksum and compares it to the received checksum value. (1 mark)
- If they do not match, an error is detected / data is retransmitted. (1 mark)

In the Von Neumann architecture, the Program Counter (PC) is a dedicated register. Its main job is to hold the memory address of the next instruction that the CPU needs to fetch and execute. Once the instruction is fetched, the PC is incremented to point to the subsequent instruction.

Award 1 mark for each point:
- Stores/holds the memory address of the next instruction to be fetched / executed. (1 mark)
- Increments (by 1) to point to the next instruction after a fetch. (1 mark)

Cookies are small text files downloaded onto a user's computer when visiting a website. They serve several purposes, including storing login states so users don't have to log in on every page, remembering items in a shopping cart, storing user-specific preferences, and tracking user browsing habits for targeted advertising.

Award 1 mark for each valid function up to a maximum of 2 marks:
- Storing user preferences / customisation settings (1 mark)
- Keeping track of items in a shopping cart / basket (1 mark)
- Maintaining a user's login session / state (1 mark)
- Tracking browsing behavior / targeted advertising (1 mark)
Reject: 'saving passwords' without security qualification, or vague answers like 'saving data'.

To find the file size in MiB:
1. Calculate the total number of pixels: \(1024 \times 768 = 786,432\) pixels.
2. Calculate the file size in bits (using 16-bit colour depth): \(786,432 \times 16 = 12,582,912\) bits.
3. Convert bits to bytes by dividing by 8: \(12,582,912 / 8 = 1,572,864\) bytes (or alternatively, \(2\) bytes per pixel: \(786,432 \times 2 = 1,572,864\) bytes).
4. Convert bytes to KiB by dividing by 1024: \(1,572,864 / 1024 = 1536\) KiB.
5. Convert KiB to MiB by dividing by 1024: \(1536 / 1024 = 1.5\) MiB.

1 mark for calculating total pixels or total bits: \(1024 \times 768 = 786,432\) pixels or \(12,582,912\) bits.
1 mark for converting to bytes: \(1,572,864\) bytes (e.g., showing division by 8 or multiplying pixels by 2).
1 mark for dividing by \(1024 \times 1024\) to convert to MiB (e.g., showing 1536 KiB).
1 mark for the correct final answer: 1.5 MiB (Accept 1.5).

To find the file size in MiB:
1. Use the standard formula: \(\text{File size in bits} = \text{sample rate} \times \text{sample resolution} \times \text{duration in seconds} \times \text{number of channels}\).
2. Calculate the size in bits: \(8192 \times 16 \times 120 \times 2 = 31,457,280\) bits.
3. Convert bits to bytes by dividing by 8: \(31,457,280 / 8 = 3,932,160\) bytes. (Alternatively, calculate directly in bytes: \(8192 \times 2\text{ bytes} \times 120 \times 2 = 3,932,160\) bytes).
4. Convert bytes to KiB by dividing by 1024: \(3,932,160 / 1024 = 3840\) KiB.
5. Convert KiB to MiB by dividing by 1024: \(3840 / 1024 = 3.75\) MiB.

1 mark for multiplying sample rate, sample resolution, duration, and channel count: \(8192 \times 16 \times 120 \times 2\) bits or \(8192 \times 2 \times 120 \times 2\) bytes.
1 mark for correct total size in bytes: \(3,932,160\) bytes.
1 mark for division by \(1024\) to get \(3840\) KiB.
1 mark for correct final answer: 3.75 MiB (Accept 3.75).

a) Perform binary addition:
```
1 0 1 1 0 1 0 0 (180 in denary)
+ 0 1 1 0 1 1 0 1 (109 in denary)
-----------------
1 0 0 0 1 0 0 0 1 (289 in denary)
```
Showing carry bits: Carry 1 is generated in columns 2, 3, 4, 5, 6, 7 and past the most significant bit (bit 7).

b) Yes, an overflow error occurred. The original numbers are 8-bit, but their sum (289) is greater than the maximum representable value of 255 in an 8-bit register, resulting in a 9th bit (the leftmost '1') which cannot be stored in an 8-bit register.

Part a:
1 mark for showing correct carry bits or intermediate column additions.
1 mark for the correct 9-bit binary sum: `100010001` (Accept `00010001` with an explicit carry-out of `1` indicated).

Part b:
1 mark for stating that an overflow error has occurred.
1 mark for explaining that the result requires 9 bits to represent, which exceeds the storage limit of an 8-bit register / CPU word size (or explaining that 289 exceeds the maximum 8-bit limit of 255).

1. A low-powered red laser beam is shone onto the surface of the disc. 2. The disc is spun at a constant speed by a motor. 3. The laser track consists of microscopic pits and lands. 4. Light reflects off the lands but is scattered/not reflected back by the pits or transitions between them. 5. A light-sensing photo-diode detects the changes in intensity of the reflected light. 6. These changes in light reflection are converted into electrical pulses representing binary values (1s and 0s).

Award 1 mark per correct point up to a maximum of 5 marks. - Laser is shone onto the surface of the disc. - The disc is rotated/spun by a motor. - The disc surface has a track made of pits and lands. - Laser light is reflected off the lands / scattered by the pits (or transitions). - A sensor/photoelectric cell detects the reflected light. - The changes in reflected light are converted into electrical signals/binary (1s and 0s). (Note: Accept references to pits/lands representing 0s and transitions representing 1s or vice versa).

1. Receiver B generates a public-private key pair where the two keys are mathematically linked. 2. Receiver B sends their public key to Sender A (or publishes it). 3. Receiver B keeps their private key secret. 4. Sender A encrypts the plaintext message using Receiver B's public key, creating ciphertext. 5. The ciphertext is transmitted over the network. 6. Only Receiver B can decrypt the ciphertext using their matching private key to recover the plaintext.

Award 1 mark per correct point up to a maximum of 5 marks. - Receiver B generates a public-private key pair (or public key and private key are mathematically linked). - Receiver B distributes/sends their public key to Sender A (or public key is made public). - Sender A encrypts the message (plaintext) using Receiver B's public key. - The encrypted message (ciphertext) is transmitted. - Receiver B decrypts the ciphertext using their private key. - Only Receiver B's private key can decrypt a message encrypted with Receiver B's public key (ensuring confidentiality).

1. The CPU checks for any pending interrupts at the end of each Fetch-Decode-Execute (FDE) cycle. 2. If an interrupt is present, the CPU suspends execution of the current process. 3. The current contents of CPU registers (including the Program Counter) are saved onto a stack. 4. The CPU retrieves and executes the Interrupt Service Routine (ISR) / interrupt handler program. 5. Once the ISR is finished, the saved register states are restored from the stack. 6. The CPU resumes the execution of the original process from the point of interruption.

Award 1 mark per correct point up to a maximum of 5 marks. - CPU checks for interrupts at the end of each cycle / instruction. - The execution of the current task/program is suspended/halted. - The state of the current registers / Program Counter (PC) / status register is saved (to a stack). - The CPU loads/runs the specific Interrupt Service Routine (ISR) / interrupt handler. - After the ISR completes, the saved CPU state / registers are restored from the stack. - The CPU resumes the suspended task / program.

1. **Operating system**: This is the core software that manages hardware resources, processes, and memory.
2. **RAM**: Random Access Memory is the primary memory dynamically allocated to running applications.
3. **Virtual memory**: Used when physical RAM is fully occupied; it temporarily transfers pages of data to secondary storage.
4. **Device driver**: Translate OS instructions into a format the peripheral hardware can understand.
5. **Utility software**: Maintenance tools that optimize, analyze, and configure computer operations.
6. **Interrupt**: A signal to the CPU from software or hardware requesting immediate processing time.

Award 1 mark for each correct term up to a maximum of 6 marks:
- [1] Operating system
- [2] RAM
- [3] Virtual memory
- [4] Device driver
- [5] Utility software
- [6] Interrupt

*Note: Spelling must be accurate to match the word bank. Reject plurals (e.g., 'Device drivers') unless clearly recognizable.*

- Statement 1 describes standard even or odd parity verification. (Parity check)
- Statement 2 describes generating a numeric block check value sent alongside data transmission. (Checksum)
- Statement 3 highlights the use of a calculated extra digit (like Modulo-11) for system entry errors. (Check digit)
- Statement 4 outlines the automatic request-to-resend protocol based on acknowledgment signals. (ARQ)
- Statement 5 refers to two-dimensional parity, allowing coordinate mapping to correct a bit error. (Parity check)
- Statement 6 identifies manual transcription/transposition protection on input codes. (Check digit)

Award 1 mark for each correctly identified statement:
- Row 1: Parity check
- Row 2: Checksum
- Row 3: Check digit
- Row 4: ARQ
- Row 5: Parity check
- Row 6: Check digit

Statement 1: The output of a NOR gate is 1 (high) only when all of its inputs are 0. Statement 2: An XOR (Exclusive-OR) gate outputs 1 only when the inputs are different. Statement 3: A NAND gate outputs 0 only when both of its inputs are 1.

1 mark for correctly identifying Statement 1 as NOR. 1 mark for correctly identifying Statement 2 as XOR. 1 mark for correctly identifying Statement 3 as NAND.

Expression 1 represents a NAND operation. Expression 2 represents a NOR operation. Expression 3 represents an Exclusive-OR (XOR) operation.

1 mark for matching Expression 1 to NAND. 1 mark for matching Expression 2 to NOR. 1 mark for matching Expression 3 to XOR.

Truth Table X represents an XOR gate because the output is 1 only when inputs are different. Truth Table Y represents a NOR gate because the output is 1 only when both inputs are 0. Truth Table Z represents a NAND gate because the output is 0 only when both inputs are 1.

1 mark for identifying Truth Table X as XOR. 1 mark for identifying Truth Table Y as NOR. 1 mark for identifying Truth Table Z as NAND.

Error 1:
- Line: 01
- Problem: Initializing Max to 999 is too high for a maximum search; it will act as a minimum finder and fail if all scores are lower than 999.
- Correction: Max <- 0 (or Max <- Scores[1])

Error 2:
- Line: 04
- Problem: The comparison operator is less-than (<) instead of greater-than (>).
- Correction: IF Scores[Index] > Max THEN

Error 3:
- Line: 06
- Problem: When a new maximum is found, the Count must reset to 1 instead of accumulating the occurrences of old, smaller maximums.
- Correction: Count <- 1

- 1 mark: Identifying Line 01 is incorrect and correcting it to Max <- 0 or Max <- Scores[1].
- 1 mark: Identifying Line 04 is incorrect and correcting the comparison operator to >.
- 1 mark: Identifying Line 06 is incorrect.
- 2 marks: Correctly explaining why Line 06 is incorrect (count must reset to 1 when a new maximum is encountered) and writing the correct assignment (Count <- 1).

The algorithm first initializes a accumulator variable 'Total' to 0. It then uses a FOR loop running from 1 to 30 to sum all values in the 'Scores' array. After the loop, it calculates the 'Average' by dividing 'Total' by 30. Finally, a second FOR loop runs from 1 to 30, checking each value in the 'Scores' array. If a score is greater than 'Average', the student's name from 'Names' at the same index is output.

- 1 mark: Initializing a running total variable to 0 and correctly looping 30 times to sum all array scores.
- 1 mark: Calculating the class average after the first loop by dividing the total by 30.
- 1 mark: Using a second loop running from 1 to 30 to inspect each element.
- 1 mark: Writing an IF statement that compares Scores[Index] > Average.
- 1 mark: Outputting the corresponding student name (Names[Index]) inside the conditional block.

The linear search checks each element from index 1 up to the length of the array, which is 50. Therefore, [1] is 50. In the IF condition, we compare each element of the array with the query search parameter, so [2] is SearchValue. If a match is found, the loop termination flag is set to true, so [3] is TRUE. After the loop, if the element was successfully found, we must return its index, so [4] is Index. If not found, we return -1 as specified, so [5] is -1.

Award 1 mark for each correctly filled gap up to 5 marks:
- [1] 50
- [2] SearchValue
- [3] TRUE (accept True)
- [4] Index
- [5] -1

- Initial: Total is 0.
- Iteration 1 (I = 1): Numbers[1] is 3. 3 MOD 2 != 0, so Total becomes 0 - 3 = -3.
- Iteration 2 (I = 2): Numbers[2] is 8. 8 MOD 2 == 0, so Total becomes -3 + 8 = 5.
- Iteration 3 (I = 3): Numbers[3] is 5. 5 MOD 2 != 0, so Total becomes 5 - 5 = 0.
- Iteration 4 (I = 4): Numbers[4] is 12. 12 MOD 2 == 0, so Total becomes 0 + 12 = 12.
- Iteration 5 (I = 5): Numbers[5] is 7. 7 MOD 2 != 0, so Total becomes 12 - 7 = 5.

Award 1 mark for each correctly filled row of the trace table corresponding to each value of I from 1 to 5:
- Row 1: I = 1, Numbers[I] = 3, Total = -3
- Row 2: I = 2, Numbers[I] = 8, Total = 5
- Row 3: I = 3, Numbers[I] = 5, Total = 0
- Row 4: I = 4, Numbers[I] = 12, Total = 12
- Row 5: I = 5, Numbers[I] = 7, Total = 5

Let's perform a step-by-step dry run of the algorithm:
1. Initially: Total = 10, X = 1.
2. First Loop Iteration (X = 1): X <= 5 is true. Items[1] is 5. Since 5 < 10 is true, Total becomes 10 + 5 = 15. Items[1] becomes 5 * 2 = 10. X is incremented by 2, becoming 3.
3. Second Loop Iteration (X = 3): X <= 5 is true. Items[3] is 12. Since 12 < 10 is false, the ELSE branch runs: Total becomes 15 - 2 = 13. X is incremented by 2, becoming 5.
4. Third Loop Iteration (X = 5): X <= 5 is true. Items[5] is 9. Since 9 < 10 is true, Total becomes 13 + 9 = 22. Items[5] becomes 9 * 2 = 18. X is incremented by 2, becoming 7.
5. Loop termination (X = 7): X <= 5 is false. The loop terminates.

1 mark: Correctly tracing the sequence of X values (1, 3, 5, 7)
1 mark: Correctly updating Items[1] to 10 when X = 1
1 mark: Correctly updating Items[5] to 18 when X = 5
1 mark: Correctly updating Total to 15 when X = 1
1 mark: Correctly updating Total to 13 when X = 3
1 mark: Correctly updating Total to 22 when X = 5

For part (a), the query requires selecting 'Name' and 'Price' fields from the 'CHOCOLATE' table. The conditions are 'CocoaPercentage >= 70' and 'InStock = TRUE'. Sorting is performed on 'Price' in ascending order (which is the default or specified using ASC).
For part (b), ProductCode is the correct primary key because it is a unique identifier for each individual chocolate product record.

Part (a) [Max 4 marks]:
- 1 mark: SELECT Name, Price
- 1 mark: FROM CHOCOLATE
- 1 mark: WHERE CocoaPercentage >= 70 AND InStock = TRUE (Accept InStock = 1 or InStock)
- 1 mark: ORDER BY Price (Accept ORDER BY Price ASC)

Part (b) [Max 2 marks]:
- 1 mark: Identifying ProductCode as the primary key
- 1 mark: Valid explanation (e.g., each product code is unique, prevents duplicates, uniquely identifies each record)

Here is a complete, standard IGCSE-compliant pseudocode solution:

```text
DECLARE CargoHold : ARRAY[1:6, 1:4] OF INTEGER
DECLARE Row, Col, Weight, TotalWeight, HeaviestRow, MaxRowWeight, RowWeight, EmptyCount : INTEGER

// Initialising 2D Array to 0
FOR Row <- 1 TO 6
FOR Col <- 1 TO 4
CargoHold[Row, Col] <- 0
NEXT Col
NEXT Row

// Initialising tracking variables
TotalWeight <- 0
EmptyCount <- 0
MaxRowWeight <- -1
HeaviestRow <- 0

// Data entry and validation loop
FOR Row <- 1 TO 6
FOR Col <- 1 TO 4
REPEAT
OUTPUT "Enter weight for Row ", Row, ", Column ", Col, ":"
INPUT Weight
IF Weight < 0 OR Weight > 150 THEN
OUTPUT "Error: Weight must be between 0 and 150 kg."
ENDIF
UNTIL Weight >= 0 AND Weight <= 150

CargoHold[Row, Col] <- Weight
NEXT Col
NEXT Row

// Calculations
FOR Row <- 1 TO 6
RowWeight <- 0
FOR Col <- 1 TO 4
RowWeight <- RowWeight + CargoHold[Row, Col]
IF CargoHold[Row, Col] = 0 THEN
EmptyCount <- EmptyCount + 1
ENDIF
NEXT Col

TotalWeight <- TotalWeight + RowWeight

IF RowWeight > MaxRowWeight THEN
MaxRowWeight <- RowWeight
HeaviestRow <- Row
ENDIF
NEXT Row

// Outputs
OUTPUT "Total cargo weight: ", TotalWeight, " kg"
OUTPUT "Row with heaviest weight: ", HeaviestRow
OUTPUT "Number of empty compartments: ", EmptyCount
```

Award marks for any of the following points, up to a maximum of 15 marks:

- **Array Declaration & Initialisation (3 marks)**
- 1 mark: Declaring the array `CargoHold` as a 2D array of integers with dimensions [1:6, 1:4].
- 1 mark: Outer and inner loops correct (e.g., 1 to 6 and 1 to 4) for initialisation.
- 1 mark: Setting every element `CargoHold[Row, Col]` to 0 inside the loops.

- **Input and Validation (4 marks)**
- 1 mark: Nested loops used correctly to traverse rows (1 to 6) and columns (1 to 4) for data entry.
- 2 marks: Validation check using a validation loop (e.g. `REPEAT...UNTIL` or `WHILE...DO`) ensuring inputs are >= 0 and <= 150, including a suitable error message if invalid.
- 1 mark: Storing the validated input correctly in `CargoHold[Row, Col]`.

- **Calculations and Processing (6 marks)**
- 1 mark: Declaring and initialising `TotalWeight` and `EmptyCount` to 0.
- 1 mark: Incrementing `TotalWeight` by each compartment's weight or by row totals.
- 1 mark: Correctly checking if `CargoHold[Row, Col] = 0` and incrementing `EmptyCount` accordingly.
- 1 mark: Correctly summing the weight of each individual row inside the row-loop.
- 2 marks: Correctly identifying the maximum row weight and saving the index of that row (e.g., comparing `RowWeight > MaxRowWeight` and updating `MaxRowWeight` and `HeaviestRow`).

- **Outputs (2 marks)**
- 1 mark: Displaying total weight and empty compartment count with appropriate messages.
- 1 mark: Displaying the row number of the heaviest row with an appropriate message.