2025 IB DP Computer Science 模擬試題連答案詳解

A phased introduction allows the organization to implement the new system in stages (e.g., department by department). If an issue occurs, it is isolated to that specific phase, reducing risk. However, it requires running both systems in parallel for different business functions, which leads to double data entry, potential compatibility issues, and prolonged training times.

[1 mark] for a valid advantage of a phased changeover (e.g., lower risk, easier staff training). [1 mark] for a valid disadvantage (e.g., compatibility issues, high cost of running two systems). [0.5 marks] for explicit comparison/link to direct changeover.

Cache memory is extremely fast, high-speed SRAM located on or very close to the CPU core. It holds copies of frequently or recently used instructions and data. During the fetch stage of the cycle, the CPU checks the cache first. If a cache hit occurs, the instruction is loaded immediately, avoiding the latency associated with fetching data from the main system memory (RAM).

[1 mark] for identifying cache as faster memory storing frequently accessed data/instructions. [1 mark] for explaining the process of checking cache first (cache hit vs cache miss). [0.5 marks] for linking this directly to the reduction of CPU idle time during the fetch phase.

Each packet in a packet-switched network is routed independently. Because network congestion and route availability change dynamically, different packets of the same message may take different paths, resulting in varying transit times and out-of-order arrival. The destination host resolves this by inspecting the sequence numbers in the packet headers (such as TCP headers) and reordering them before delivering the complete message to the application layer.

[1 mark] for explaining why packets arrive out of order (independent routing, dynamic paths, dynamic network congestion). [1 mark] for identifying the use of sequence numbers in packet headers. [0.5 marks] for explaining that the destination reassembles/reorders the packets based on these sequence numbers.

Binary search continually halves the search space. The maximum number of comparisons is given by \(\lceil \log_2(N+1) \rceil\) or \(\lfloor \log_2(N) \rfloor + 1\). For \(N = 1000\): \(2^9 = 512\) and \(2^{10} = 1024\). Since \(512 < 1000 \le 1024\), it will take a maximum of 10 comparisons to either find the item or determine that it is not present.

[1 mark] for identifying the binary division relationship (halving the search space) or writing the logarithmic formula. [1 mark] for showing correct calculation steps (e.g., matching \(2^{10} = 1024\)). [0.5 marks] for the final correct answer of 10.

Two features are: 1. Screen readers: These use text-to-speech engines to read out text, menus, and image descriptions, allowing blind users to navigate the system using audio cues. 2. High-contrast themes / adjustable text size: These modify the visual representation to make elements stand out clearly, assisting users with low vision or color blindness to read text and identify UI elements easily.

[1 mark] for identifying two valid OS-level accessibility features (0.5 marks each). [1 mark] for explaining how each feature improves usability (0.5 marks each). [0.5 marks] for linking both explanations directly to visual impairment needs.

Let's trace the values: Initially: A = 12, B = 18. Iteration 1: B is not 0 (18 != 0). T = 18. B = 12 mod 18 = 12. A = 18. Iteration 2: B is not 0 (12 != 0). T = 12. B = 18 mod 12 = 6. A = 12. Iteration 3: B is not 0 (6 != 0). T = 6. B = 12 mod 6 = 0. A = 6. Iteration 4: B is 0. The loop terminates. Output A is 6. This is the Euclidean algorithm for finding the greatest common divisor (GCD).

[1 mark] for showing correct values after the first loop iteration (A = 18, B = 12). [1 mark] for showing correct subsequent transitions (A = 12, B = 6 then A = 6, B = 0). [0.5 marks] for the correct final output of 6.

The execution of the algorithm step-by-step is as follows:
- **Initial State**: I = 0, A = 0, B = 10.
- **First Iteration (I = 0)**: X is assigned NUMS[0] which is 4. Since 4 mod 2 == 0, A becomes A + 4 = 4, and B becomes B - 1 = 9. I is incremented to 1.
- **Second Iteration (I = 1)**: X is assigned NUMS[1] which is 7. Since 7 mod 2 != 0, A becomes A - 7 = -3, and B becomes B + 2 = 11. I is incremented to 2.
- **Third Iteration (I = 2)**: X is assigned NUMS[2] which is 3. Since 3 mod 2 != 0, A becomes A - 3 = -6, and B becomes B + 2 = 13. I is incremented to 3.
- **Fourth Iteration (I = 3)**: X is assigned NUMS[3] which is 6. Since 6 mod 2 == 0, A becomes A + 6 = 0, and B becomes B - 1 = 12. I is incremented to 4.
- **Fifth Iteration (I = 4)**: X is assigned NUMS[4] which is 2. Since 2 mod 2 == 0, A becomes A + 2 = 2, and B becomes B - 1 = 11. I is incremented to 5.
- **Loop Termination**: I is now 5, the loop condition (I < 5) evaluates to False, and the loop terminates.

Completed Trace Table:
| I | X | A | B |
|---|---|---|---|
| 0 | | 0 | 10|
| 1 | 4 | 4 | 9 |
| 2 | 7 | -3| 11|
| 3 | 3 | -6| 13|
| 4 | 6 | 0 | 12|
| 5 | 2 | 2 | 11|

Award [1 mark] for each correct row of the trace table up to a maximum of [6 marks]:
- [1 mark] for initial values correct (I=0, A=0, B=10).
- [1 mark] for Row 1 (I=1, X=4, A=4, B=9) correct.
- [1 mark] for Row 2 (I=2, X=7, A=-3, B=11) correct.
- [1 mark] for Row 3 (I=3, X=3, A=-6, B=13) correct.
- [1 mark] for Row 4 (I=4, X=6, A=0, B=12) correct.
- [1 mark] for Row 5 (I=5, X=2, A=2, B=11) correct.

The execution of the algorithm step-by-step is as follows:
- **Initial State**: I = 0, A = 0, B = 10.
- **First Iteration (I = 0)**: X is assigned NUMS[0] which is 4. Since 4 mod 2 == 0, A becomes A + 4 = 4, and B becomes B - 1 = 9. I is incremented to 1.
- **Second Iteration (I = 1)**: X is assigned NUMS[1] which is 7. Since 7 mod 2 != 0, A becomes A - 7 = -3, and B becomes B + 2 = 11. I is incremented to 2.
- **Third Iteration (I = 2)**: X is assigned NUMS[2] which is 3. Since 3 mod 2 != 0, A becomes A - 3 = -6, and B becomes B + 2 = 13. I is incremented to 3.
- **Fourth Iteration (I = 3)**: X is assigned NUMS[3] which is 6. Since 6 mod 2 == 0, A becomes A + 6 = 0, and B becomes B - 1 = 12. I is incremented to 4.
- **Fifth Iteration (I = 4)**: X is assigned NUMS[4] which is 2. Since 2 mod 2 == 0, A becomes A + 2 = 2, and B becomes B - 1 = 11. I is incremented to 5.
- **Loop Termination**: I is now 5, the loop condition (I < 5) evaluates to False, and the loop terminates.

Completed Trace Table:
| I | X | A | B |
|---|---|---|---|
| 0 | | 0 | 10|
| 1 | 4 | 4 | 9 |
| 2 | 7 | -3| 11|
| 3 | 3 | -6| 13|
| 4 | 6 | 0 | 12|
| 5 | 2 | 2 | 11|

Award [1 mark] for each correct row of the trace table up to a maximum of [6 marks]:
- [1 mark] for initial values correct (I=0, A=0, B=10).
- [1 mark] for Row 1 (I=1, X=4, A=4, B=9) correct.
- [1 mark] for Row 2 (I=2, X=7, A=-3, B=11) correct.
- [1 mark] for Row 3 (I=3, X=3, A=-6, B=13) correct.
- [1 mark] for Row 4 (I=4, X=6, A=0, B=12) correct.
- [1 mark] for Row 5 (I=5, X=2, A=2, B=11) correct.

(a) Two stakeholders to consult:
- Medical staff (doctors, nurses)
- Administrative/receptionist staff
- Clinic management/directors
- Patients (limited consultation/feedback)

(b) Requirements gathering method and advantage:
- Method: Interviews (e.g., face-to-face discussions with doctors and administrators to understand their workflow).
- Advantage: Allows for deep qualitative insights, clarification of complex medical procedures, and follow-up questions to uncover non-obvious requirements.
- Alternative Method: Direct observation (observing receptionists checking in patients).
- Alternative Advantage: Provides objective, first-hand data on how things are actually done rather than what users say they do.

(c) (i) Comparison of implementation methods:
- Direct changeover: Low cost because only one system is run at a time (no double entry or running redundant servers), but high risk because if the new system fails, there is no backup system to rely on, which could halt clinic operations.
- Parallel running: High cost because both the legacy paper system and the new electronic system run simultaneously (requiring double input and extra workload), but low risk because if the new system fails, the clinic can immediately fall back on the paper system.

(c) (ii) Recommendation:
- Parallel running is highly recommended. Patient medical records are safety-critical. A direct changeover carries too much risk; a system failure could lead to lost patient data or an inability to access historical records during a medical emergency.

(d) Importance and problems of data migration:
- Importance: Ensure historical medical histories, patient contact info, and billing details are accurately transferred to the new database, preserving the continuity of patient care without starting from scratch.
- Problems (choose two):
1. Data format incompatibility: The old paper records or simple spreadsheets may not map directly to the structured schema of the new cloud EHR database.
2. Incomplete or duplicate data: Existing patient records might contain typos, missing fields, or redundant files, which will populate the new database with corrupt/invalid data ("garbage in, garbage out").
3. Data loss during migration: Network dropouts or transfer errors might lead to missing patient records.

(a) [2 marks]
- Award 1 mark for each valid stakeholder identified, up to 2 marks.
- Accept: doctors, nurses, administrative staff, receptionists, IT technicians, clinic managers, patients.
- Reject: general public, competitors.

(b) [3 marks]
- Award 1 mark for identifying and describing a valid requirements gathering method.
- Award up to 2 marks for a well-explained advantage relevant to the method described.
- Acceptable methods: Interviews, questionnaires/surveys, direct observation, document analysis.

(c) (i) [4 marks]
- Award 1 mark for analyzing the risk of direct changeover (high risk explained).
- Award 1 mark for analyzing the cost of direct changeover (low cost explained).
- Award 1 mark for analyzing the risk of parallel running (low risk explained).
- Award 1 mark for analyzing the cost of parallel running (high cost explained).

(c) (ii) [2 marks]
- Award 1 mark for recommending parallel running.
- Award 1 mark for a justified reason linked to patient safety, data integrity, or system downtime.
- Note: Accept direct changeover only if accompanied by an exceptional justification (e.g., strict budget limits with intensive dry-run testing beforehand).

(d) [4 marks]
- Award up to 2 marks for explaining the importance of data migration (1 mark for continuity of care/retaining records, 1 mark for preventing data loss or downtime during transition).
- Award 1 mark each for identifying any two valid problems (up to 2 marks).

(a) Definition and necessity of protocol:
- Definition: A protocol is a set of rules and standards that govern how data is formatted, transmitted, and received across a network.
- Necessity: Standard protocols ensure interoperability. This allows AGVs made by different manufacturers, the server, and network routers to exchange data seamlessly regardless of their underlying hardware or operating systems.

(b) (i) Telemetry transmission via packet switching:
- The telemetry data is divided into smaller, manageable chunks called packets.
- Each packet is appended with a header containing routing details (sender/receiver IP addresses) and packet sequence numbers.
- Each packet is routed independently across the network based on the most efficient path available.
- Once all packets arrive at the destination server, they are reordered and reassembled into the original telemetry dataset using the sequence numbers.

(b) (ii) Packet switching vs. circuit switching:
- Packet switching is more efficient because AGVs send data in short, bursty intervals (telemetry/coordinates). Circuit switching would require a dedicated, continuous link to be reserved for each AGV, which would waste bandwidth when the AGV is idle. Packet switching allows multiple AGVs to dynamically share the same physical channel.

(c) Securing communication:
- Firewall: A firewall is placed at the entry/exit points of the network. It inspects incoming and outgoing traffic, filtering out unauthorized connection attempts from external devices trying to access the server or AGV network.
- Encryption: All transmitted instructions and telemetry data are scrambled into ciphertext using a strong algorithm. If malicious users intercept the wireless transmission, they will see only garbled data and will be unable to read or tamper with the instructions without the private decryption key.

(d) Wireless interference factors (choose two):
- Physical barriers (e.g., tall metal shelving units, concrete walls) causing signal attenuation.
- Electromagnetic radiation/interference from high-power electric motors or conveyor belts in the warehouse.
- Co-channel interference from other wireless devices (e.g., handheld inventory scanners, employee smartphones) operating on the same frequency band.

(a) [3 marks]
- Award 1 mark for a precise definition of a protocol.
- Award up to 2 marks for a clear explanation of its necessity (focusing on interoperability/compatibility and standard rules of communication).

(b) (i) [4 marks]
- Award 1 mark for data segmentation into packets.
- Award 1 mark for adding header information (IP addresses, sequence numbers).
- Award 1 mark for packets being routed independently through the network.
- Award 1 mark for reassembling packets in the correct order at the destination.

(b) (ii) [2 marks]
- Award 1 mark for stating that AGV transmissions are bursty/non-continuous.
- Award 1 mark for explaining that circuit switching wastes dedicated bandwidth, whereas packet switching shares channel capacity dynamically.

(c) [4 marks]
- Award 1 mark for defining/explaining how a firewall operates (monitoring and filtering packet traffic).
- Award 1 mark for applying it to the scenario (preventing unauthorized external connections to AGVs/server).
- Award 1 mark for defining/explaining encryption (scrambling data into ciphertext).
- Award 1 mark for applying it to the scenario (preventing data theft or command spoofing if wireless packets are intercepted).

(d) [2 marks]
- Award 1 mark per valid physical or electromagnetic factor identified, up to 2 marks.
- Accept: metal shelving/structures, electromagnetic interference from heavy machinery, congestion from other devices, or competing WiFi signals.

### Part (a) Solution
Parallel arrays are two or more arrays of the same size where elements at the same index are logically related to each other (i.e., they represent different attributes of the same entity, such as `IDS[i]`, `DESTINATIONS[i]`, and `WEIGHTS[i]` describing the same package).

A key disadvantage of using parallel arrays compared to an array of objects is data integrity maintenance during sorting, deletion, or insertion. If you need to reorder or sort the data (e.g., sorting packages by weight), every array must be reordered in the exact same sequence. If one array is modified without identical changes to the others, the data relationship is permanently lost/corrupted. An array of objects binds all properties together natively, avoiding this risk.

### Part (b) Pseudocode Solution

```
processPackages(targetDest, IDS, DESTINATIONS, WEIGHTS)
totalWeight = 0.0
maxWeight = -1.0
heaviestID = -1
underFiveCount = 0
found = false

loop I from 0 to 499
if DESTINATIONS[I] == targetDest then
found = true
totalWeight = totalWeight + WEIGHTS[I]

if WEIGHTS[I] > maxWeight then
maxWeight = WEIGHTS[I]
heaviestID = IDS[I]
end if

if WEIGHTS[I] < 5.0 then
underFiveCount = underFiveCount + 1
end if
end if
end loop

if found == true then
output "Total Weight: ", totalWeight
output "Heaviest Package ID: ", heaviestID
output "Packages under 5kg: ", underFiveCount
else
output "No packages found for destination: ", targetDest
end if
end processPackages
```

### Part (c) Solution
- **Improvement:** By sorting the `IDS` array, we can use a Binary Search algorithm instead of a Linear Search.
- **Reason:** This improves search time complexity from \(O(N)\) to \(O(\log N)\), making searches significantly faster as the dataset scales.
- **Overhead:** Sorting the `IDS` array requires simultaneously reordering the corresponding elements in both the `DESTINATIONS` and `WEIGHTS` arrays to maintain index-level alignment. This parallel movement of data introduces significant computational overhead whenever a package is added, removed, or sorted.

### Part (a) [3 marks]
- **1 mark:** Correct definition of 'parallel arrays' as multiple arrays where elements at the same index index correspond to the same real-world entity.
- **1 mark:** Identifying a valid disadvantage (e.g., maintaining alignment during operations like sorting, insertion, or deletion).
- **1 mark:** Developing the explanation contextually (e.g., sorting package IDs requires manually shifting destinations and weights; failure to do so results in mismatched package information).

### Part (b) [9 marks]
- **1 mark:** Initializing all tracking variables correctly (e.g., `totalWeight` to 0, `maxWeight` to a low/sentinel value, `found` to false).
- **1 mark:** Loop correctly configured to iterate through all 500 elements (e.g., `0 to 499` or `1 to 500` depending on index convention).
- **1 mark:** Correct conditional check comparing array elements to `targetDest` (e.g., `DESTINATIONS[I] == targetDest`).
- **1 mark:** Correct accumulation of `totalWeight` within the matching block.
- **2 marks:** Correct logic to determine the heaviest package (1 mark for updating the running maximum weight, 1 mark for storing the corresponding ID from the parallel array `IDS[I]`).
- **1 mark:** Correct counter increment for packages weighing under 5.0 kg.
- **1 mark:** Implementing a mechanism (such as a boolean flag or checking counter/total) to verify if any matches were found.
- **1 mark:** Correct final output of calculated values and appropriate error message handling when no matches are found.

### Part (c) [3 marks]
- **1 mark:** Suggesting Binary Search (or logarithmic search).
- **1 mark:** Explaining that it reduces the search time complexity to \(O(\log N)\), which is faster than \(O(N)\) linear search.
- **1 mark:** Explaining the overhead constraint: any sort of `IDS` requires the system to mirror every swap operation across both `DESTINATIONS` and `WEIGHTS` to prevent data corruption.

(a) Encapsulation is the practice of bundling data (attributes) and methods that operate on that data into a single unit (class) while restricting direct access to the data from outside the class. In the Workout class, encapsulation is applied by declaring the attributes workoutID, duration, and caloriesBurned as private. These can only be read through public getter methods, preventing accidental or unauthorized alteration of raw data.

(b) Java Class Definition for Workout:

public class Workout {
private String workoutID;
private int duration;
private double caloriesBurned;

public Workout(String workoutID, int duration, double caloriesBurned) {
this.workoutID = workoutID;
this.duration = duration;
this.caloriesBurned = caloriesBurned;
}

public String getWorkoutID() {
return this.workoutID;
}

public int getDuration() {
return this.duration;
}

public double getCaloriesBurned() {
return this.caloriesBurned;
}

public String calculateIntensity() {
return "General";
}
}

(c) Java Class Definition for CardioWorkout:

public class CardioWorkout extends Workout {
private int averageHeartRate;
private double distance;

public CardioWorkout(String workoutID, int duration, double caloriesBurned, int averageHeartRate, double distance) {
super(workoutID, duration, caloriesBurned);
this.averageHeartRate = averageHeartRate;
this.distance = distance;
}

@Override
public String calculateIntensity() {
if (this.averageHeartRate > 150) {
return "High";
} else if (this.averageHeartRate >= 110) {
return "Medium";
} else {
return "Low";
}
}
}

Part (a) [3 marks]
- 1 mark: Clear definition of encapsulation (hiding internal state, exposing via public methods).
- 1 mark: Application to Workout (making fields private to prevent external modification).
- 1 mark: Explanation of getter methods acting as controlled access points.

Part (b) [5 marks]
- 1 mark: Correct class declaration and private attributes (workoutID, duration, caloriesBurned) with appropriate types.
- 1 mark: Correct constructor assigning all three parameters using 'this' or different variable names.
- 1 mark: All three correct accessor methods (getWorkoutID, getDuration, getCaloriesBurned) returning correct types.
- 1 mark: Signature and return statement for calculateIntensity() returning "General".
- 1 mark: Syntax accuracy (braces, semicolons, standard Java structure).

Part (c) [7 marks]
- 1 mark: Correct subclass header with 'extends Workout'.
- 1 mark: Subclass private attributes (averageHeartRate as int, distance as double) defined correctly.
- 1 mark: Constructor signature accepting five parameters.
- 1 mark: First statement of constructor is 'super(workoutID, duration, caloriesBurned)'.
- 1 mark: Proper assignment of the subclass fields within the constructor.
- 1 mark: Overriding signature for calculateIntensity() matching the superclass method signature.
- 1 mark: Correct logical conditions using if-else structures to return "High", "Medium", or "Low" according to the specified limits.

(a)
Inheritance is an OOP mechanism where a new class (subclass) acquires the properties (attributes) and behaviors (methods) of an existing class (superclass). In this scenario, `ExpressDelivery` is the subclass that inherits from the `Delivery` superclass. It reuses the attributes `trackingID`, `weight`, and `destination`, along with their respective getter methods, and extends the functionality by adding `guaranteedHours` and redefining cost calculations.

(b)
```java
public class ExpressDelivery extends Delivery {
private int guaranteedHours;

public ExpressDelivery(String trackingID, double weight, String destination, int guaranteedHours) {
super(trackingID, weight, destination);
this.guaranteedHours = guaranteedHours;
}

@Override
public double calculateCost() {
double baseCost = super.calculateCost();
if (this.guaranteedHours == 12) {
return baseCost + 20.00;
} else if (this.guaranteedHours == 24) {
return baseCost + 10.00;
} else {
return baseCost + 5.00;
}
}
}
```

(c)
- **Method Overriding** occurs when a subclass provides a specific implementation of a method that is already defined in its parent class, sharing the same signature (name, parameters, and return type). In this scenario, `calculateCost()` in `ExpressDelivery` overrides `calculateCost()` in `Delivery`.
- **Method Overloading** occurs when a class has multiple methods with the same name but different parameter lists (signatures) within the same scope.
- In this scenario, `calculateCost()` is overridden to change behavior based on the object's specific type, rather than overloaded.

(d)
```java
public static double calculateTotalRevenue(Delivery[] shipments) {
double total = 0.0;
for (int i = 0; i < shipments.length; i++) {
if (shipments[i] != null) {
total += shipments[i].calculateCost();
}
}
return total;
}
```
**Polymorphism** allows the array of type `Delivery[]` to contain both `Delivery` and `ExpressDelivery` objects. During execution, when `shipments[i].calculateCost()` is called, **dynamic (late) binding** occurs. The Java Virtual Machine (JVM) dynamically determines the actual subclass type of each object at runtime and executes the correct `calculateCost()` method (either the base class version or the overridden subclass version), ensuring the correct total revenue is calculated automatically without explicit type-casting.

(a) [3 marks total]
- [1 mark] for defining inheritance (sharing attributes/methods from parent to child class).
- [1 mark] for identifying `Delivery` as the superclass/parent and `ExpressDelivery` as the subclass/child.
- [1 mark] for explaining that `ExpressDelivery` inherits fields (`trackingID`, `weight`, `destination`) and behavior (getters) without redefining them, but extends them with `guaranteedHours`.

(b) [5 marks total]
- [1 mark] for correct class signature: `public class ExpressDelivery extends Delivery`.
- [1 mark] for declaring the private attribute: `private int guaranteedHours;`.
- [1 mark] for correct constructor calling `super(...)` as the first statement.
- [1 mark] for correct method overriding header: `public double calculateCost()`.
- [1 mark] for correct conditional logic using `super.calculateCost()` to compute and return the correct cost based on `guaranteedHours`.

(c) [3 marks total]
- [1 mark] for defining method overriding (same name and parameters in subclass, replacing parent behavior) and referencing `calculateCost()` as overridden.
- [1 mark] for defining method overloading (same name but different parameters within the same class context).
- [1 mark] for clarifying that `calculateCost()` in this implementation is overridden to implement specialized subclass logic, not overloaded.

(d) [5 marks total]
- [1 mark] for correct static method signature and double return type.
- [1 mark] for initializing the accumulator variable to `0.0` and returning it at the end.
- [1 mark] for a valid loop iterating through the `shipments` array.
- [1 mark] for invoking `calculateCost()` on the element and adding it to the accumulator.
- [1 mark] for explaining how polymorphism/dynamic binding executes the correct version of `calculateCost()` at runtime based on the actual object type without explicit casting.

### Part (a) Solution
In Java, primitive sorting algorithms compare numbers directly using relational operators (e.g., \`>\`, \`<\`).
1. Objects cannot be compared directly using these relational operators because the operators evaluate object reference memory addresses rather than internal object values.
2. To sort objects, the program must explicitly target and compare specific attributes of the object (such as \`delayMinutes\`) by invoking its accessor methods (like \`getDelayMinutes()\`).

### Part (b) Solution
```java
public void sortByDelayDescending() {
for (int i = 0; i < count - 1; i++) {
int maxIdx = i;
for (int j = i + 1; j < count; j++) {
// Compare the delayMinutes of elements at index j and maxIdx
if (flights[j].getDelayMinutes() > flights[maxIdx].getDelayMinutes()) {
maxIdx = j;
}
}
// Swap flights[i] and flights[maxIdx]
Flight temp = flights[i];
flights[i] = flights[maxIdx];
flights[maxIdx] = temp;
}
}
```

### Part (c) Solution
To handle the secondary sort alphabetically (A-Z) on destination when delays are identical:
```java
if (flights[j].getDelayMinutes() > flights[maxIdx].getDelayMinutes()) {
maxIdx = j;
} else if (flights[j].getDelayMinutes() == flights[maxIdx].getDelayMinutes()) {
// If delays are equal, sort alphabetically (A comes before B, so compareTo returns negative value)
if (flights[j].getDestination().compareTo(flights[maxIdx].getDestination()) < 0) {
maxIdx = j;
}
}
```

### Part (d) Solution
- **Big-O Complexity:** \(O(N^2)\) (or \(O(\text{count}^2)\))
- **Justification:** Selection sort uses nested loops. The outer loop runs \(N-1\) times, and the inner loop performs comparisons that decrease in count with each step: \((N-1) + (N-2) + \dots + 1\). This results in a total of \(\frac{N(N-1)}{2}\) comparisons. Since this number is proportional to \(N^2\), the time complexity is quadratic in all cases, including the worst case.

### Part (a) [2 marks]
- **1 mark** for stating that relational operators (\`>\`, \`<\`) cannot be applied directly to object references.
- **1 mark** for stating that comparisons must extract and compare the inner fields of the object using accessor/getter methods (e.g., \`getDelayMinutes()\`).

### Part (b) [6 marks]
- **1 mark** for correct outer loop boundaries (from \`0\` up to \`count - 1\` or equivalent).
- **1 mark** for correct initialization of tracking variable (e.g., \`int maxIdx = i\`).
- **1 mark** for correct inner loop starting from \`i + 1\` and terminating at \`count\` (to avoid null references).
- **1 mark** for calling \`getDelayMinutes()\` on array elements during comparison.
- **1 mark** for evaluating the condition in descending order (checking if \`j\`'s delay is larger than current max index's delay).
- **1 mark** for a correct swap algorithm using a temporary variable of type \`Flight\`.

### Part (c) [4 marks]
- **1 mark** for checking if the delay times are equal (detecting a tie-breaker situation).
- **1 mark** for calling \`getDestination()\` on both \`Flight\` objects.
- **1 mark** for correctly using the \`.compareTo()\` method (or equivalent string comparison mechanism) on the destinations.
- **1 mark** for checking for a negative result (\`< 0\`) from \`compareTo()\` to prioritize alphabetical order, and correctly updating the index tracker (\`maxIdx\`).

### Part (d) [2 marks]
- **1 mark** for identifying the complexity as \(O(N^2)\) or \(O(\text{count}^2)\).
- **1 mark** for justifying that selection sort uses nested loops, yielding a number of comparisons proportional to \(N^2\) (or mathematically representing \(\frac{N(N-1)}{2}\) operations).