2024 Edexcel IGCSE Computer Science 模擬試題連答案詳解

For part (a), tracing execution: Index 0: current=3, positive odd, total=3, count=1. Index 1: current=-5, negative, skipped. Index 2: current=7, positive odd, total=10, count=2. Index 3: current=4, positive even, skipped. Index 4: current=9, positive odd, total=19, count=3. Index 5: current=-2, negative, skipped. Index 6: loop ends. For part (b), average = total / count = 19 / 3 = 6.33. For part (c), if the array has no numbers fitting the condition, count remains 0. Dividing by 0 causes a runtime crash, which this check avoids.

(a) 8 marks total: 2 marks for tracking index correctly up to 6, 2 marks for identifying positive odd values (3, 7, 9), 2 marks for updating total to 3, then 10, then 19, 2 marks for updating count to 1, then 2, then 3. (b) 2 marks: 1 mark for showing division 19/3, 1 mark for correct value of 6.33. (c) 3.33 marks: 1.33 marks for identifying division-by-zero risk, 1 mark for explaining that it prevents a program crash, 1 mark for identifying that this scenario occurs when count is 0.

For part (a), full mesh connects every node to every other node, providing backup paths (redundancy) and high bandwidth, but requires excessive cables and ports. For part (b), IP addresses (Logical, Network Layer, changeable) routing packets across subnets, while MAC addresses (Physical, Data Link Layer, unchangeable) route within local segments. For part (c), routers analyze packet headers, find destination IPs, and use routing metrics/tables to forward packets to the next hop.

(a) 4 marks: 1 mark for each valid advantage of mesh (max 2), 1 mark for each valid disadvantage of mesh (max 2). (b) 6 marks: 2 marks for contrasting purposes, 2 marks for contrasting assignment, 2 marks for contrasting network layers. (c) 3.33 marks: 1.33 marks for identifying destination IP check, 1 mark for path decision using routing table, 1 mark for forwarding action.

For part (a), switching to electric drones removes diesel exhaust, improving urban air quality, but battery manufacturing and disposal (toxic lithium) and non-renewable electricity grids present negative environmental trade-offs. For part (b), legal responsibility relies on whether crash causes were code defects (manufacturer) or physical maintenance neglect (operator). For part (c), companies must process requests to erase captured video footage of individuals and should actively mask/blur faces to avoid unauthorized storage of private data.

(a) 4 marks: 1 mark for each of two positive environmental impacts, 1 mark for each of two negative environmental impacts. (b) 5 marks: 2 marks for explaining manufacturer vs operator liability, 2 marks for software developers' safety-first engineering duties, 1 mark for compulsory liability insurance needs. (c) 4.33 marks: 1.33 marks for identifying images as personal data, 1 mark for identifying deletion rights, 1 mark for technical mitigation steps (e.g., blurring, low retention), 1 mark for providing pathways for user deletion requests.

For part (a): (i) PC holds the next instruction address and increments. (ii) MAR copies the PC address via address bus to point to main memory. (iii) MDR receives the binary instruction from RAM via data bus. For part (b), Cache utilizes Static RAM (SRAM) which is extremely fast compared to DRAM (RAM), minimizing CPU idle cycles. SRAM is physically massive per bit and highly expensive, limiting practical sizes on chip dies. For part (c), doubling the data bus width allows 8 bytes to pass simultaneously instead of 4, reducing required read cycles for large values.

(a) 6 marks total: 2 marks for explaining PC (holds address, increments), 2 marks for explaining MAR (holds address to access memory), 2 marks for explaining MDR (holds actual data fetched). (b) 4 marks: 2 marks for explaining access speed and locality of cache, 2 marks for cost, physical size, and thermal dissipation limitations of SRAM. (c) 3.33 marks: 1.33 marks for explaining double bandwidth per cycle, 1 mark for reduction in bus cycles, 1 mark for faster data processing throughput.

For part (a), the literal translation is \(S = (A \cdot (W + M)) + (A \cdot W \cdot M)\). For part (b), mapping the truth table shows S is 1 for inputs (1,0,1), (1,1,0), and (1,1,1), and 0 for all other 5 combinations. For part (c), we simplify: \(S = A \cdot W + A \cdot M + A \cdot W \cdot M\). Factoring out \(A \cdot W\) yields \(A \cdot W \cdot (1 + M) + A \cdot M\). Since \(1 + M = 1\), the expression becomes \(A \cdot W + A \cdot M\), which factors to \(A \cdot (W + M)\).

(a) 3 marks: 1.5 marks for first term, 1.5 marks for second term combined with OR. (b) 6 marks: 2 marks for list of all 8 binary states, 4 marks for the output values (1 mark per 2 correct outputs). (c) 4.33 marks: 1.33 marks for identifying redundant conditions (since both W and M open implies at least one is open), 2 marks for correct algebraic steps, 1 mark for final expression \(S = A \cdot (W + M)\).

For part (a), File size = sample rate × bit depth × channels × seconds. Convert 24 bits to 3 bytes. Convert 3 minutes to 180 seconds. Size = \(48,000 \times 3 \times 2 \times 180 = 51,840,000\) bytes. Dividing by 1,000,000 gives 51.84 MB. For part (b), smaller sample rate captures fewer data points per second, saving storage space, but it fails to capture high-frequency components resulting in poorer, muffled audio. For part (c), an image is a 2D grid of pixels. Colour depth determines bits per pixel (e.g., 8-bit allows 256 colours). Metadata tells the processor the dimensions and structure so it can render the pixels correctly.

(a) 5 marks: 1 mark for duration conversion (180s), 1 mark for bit depth conversion (3 bytes), 1 mark for correct formula substitution, 1 mark for correct byte calculation (51,840,000), 1 mark for correct division to 51.84 MB. (b) 4 marks: 2 marks for details of space savings (fewer samples recorded), 2 marks for explanation of sound quality degradation (cannot resolve high frequencies). (c) 4.33 marks: 1.33 marks for describing the pixel grid representation, 1 mark for defining colour depth, 1 mark for defining metadata, 1 mark for describing metadata's role in rendering.

```python
def validatePassword(password):
# Rule 1: Minimum length check
if len(password) < 8:
return False

# Rule 4: Case-insensitive check for "school"
if "school" in password.lower():
return False

has_upper = False
has_digit = False

# Iterate through characters to check Rules 2 and 3
for char in password:
if char.isupper():
has_upper = True
if char.isdigit():
has_digit = True

return has_upper and has_digit
```

- 2 marks: Length check logic (returns `False` if length is less than 8).
- 2 marks: Substring check logic (converts to lowercase and checks if "school" is in the password, returning `False` if true).
- 3 marks: Iterates through each character to check for at least one uppercase letter (e.g., using `isupper()`).
- 3 marks: Iterates through each character to check for at least one digit (e.g., using `isdigit()`).
- 3.33 marks: Syntactically correct function structure, using conditional checks, maintaining logic flags, and returning a final Boolean value.

```python
def findPeaks(temperatures):
peaks = []
n = len(temperatures)
if n == 0:
return peaks
if n == 1:
return [0]

# Check boundary condition: start of list
if temperatures[0] > temperatures[1]:
peaks.append(0)

# Check internal list elements
for i in range(1, n - 1):
if temperatures[i] > temperatures[i-1] and temperatures[i] > temperatures[i+1]:
peaks.append(i)

# Check boundary condition: end of list
if temperatures[n-1] > temperatures[n-2]:
peaks.append(n-1)

return peaks
```

- 2 marks: Correctly handles empty arrays and single-element arrays to prevent index out of bounds errors.
- 3 marks: Correctly checks the first element comparison against only index 1.
- 3 marks: Correctly checks the last element comparison against only index \( n-2 \).
- 3 marks: Employs a loop from index 1 to \( n-2 \) checking if the element is strictly greater than both its left and right neighbors.
- 2.33 marks: Correctly appends matching indices to a tracking list and returns the list of indices.

```python
def calculateAverageScore(filename, threshold):
total_score = 0
count = 0
try:
# Open file safely using a context manager
with open(filename, 'r') as file:
for line in file:
line = line.strip()
if not line:
continue
# Split line into Name and Score
parts = line.split(',')
score = float(parts[1])
# Accumulate and count scores strictly exceeding threshold
if score > threshold:
total_score += score
count += 1
except FileNotFoundError:
return 0.0

# Prevent division by zero
if count == 0:
return 0.0
return total_score / count
```

- 2 marks: Correctly opens the file in read mode and ensures the file is closed (using `with open` or explicitly calling `.close()` in a finally block).
- 3 marks: Safely iterates through lines and splits using `,` as a delimiter.
- 3 marks: Correctly extracts and converts the score component to a numeric type (float or integer).
- 3 marks: Conditionally adds up the scores and counts elements that strictly exceed the `threshold` variable.
- 2.33 marks: Computes division correctly, explicitly preventing division-by-zero errors when no records meet the criteria by returning `0.0`.

Let's trace step-by-step:
- Initialization: `inputStr` = "AABBBCCCC", `compressed` = "", `count` = 1. Length of `inputStr` is 9. The loop variable `i` runs from 0 to 7 (LENGTH - 2).
- **i = 0**: `inputStr[0]` is 'A', `inputStr[1]` is 'A'. Match! `count` becomes 2.
- **i = 1**: `inputStr[1]` is 'A', `inputStr[2]` is 'B'. No match! `compressed` becomes "" + 'A' + "2" = "A2". `count` reset to 1.
- **i = 2**: `inputStr[2]` is 'B', `inputStr[3]` is 'B'. Match! `count` becomes 2.
- **i = 3**: `inputStr[3]` is 'B', `inputStr[4]` is 'B'. Match! `count` becomes 3.
- **i = 4**: `inputStr[4]` is 'B', `inputStr[5]` is 'C'. No match! `compressed` becomes "A2" + 'B' + "3" = "A2B3". `count` reset to 1.
- **i = 5**: `inputStr[5]` is 'C', `inputStr[6]` is 'C'. Match! `count` becomes 2.
- **i = 6**: `inputStr[6]` is 'C', `inputStr[7]` is 'C'. Match! `count` becomes 3.
- **i = 7**: `inputStr[7]` is 'C', `inputStr[8]` is 'C'. Match! `count` becomes 4.
- Loop ends.
- After the loop: `compressed` = "A2B3" + `inputStr[8]` ('C') + "4" = "A2B3C4".

- 3 marks: Tracking state transitions of `count` correctly at matching indices (increases on consecutive characters).
- 4 marks: Correctly tracking changes to `compressed` inside the `ELSE` branch at boundary transitions (when `i = 1` and `i = 4`).
- 3 marks: Running the loop correctly up to `i = 7` (preventing off-by-one errors).
- 3.33 marks: Correct final post-loop output generation of `"A2B3C4"`.

```python
def bubbleSort(arr):
n = len(arr)
for i in range(n):
# Initialize swapped flag for each outer pass
swapped = False
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
swapped = True
# If no elements were swapped, array is sorted
if not swapped:
break
```

**Complexity Explanation:**
- Best-case time complexity: \( O(n) \).
- This occurs when the list is already sorted. The algorithm makes one complete pass of \( n-1 \) comparisons, finds no elements to swap, and breaks out of the loop.

- 3 marks: Declares a boolean variable `swapped` and initializes it to `False` inside the outer loop, before the start of the inner loop.
- 3 marks: Sets the `swapped` variable to `True` whenever a physical swap of elements occurs inside the conditional block.
- 3 marks: Places a conditional break statement checking if `swapped` is still `False` immediately after the inner loop finishes to terminate the outer loop.
- 4.33 marks: Correctly specifies the best-case complexity of \( O(n) \) and explains that it is achieved when the input array is already in sorted order.

```python
def sumOfPrimes(N):
total_sum = 0
# Outer loop going up to and including N
for num in range(2, N + 1):
is_prime = True
# Inner loop to check potential factors
for factor in range(2, int(num**0.5) + 1):
if num % factor == 0:
is_prime = False
break # Break inner loop if a divisor is found
# If is_prime is still True, add to accumulator
if is_prime:
total_sum += num
return total_sum
```

- 2 marks: Correctly sets up a function and initializes a summation accumulator to `0`.
- 3 marks: Implements an outer loop starting at 2 and correctly terminating at \( N \) (inclusive).
- 3 marks: Implements an inner loop checking potential factors from 2 up to \( \sqrt{\text{num}} \) or \( \text{num}-1 \).
- 3 marks: Employs standard modulo checking (`%`) and a flag mechanism (boolean variable) to accurately identify non-primes.
- 2.33 marks: Correctly accumulates prime values and returns the expected numerical sum at the end.