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

In a direct changeover, the old system is immediately decommissioned and the new system is fully implemented. If the new system contains major undetected bugs or fails entirely, there is no alternative system operational to fall back on, which can lead to catastrophic operational disruption in a hospital environment.

Award up to 2.78 marks: 1.39 marks for identifying the high risk or lack of a fallback system, and 1.39 marks for explaining the potential consequences in the context of the hospital environment.

During the fetch stage, the CPU copies the address stored in the Program Counter (PC) to the Memory Address Register (MAR). The MAR then places this address on the address bus so that the physical RAM location can be addressed and the instruction retrieved.

Award up to 2.78 marks: 1.39 marks for identifying that MAR receives the instruction address from the Program Counter, and 1.39 marks for describing how it uses the address bus to locate the instruction in RAM.

A VPN secures the connection by encrypting all data packets before they travel over the public internet, ensuring that interceptors cannot read the content. It also creates a secure, authenticated tunnel between the remote client and the corporate network, hiding the user's actual external IP address.

Award up to 2.78 marks: 1.39 marks for explaining how data encryption ensures confidentiality, and 1.39 marks for describing how tunneling or secure authentication prevents interception.

Tracing the first pass of bubble sort on [12, 5, 8, 3, 14]: 1. Compare 12 and 5: swap to [5, 12, 8, 3, 14]. 2. Compare 12 and 8: swap to [5, 8, 12, 3, 14]. 3. Compare 12 and 3: swap to [5, 8, 3, 12, 14]. 4. Compare 12 and 14: no swap [5, 8, 3, 12, 14]. At the end of the pass, the largest value (14) has settled at the final position.

Award 2.78 marks for the exact correct final array [5, 8, 3, 12, 14]. Award 1.39 marks if one element is misplaced but the bubbles-to-the-end trace is partially correct.

Visual accessibility features include screen readers (which read interface elements aloud using text-to-speech feedback) and visual adjustment mechanisms such as screen magnifiers, scalable large-text options, or high-contrast color themes.

Award 1.39 marks for each correct accessibility feature identified, up to a maximum of 2.78 marks (e.g., screen readers, magnification tools, high contrast modes, voice assistants).

RAM is volatile, meaning it loses all stored data when power is lost, and it allows dynamic reading and writing. ROM is non-volatile, preserving stored data even without power, and is permanently written during manufacture, making it read-only during normal runtime operations.

Award up to 2.78 marks: 1.39 marks for correctly distinguishing their volatility, and 1.39 marks for correctly distinguishing their write/read capabilities.

The header of a network packet contains crucial metadata for routing and assembly, which includes the sender's (source) IP address, the receiver's (destination) IP address, the sequence number of the packet, and error-checking checksums.

Award 1.39 marks for each correct item identified, up to a maximum of 2.78 marks (e.g., source IP, destination IP, packet sequence number, checksum).

Evaluating mystery(4): it returns 4 * mystery(3). mystery(3) returns 3 * mystery(2). mystery(2) returns 2 * mystery(1). mystery(1) reaches the base case and returns 1. Computing back upwards: mystery(2) = 2 * 1 = 2; mystery(3) = 3 * 2 = 6; mystery(4) = 4 * 6 = 24.

Award 2.78 marks for the correct integer value 24. Award 1.39 marks if the mathematical expansion was correctly worked out but a minor arithmetic mistake occurred.

1. The Program Counter (PC) holds the address of the next instruction, which is copied to the Memory Address Register (MAR). 2. The MAR uses the address bus to locate the instruction in RAM. 3. The instruction at that address is copied via the data bus into the Memory Data Register (MDR).

Award up to 2.78 marks as follows: 1 mark for stating that the MAR receives or holds the address of the next instruction to be fetched (from the PC); 1 mark for explaining that the MAR points to or accesses the specific address in RAM; 0.78 marks for explaining that the instruction or data located at that memory address is loaded into the MDR.

(a)
- Issue 1: Privacy and Confidentiality. Unauthorized individuals might intercept patient records during transmission or access them due to weak authentication mechanisms, exposing highly private health data.
- Issue 2: Digital Divide / Staff Training. Some medical staff or patients may lack the necessary IT literacy, resulting in errors in data entry or frustration during the transition phase, which could temporarily impact patient care.

(b)
- Implementation: Both the legacy paper-based system and the new cloud-based EHR system run concurrently. Doctors enter patient records into both systems for a specified period (e.g., one month) until the new system is verified to work correctly.
- Advantage: Low risk; if the new EHR system suffers a failure or data loss, the clinic has the paper files as an active and up-to-date backup.
- Disadvantage: High workload and duplication of effort; staff must perform double data entry, which can lead to stress and reduced time for patient care.

(c)
- A prototype provides an early, simplified version of the user interface and basic system workflow.
- It allows doctors and clinic staff to test the usability of the software on mobile tablets and provide feedback to developers early in the process.
- This helps identify design flaws, clarify system requirements, and prevent expensive revisions after the software is fully developed.

(d)
- Method 1: Data Encryption (e.g., utilizing HTTPS/TLS protocols) during transmission. This scrambles the patient records into unreadable ciphertext so that even if intercepted, they cannot be read without the private decryption key.
- Method 2: Virtual Private Network (VPN). Establishes an encrypted network tunnel specifically between the clinic's local network/devices and the cloud servers, ensuring data is shielded from public internet inspection.

(a) [4 marks]
- 1 mark for identifying a valid social/ethical issue.
- 1 mark for outlining it in the context of the clinic up to 2 issues.
(Accept: Privacy/security leaks, digital exclusion, data loss during migration, consent of patient records transfer).

(b) [4 marks]
- 2 marks for describing parallel implementation correctly in this context (running both concurrently, double entry).
- 1 mark for a valid advantage (failsafe/redundancy/low risk).
- 1 mark for a valid disadvantage (increased workload/inefficient).

(c) [3 marks]
- 1 mark for defining/describing a prototype (early interactive mock-up).
- 1 mark for explaining stakeholder feedback (interaction with doctors/nurses).
- 1 mark for connecting this to system improvement (clarifying requirements, reducing final costs, error reduction).

(d) [4 marks]
- 1 mark for identifying a security method.
- 1 mark for explaining how it prevents unauthorized access, up to 2 methods.
(Award max 2 marks for simple lists without explanation. Acceptable methods: End-to-end encryption, VPN, Multi-factor authentication for transit endpoints, secure API gateways).

(a)
- A protocol is a set of standardized rules and guidelines that govern how data is formatted, transmitted, and received across a network, ensuring that different devices can communicate successfully.

(b)
- Suitability: High flexibility and lower installation costs. Smart devices can be placed anywhere in the school building (e.g., ceilings, outdoor walls) without laying down expensive physical ethernet cabling. It is also highly scalable, allowing new IoT devices to be added seamlessly.
- Security Drawback: Physical boundaries do not contain wireless signals. Unauthorized users outside the school premises can intercept wireless signals (eavesdropping) or attempt to access the network remotely.

(c)
- The router receives data packets from the IoT devices over the local wireless access point.
- It inspects the destination IP address contained in the packet headers.
- It references its routing table to determine the most efficient path through the network and forwards the packet to the next hop or directly to the school's internal server.

(d)
- Data Encryption: Converts the plain text data sent by IoT devices into ciphertext using an encryption algorithm and key. Even if an attacker intercepts the wireless signal, the intercepted data remains unreadable without the correct decryption key.
- MAC Address Filtering: The wireless access point maintains an access control list of approved Media Access Control (MAC) addresses (the physical, unique identifiers of the school's IoT hardware). Any device attempting to connect whose MAC address is not on this whitelist will be blocked immediately from joining the network.
- Synthesis: Combined, MAC filtering prevents unauthorized devices from establishing physical/logical connections, while encryption protects data confidentiality in case authorized channels are sniffed or bypassed.

(a) [2 marks]
- 1 mark for defining protocol as a set of rules/standards.
- 1 mark for explaining its purpose (enabling successful, understandable communication/data exchange between devices).

(b) [4 marks]
- 2 marks for explaining suitability (mobility, ease of deployment, scalability, absence of physical cabling in tight locations).
- 2 marks for discussing the security drawback (signal leakage beyond school walls, vulnerability to sniffing or man-in-the-middle attacks).

(c) [3 marks]
- 1 mark for receiving packets and reading destination IP addresses in headers.
- 1 mark for mentioning the use of a routing table/routing protocols.
- 1 mark for forwarding the packet along the optimal/fastest path towards the school server.

(d) [6 marks]
- Up to 3 marks for describing data encryption (mentioning plaintext/ciphertext, key requirement, and protection of confidentiality during transit).
- Up to 3 marks for describing MAC address filtering (mentioning physical/unique hardware addresses, whitelisting, and blocking unauthorized access at the connection phase).

(a)
- Difference: A queue is a First-In-First-Out (FIFO) data structure where elements are added at the rear and removed from the front. In contrast, a stack is a Last-In-First-Out (LIFO) structure where elements are added and removed from the same end (the top).
- Suitability: A queue is suitable for incoming delivery orders because it preserves chronological fairness, ensuring that the first customer who places an order is the first customer whose package is processed and delivered.

(b)
```
// Assuming PACKAGES is an array containing 5 package objects
loop I from 0 to 4
CURRENT_PACKAGE = PACKAGES[I]
if CURRENT_PACKAGE.weight > 10 then
HEAVY_QUEUE.enqueue(CURRENT_PACKAGE)
else
LIGHT_QUEUE.enqueue(CURRENT_PACKAGE)
end if
end loop
```

(c)
- A trace table is used to manually dry-run the algorithm step-by-step.
- It records the values of variables (like index `I`, `CURRENT_PACKAGE.weight`, and queue states) at each line of execution.
- This allows developers to check for logical errors, off-by-one errors in the loop limits, or incorrect branching decisions without needing to compile or run the code.

(d)
- Standard algorithms (like Quick Sort or Merge Sort) are highly optimized and have known time complexities (such as \(O(N \log N)\)).
- Using them ensures the system remains scalable when handling hundreds of thousands of packages, preventing system lag.
- They are pre-tested and reliable, which reduces development time and prevents software bugs in high-throughput enterprise environments.

(a) [4 marks]
- 2 marks for contrasting FIFO (queue) and LIFO (stack) operations.
- 2 marks for justifying the queue (fairness, processing in order of arrival, preventing older orders from starvation).

(b) [5 marks]
- 1 mark for establishing a loop that executes exactly 5 times (0 to 4).
- 1 mark for accessing the element from the array using the loop index.
- 1 mark for the correct conditional statement check (weight > 10).
- 1 mark for correctly calling HEAVY_QUEUE.enqueue() and LIGHT_QUEUE.enqueue() in the appropriate branches.
- 1 mark for correct logical nesting and block termination (end if, end loop/next).

(c) [3 marks]
- 1 mark for stating it tracks the changes in variable values during execution.
- 1 mark for explaining that it traces execution step-by-step/line-by-line.
- 1 mark for identifying its output as finding dry-run logical/boundary errors.

(d) [3 marks]
- 1 mark for discussing efficiency/computational complexity (e.g., \(O(N \log N)\) vs \(O(N^2)\)).
- 1 mark for discussing scalability in large systems (handling large databases of packages).
- 1 mark for discussing reliability/robustness of using pre-tested solutions.

### Part (a)
One advantage of inheritance is **code reusability** and the elimination of redundant declarations.
In the context of GreenHarvest, `RefrigeratedContainer` inherits general fields such as `containerID` and `maxWeight` from `CargoContainer` without needing to redefine them. This allows development to focus purely on specialized attributes such as temperature tracking, reducing development time and simplifying code maintenance.

### Part (b)
```
+-----------------------------------------------+
| CargoContainer |
+-----------------------------------------------+
| - containerID : String |
| - maxWeight : double |
+-----------------------------------------------+
| + CargoContainer(String, double) |
+-----------------------------------------------+
^
| [Inheritance Arrow: hollow triangle point]
|
+-----------------------------------------------+
| RefrigeratedContainer |
+-----------------------------------------------+
| - targetTemp : double |
+-----------------------------------------------+
| + RefrigeratedContainer(String, double, double)|
| + isTemperatureSafe(double) : boolean |
+-----------------------------------------------+
```

### Part (c)
```java
public class RefrigeratedContainer extends CargoContainer {
private double targetTemp;

public RefrigeratedContainer(String containerID, double maxWeight, double targetTemp) {
super(containerID, maxWeight);
this.targetTemp = targetTemp;
}

public boolean isTemperatureSafe(double currentTemp) {
return Math.abs(currentTemp - this.targetTemp) <= 2.0;
}
}
```

### Part (a) [4 marks]
- **1 mark** for stating an advantage of inheritance (e.g., code reuse, modularity, lower redundancy).
- **1 mark** for explaining that advantage clearly.
- **1 mark** for identifying the specific superclass-subclass relationship (`CargoContainer` is superclass, `RefrigeratedContainer` is subclass).
- **1 mark** for demonstrating how fields like `containerID` are shared without duplication.

### Part (b) [5 marks]
- **1 mark** for two correct class box headers showing proper class names.
- **1 mark** for correct fields with private modifier (-) and correct data types.
- **1 mark** for correct methods/constructors with public modifier (+).
- **1 mark** for indicating correct types/return types in methods.
- **1 mark** for using the correct inheritance notation (solid line with an open/hollow arrowhead pointing to `CargoContainer`).

### Part (c) [6 marks]
- **1 mark** for correct class declaration `public class RefrigeratedContainer extends CargoContainer`.
- **1 mark** for declaring private double field `targetTemp`.
- **1 mark** for correct constructor signature matching parameters.
- **1 mark** for correct use of `super(containerID, maxWeight)` as the first statement in the constructor.
- **1 mark** for initializing `this.targetTemp = targetTemp`.
- **1 mark** for implementing `isTemperatureSafe` using `Math.abs(currentTemp - targetTemp) <= 2.0` (or equivalent range checking).

### Part (a)
- **Method overloading** occurs within the same class when multiple methods share the same name but have different signatures (different number, type, or order of parameters). Example: A class could define `addMembership(String memberName)` and `addMembership(String memberName, double promotionDiscount)`.
- **Method overriding** occurs when a subclass implements a method that is already declared in its superclass, keeping identical parameters and return type. Example: `PremiumMembership` overrides `calculateMonthlyFee()` defined in `Membership` to implement its custom premium pricing logic.

### Part (b)
1. **Extensibility**: It allows the introduction of new membership types (e.g., `VIPMembership`) without changing the core fee calculation logic. The program automatically calls the appropriate subclass method through dynamic binding.
2. **Reduced Code Complexity**: A single loop traversing one uniform array (`Membership[]`) can handle billing for all types of memberships, eliminating the need for multiple loops or conditional `instanceof` checks.

### Part (c)
```java
public double calculateTotalRevenue(Membership[] members) {
double total = 0.0;
if (members != null) {
for (int i = 0; i < members.length; i++) {
if (members[i] != null) {
total += members[i].calculateMonthlyFee();
}
}
}
return total;
}
```

### Part (a) [4 marks]
- **1 mark** for defining method overloading correctly (same name, different signature, same class).
- **1 mark** for a valid example of overloading.
- **1 mark** for defining method overriding correctly (same name, same signature, different class in hierarchy).
- **1 mark** for a valid example of overriding.

### Part (b) [4 marks]
- **2 marks** for explaining the benefit of extensibility/scalability (adding new subclasses with no change to processing code).
- **2 marks** for explaining simplicity/cleanliness of code (avoiding multiple arrays, typecasting, and explicit conditional logic).

### Part (c) [7 marks]
- **1 mark** for correct method header returning a `double` and accepting `Membership[]` parameter.
- **1 mark** for declaring and initializing a total revenue accumulator variable (e.g., `double total = 0.0;`).
- **1 mark** for checking if the input array itself is null.
- **1 mark** for a correct loop that traverses from index `0` to `members.length - 1`.
- **1 mark** for a null-safety check verifying that `members[i] != null`.
- **1 mark** for correctly calling the `calculateMonthlyFee()` method on elements.
- **1 mark** for returning the accumulated total at the end of execution.

### Part (a)
- **Composition** represents a strong ownership relationship where the lifetime of the part is entirely dependent on the lifetime of the whole. If the whole object is destroyed, the part is also destroyed. For example, the relationship between `HybridCar` and `ElectricMotor` is composition; an electric motor is manufactured as an integral part of the car, and if the car is deleted from the system, its motor has no meaningful independent existence.
- **Aggregation** represents a weaker, independent relationship where the part can exist even if the whole is destroyed. For example, the relationship between `HybridCar` and `Driver` is aggregation; a driver can rent different cars, and if a particular `HybridCar` is removed from the fleet database, the `Driver` object remains unaffected.

### Part (b)
Encapsulation is the bundling of data and the methods that operate on that data into a single unit (class), while restricting direct access to some components.
- **`private` modifier**: Restricts field access so that variables can only be read or modified within the declaring class, preventing external entities from corrupting data directly.
- **Accessors/Mutators (Getters/Setters)**: Provide controlled entry points to access or modify fields. Mutators can include data validation, ensuring that the object's state remains consistent (e.g., rejecting negative fuel values).

### Part (c)
**1. Trip Class**
```java
public class Trip {
private double distance;
private double fuelUsed;

public Trip(double distance, double fuelUsed) {
this.distance = distance;
this.fuelUsed = fuelUsed;
}

public double getDistance() {
return this.distance;
}

public double getFuelUsed() {
return this.fuelUsed;
}
}
```

**2. Average Fuel Efficiency Method**
```java
public double getAverageFuelEfficiency(Trip[] trips) {
double totalDistance = 0.0;
double totalFuel = 0.0;
for (int i = 0; i < trips.length; i++) {
totalDistance += trips[i].getDistance();
totalFuel += trips[i].getFuelUsed();
}
return (totalFuel / totalDistance) * 100.0;
}
```

### Part (a) [4 marks]
- **1 mark** for defining composition as a strong relationship where the part cannot exist without the whole.
- **1 mark** for applying composition correctly to `HybridCar` and `ElectricMotor`.
- **1 mark** for defining aggregation as a weak relationship where the part exists independently.
- **1 mark** for applying aggregation correctly to `HybridCar` and `Driver`.

### Part (b) [4 marks]
- **1 mark** for identifying the `private` access modifier.
- **1 mark** for explaining how `private` restricts direct attribute access.
- **1 mark** for identifying getters/setters (accessors/mutators).
- **1 mark** for explaining how getters/setters offer validation or read-only control over the class state.

### Part (c) [7 marks]
**Trip Class [3 marks]:**
- **1 mark** for defining private `distance` and `fuelUsed` fields with correct types.
- **1 mark** for a correct constructor initializing both fields.
- **1 mark** for both public getter methods returning the attributes.

**Method [4 marks]:**
- **1 mark** for declaring and initializing double accumulators for total distance and total fuel.
- **1 mark** for a standard loop that correctly loops through the `trips` array.
- **1 mark** for retrieving and adding values using the correct getter methods (`getDistance()` and `getFuelUsed()`).
- **1 mark** for computing and returning the correct efficiency calculation based on the formula: `(totalFuel / totalDistance) * 100.0`.