2024 OCR A-Level Computer Science - H446 模擬試題連答案詳解

At the start of the fetch stage, the CPU needs to locate the next instruction. The Program Counter (PC) stores the memory address of this next instruction. This address is copied from the PC to the Memory Address Register (MAR) via the address bus so that the control unit can locate and read the instruction from main memory.

1 mark for stating that the PC holds the address of the next instruction to be fetched. 1 mark for stating that this address is copied directly into the MAR to locate the instruction.

1. Key Exchange: Asymmetric encryption uses public and private keys, meaning a shared secret key does not need to be sent over an insecure connection, preventing interception. 2. Authentication: The digital certificate containing the server's public key is verified by a trusted authority, confirming the server's identity to the client.

1 mark for explaining that no shared secret key needs to be exchanged (avoids key distribution risks). 1 mark for explaining that it allows authentication of the server (using digital certificates/signatures).

A collision occurs when a hashing algorithm calculates the exact same array index for two completely different input keys. One resolution method is linear probing (open addressing), where the algorithm searches sequentially for the next available slot in the table. Another method is chaining (closed addressing), where each index contains a pointer to a linked list of records that share the same hash value.

1 mark for explaining that a collision is when two different input keys produce the same hash value/index. 1 mark for describing a valid resolution method: either linear probing (searching for the next free slot) or chaining (creating a linked list at that index).

Referential integrity is a state of consistency where every foreign key value in a table matches an existing, valid primary key value in the related table. This prevents orphan records. It is enforced automatically by the Database Management System (DBMS) using foreign key constraints, which reject operations that break the link (like deleting a parent record still referenced by a child).

1 mark for defining referential integrity (ensuring foreign keys point to valid primary keys / no orphaned records). 1 mark for explaining that it is enforced by DBMS foreign key constraints (e.g., cascading deletes or blocking invalid inserts).

1. Maximises precision: By ensuring that there are no leading unnecessary zeros or ones in the mantissa, the available bits are used as efficiently as possible for representing the actual value. 2. Unique representation: It ensures there is only one way to represent any real number, making arithmetic comparisons much faster and simpler.

1 mark for: Maximizes the precision/accuracy of the represented value within the allocated bits. 1 mark for: Ensures a unique representation of each number (simplifying comparisons and calculations).

A device driver is a utility program that translates generic operating system commands into specific hardware instructions. It is necessary because computer hardware is manufactured by many different companies with unique interfaces; the driver allows the OS to support new peripherals without having to rewrite its own code.

1 mark for stating that it translates/interfaces between the OS and the physical hardware. 1 mark for explaining that it is necessary to abstract hardware details from the OS, enabling generic OS commands to work on diverse physical models.

The purpose of DNS is to map human-readable domain names (like google.com) to machine-readable IP addresses. If the IP address is not cached locally, the resolver contacts a DNS root server, which directs it to a Top-Level Domain (TLD) server, and finally to an authoritative name server that returns the definitive IP address.

1 mark for: Translating human-friendly domain names to IP addresses. 1 mark for: Querying external name servers (e.g., root, TLD, or authoritative servers) to resolve the mapping when not cached.

First, apply De Morgan's Law to the outermost expression: \(\neg A \land \neg(B \land \neg C)\). Next, apply De Morgan's Law to the right-hand bracketed expression: \(\neg A \land (\neg B \lor \neg\neg C)\). Finally, simplify the double negation of C to get the final expression: \(\neg A \land (\neg B \lor C)\).

1 mark for correct intermediate application of De Morgan: \(\neg A \land \neg(B \land \neg C)\). 1 mark for the final simplified Boolean expression: \(\neg A \land (\neg B \lor C)\).

During the Fetch phase, the Program Counter (PC) stores the address of the next instruction. This address is copied to the Memory Address Register (MAR) via the address bus. Once this has occurred, the PC is incremented so that it points to the subsequent instruction in sequence.

1 mark for: Holds the memory address of the next instruction to be fetched. 1 mark for: It is incremented to point to the next instruction.

Paging is a physical division of memory where blocks (pages) are always of the same size. Segmentation is a logical division where memory is divided into segments of differing sizes that correspond to logical units of code (such as subroutines or objects).

1 mark for identifying that paging uses fixed-size/physical divisions. 1 mark for identifying that segmentation uses variable-size/logical divisions.

Packet switching does not require a dedicated physical channel, meaning bandwidth can be shared among multiple users, which is highly efficient. Furthermore, if a node or path fails, routers can dynamically redirect packets through alternative paths, preventing data loss and communication dropouts.

1 mark for: More efficient use of bandwidth (no idle channels/can share links). 1 mark for: More resilient to network failure (packets can take alternative routes).

Referential integrity maintains database consistency and accuracy. It ensures that any foreign key in one table must match an existing primary key in the related table. This prevents dangling references, such as having an order for a customer ID that does not exist in the customer table.

1 mark for: Ensures database consistency/prevents orphaned or dangling records. 1 mark for: Explaining that a foreign key must correspond to a valid, existing primary key in the related table.

Sign and magnitude has two representations for zero (positive and negative), which wastes memory and complicates comparison. Two's complement has a single representation for zero. Additionally, two's complement allows addition and subtraction to be performed using the same hardware circuit, simplifying CPU design.

1 mark for: Standard addition circuitry can be used for subtraction (no separate subtraction hardware needed). 1 mark for: Only a single representation of zero (eliminates negative zero, simplifying comparisons).

In symmetric encryption, a single private key must be shared beforehand. If intercepted during transmission, the security is compromised. Asymmetric encryption uses a public key to encrypt, which can be shared freely, while only the recipient holds the matching private key required to decrypt it, which never needs to be shared.

1 mark for: In symmetric encryption, sharing the key across the network introduces interception risks. 1 mark for: Asymmetric encryption uses public/private key pairs so the decryption key is never transmitted.

RIPA regulates the powers of public bodies to carry out surveillance and investigation. Two of its primary powers include demanding ISPs to provide access to digital communications and forcing individuals to decrypt encrypted files or hand over cryptographic keys.

1 mark for: Power to intercept and monitor digital communications (such as emails or internet traffic). 1 mark for: Power to demand that encrypted data is decrypted or that decryption keys are surrendered.

Using De Morgan's Law, \(\neg(P \land Q)\) is equivalent to \(\neg P \lor \neg Q\). Applying this to \(\neg(A \land \neg B)\) yields \(\neg A \lor \neg(\neg B)\). Since the double negation \(\neg(\neg B)\) simplifies to \(B\), the final expression is \(\neg A \lor B\).

1 mark for applying De Morgan's Law to split the expression: \(\neg A \lor \neg(\neg B)\). 1 mark for the final simplified answer: \(\neg A \lor B\).

1. The PC holds the memory address of the next instruction to be fetched. 2. Once this address is copied to the MAR (Memory Address Register), the PC is incremented to point to the subsequent instruction in memory.

1 mark for: Stating that the PC holds the address of the next instruction to be fetched. 1 mark for: Stating that the PC is incremented (by 1) once the address is copied to the MAR (or to point to the subsequent instruction).

Symmetric encryption relies on a single shared key to perform both the encryption and decryption of data. Asymmetric encryption utilizes a mathematically linked key pair: a public key (distributed openly) is used to encrypt the data, and a private key (kept secret by the recipient) is used to decrypt it.

1 mark for: Stating that symmetric encryption uses a single/same key for both encryption and decryption. 1 mark for: Stating that asymmetric encryption uses a key pair (public and private keys) where one key encrypts and the other decrypts.

Pipelining is a technique where the CPU parallelises the processing of instructions. While one instruction is being executed, the next is being decoded, and the one after that is being fetched. This maximizes the utilization of different parts of the processor, theoretically completing one instruction per clock cycle instead of waiting for a single instruction to go through all three stages before starting the next. However, pipelining efficiency is reduced by: 1. Branching (conditional jumps): If a branch is taken, instructions fetched speculatively into the pipeline must be discarded (flushed). 2. Data dependencies: An instruction cannot proceed if it relies on a register value that has not yet been written back by a preceding instruction.

1 mark: Explain that pipelining overlaps the stages of the instruction cycle (Fetch, Decode, Execute) for multiple instructions. 1 mark: Explain that this improves performance by increasing instruction throughput / completing more instructions per unit of time. 1 mark: State 'branching / jump instructions' as a limiting factor (as it requires flushing the pipeline). 1 mark: State 'data dependencies' (or 'resource conflict/interrupts/cache misses') as a limiting factor.

Paging and segmentation are both memory management techniques used to implement virtual memory. Similarities: 1. Both allow a program to run even if there is insufficient contiguous physical RAM by swapping blocks of data to and from secondary storage. 2. Both translate virtual memory addresses into physical RAM addresses using lookup tables. Differences: 1. Paging divides physical and logical memory into fixed-size blocks (pages and frames), whereas segmentation divides memory into variable-sized logical blocks (segments) based on the structure of the program (e.g., functions, classes, or arrays). 2. Paging is invisible to the programmer (handled purely by hardware/OS), while segmentation is logical and corresponds to the modular design of the software.

Max 2 marks for similarities: - Both enable virtual memory / allow programs to execute without being fully loaded into RAM. - Both map virtual addresses to physical memory locations. - Both can lead to disk thrashing if memory is overloaded. Max 2 marks for differences: - Paging uses fixed-sized blocks, whereas segmentation uses variable-sized blocks. - Pages are physical divisions, whereas segments are logical divisions based on program structure.

The Transport Layer is responsible for establishing end-to-end communication. It splits the application data into smaller segments/packets, adds a sequence number to each, and includes source/destination port numbers to target the correct application. It also handles flow control and error checking. The Network (Internet) Layer takes these packets and prepends IP addresses (source and destination) to the header. It is responsible for routing the packets across the interconnected networks to reach their destination using the most efficient path via routers.

Transport Layer (max 2 marks): - 1 mark: Splits data into packets/segments and adds sequence numbers to allow reassembly. - 1 mark: Identifies the correct application using port numbers / handles error checking (retransmission). Network/Internet Layer (max 2 marks): - 1 mark: Adds source and destination IP addresses to the packet header. - 1 mark: Handles routing of packets across different networks using routers.

Atomicity ensures that a database transaction is treated as a single, indivisible unit of work. Either all operations within the transaction succeed, or none of them do. For example, in a bank transfer of £50 from Account A to Account B, the debit from A and credit to B must both complete. If the system crashes after A is debited but before B is credited, the database rolls back the transaction so money is not lost. Durability ensures that once a transaction is successfully committed, its changes are permanently written to non-volatile storage and will not be lost, even in the event of a subsequent power failure or system crash. For example, once a ticket booking is confirmed, a power failure seconds later must not cause the booking details to be lost from the database.

Atomicity (2 marks): - 1 mark: Define Atomicity as the all-or-nothing property of transactions. - 1 mark: Provide a valid example (e.g., bank transfer requiring both debit and credit to succeed or rollback). Durability (2 marks): - 1 mark: Define Durability as ensuring committed transactions are permanently saved and survive system crashes. - 1 mark: Provide a valid example (e.g., flight booking records remaining intact after a server power cut).

Step 1: Parse the exponent. The last 4 bits are 0011. Since the sign bit is 0, this is positive. In denary, 0011 = 3. Step 2: Parse the mantissa. The first 8 bits are 01101000. It is positive, so the implied binary point is after the sign bit: 0.1101000. Step 3: Apply the exponent of +3 by shifting the binary point 3 places to the right: 0.1101000 becomes 110.1000 (or 110.1 in binary). Step 4: Convert 110.1 binary to denary. The integer part is 110 (which is 4 + 2 = 6). The fractional part is .1 (which is 0.5). Therefore, the denary number is 6.5.

1 mark: Correctly convert the exponent 0011 to denary +3. 1 mark: Correctly identify the mantissa as 0.1101 (or 0.1101000). 1 mark: Correctly show the application of the exponent, e.g., shifting binary point 3 places to get 110.1 binary (or equivalent sum such as 0.8125 x 8). 1 mark: Correct final denary answer 6.5 (or 6 and a half).

The main difference is reversibility. A hashing algorithm is a one-way function; once plaintext is converted to a hash value, it cannot be run backward to retrieve the original plaintext. Symmetric encryption is a two-way function; data encrypted with a key can be decrypted back to the original plaintext using the same secret key. Hashing Use Case: Storing user passwords. When a user creates a password, its hash is stored. When they log in, the input is hashed and compared to the stored hash. The original password is never stored, maintaining security. Symmetric Encryption Use Case: Encrypting local files/hard drives or confidential data in transit where both the sender and recipient have secure access to the shared key and need to read the actual data.

1 mark: Explain that hashing is one-way / irreversible. 1 mark: Explain that symmetric encryption is two-way / reversible (with a key). 1 mark: Provide a valid hashing use case (e.g., password storage, verifying database integrity / checksums). 1 mark: Provide a valid symmetric encryption use case (e.g., database file encryption, secure messaging where key is pre-shared, hard drive encryption).

Web crawlers (or spiders) are automated programs that systematically navigate the internet. They start with a list of known URLs, download the content of these pages, and extract any links found within them to add to their queue of pages to visit. Indexing software takes the raw page data downloaded by the crawlers, parses the text to extract keywords, metadata, and page structure. It then constructs or updates an index (a massive, optimized database) that maps these keywords to the URLs on which they appear, along with weighting factors. This ensures that when a user searches for a term, the search engine queries the index rather than the live web, returning relevant results in milliseconds.

Max 2 marks for Web Crawlers: - 1 mark: Systematically traverse the web by following hyperlinks from page to page. - 1 mark: Download/fetch the contents / HTML of the visited web pages. Max 2 marks for Indexing: - 1 mark: Parse downloaded text to extract keywords, metadata, and structural features. - 1 mark: Store this in an index / database mapping keywords to their source URLs to allow instant querying.

Under RIPA, authorized public bodies (like police or security services) can: 1. Intercept communications in transit (e.g., monitor emails, phone calls, or internet traffic). 2. Force Internet Service Providers (ISPs) to collect and hand over communications data (metadata like logs of who contacted whom and when). 3. Demand that suspect individuals or organizations decrypt ciphertext or hand over their private encryption keys. 4. Impose strict secrecy on these actions, preventing individuals or companies from revealing that an interception warrant or decryption request has been issued.

1 mark per valid power stated (max 4): - Demand ISPs/telecommunication companies hand over a user's communications data (metadata / activity logs). - Intercept / monitor digital communications in transit (e.g. emails, web traffic). - Demand individuals/organizations hand over encryption keys or decrypt encrypted data. - Prevent disclosure of interception/decryption activities (secrecy / gagging orders). - Conduct covert surveillance of internet activities.

Paging and segmentation are both virtual memory management techniques. Paging divides memory into fixed-sized blocks (physical divisions) known as pages/page frames. It is transparent to the programmer. In contrast, segmentation divides memory into variable-sized blocks (logical divisions) called segments, which represent logical divisions of a program (such as functions, objects, or arrays) and are visible to the developer/compiler.

1 mark per difference identified and 1 mark per expansion/contrast (Max 4 marks total):
- Paging uses fixed-sized blocks/pages (1 mark) whereas segmentation uses variable-sized blocks/segments (1 mark).
- Paging is a physical division of memory / handled by the hardware/OS (1 mark) whereas segmentation is a logical division / reflects the structure of the program (1 mark).
- Paging is transparent to the programmer (1 mark) whereas segmentation is visible to the programmer/compiler (1 mark).

A simple packet-filtering firewall inspects packets individually and in isolation, checking only static fields in the header (e.g., source/destination IP, port number, protocol) against a set of rules. A stateful inspection firewall tracks the context/state of active network connections (e.g., TCP handshakes). It keeps a state table and only permits incoming packets if they are part of an existing, legitimate conversation initiated from inside the network, preventing many types of unauthorized access and spoofing attacks.

1 mark: Packet filtering inspects packet headers (IP addresses/ports) in isolation / statically.
1 mark: Packet filtering does not keep track of the history or state of the connection.
1 mark: Stateful inspection monitors and records active connections/sessions (using a state table).
1 mark: Stateful inspection only allows incoming packets if they match a valid, pre-established outbound request/session.

CPUs are designed for general-purpose sequential processing and contain a few highly powerful cores. In contrast, GPUs have a highly parallel architecture containing thousands of smaller, simpler cores designed to handle multiple tasks concurrently. Hashing millions of passwords is a Single Instruction Multiple Data (SIMD) scenario because the exact same hashing algorithm is run on different data inputs (passwords) independently. The massive parallelism of the GPU allows thousands of password hashes to be computed at the exact same time, dramatically outperforming a CPU.

1 mark: GPU has a highly parallel architecture / contains thousands of smaller, simpler cores (compared to CPU's few, powerful cores).
1 mark: Identifies that password hashing is a parallelizable task / can be calculated independently (Single Instruction Multiple Data / SIMD).
1 mark: GPU can run the same instructions on multiple streams of data concurrently.
1 mark: This leads to significantly higher throughput/speed for this specific bulk task on a GPU.

1. Convert the magnitude to binary: \(3.75 = 3 + 0.5 + 0.25 = 11.11_2\).
2. Represent as a negative fixed-point number in two's complement. If positive is \(0011.1100\), we flip the bits to get \(1100.0011\) and add 1 to get \(1100.0100\).
3. Normalize the binary number. For negative numbers, a normalized mantissa must start with `10`. The binary point must be placed after the first bit: \(1.0001000\).
4. Calculate the exponent: We moved the binary point 2 places to the left, which means we must multiply the mantissa by \(2^2\). Therefore, the exponent is \(+2\).
5. Convert the exponent to 4-bit two's complement: \(0010\).
6. Combined representation: Mantissa = `10001000`, Exponent = `0010`.

1 mark: Converting \(-3.75\) to a valid fixed-point two's complement binary representation (e.g., \(1100.01\) or \(1100.0100\)).
1 mark: Recognizing the need to normalize to a form starting with `10` for a negative number / shifting point 2 places to the left.
1 mark: Correct 8-bit mantissa: `10001000`.
1 mark: Correct 4-bit exponent: `0010`.

Paging and segmentation are two distinct memory management techniques used by an operating system to manage physical memory (RAM). Paging divides physical memory into fixed-size, physical blocks called pages. These pages do not respect the logical structure of a program; a single function or data structure might span multiple pages. Paging can lead to internal fragmentation, where a process does not fully utilize the last page allocated to it. In contrast, segmentation divides memory into variable-size, logical blocks called segments. These segments align with the structure of the program (e.g., individual subroutines, modules, or stack structures). Segmentation can lead to external fragmentation, where free memory is split into small, non-contiguous blocks that cannot accommodate a new segment. Virtual memory is a technique used when RAM is insufficient to hold all active processes. The operating system allocates a portion of secondary storage (such as a hard disk or solid-state drive) to act as temporary RAM. When RAM is full, inactive pages or segments are copied (swapped) from RAM to the virtual memory area on the secondary storage, freeing up space in RAM for active processes. If an inactive page is needed again, it is swapped back into RAM, and another inactive page is moved to secondary storage. While virtual memory allows a computer to run programs that exceed physical memory limits, heavy reliance on it causes performance issues. Secondary storage is significantly slower than RAM, leading to latency. If the system is constantly swapping pages back and forth because RAM is almost entirely full, a phenomenon called 'disk thrashing' occurs. During thrashing, the system spends more time and processing power performing I/O operations (swapping) than executing actual program instructions, causing the computer to become highly unresponsive.

Level 3 (8-10 marks): Thorough discussion of both paging and segmentation, showing clear understanding of differences (logical vs physical). Detailed explanation of virtual memory mechanism and a clear, well-reasoned discussion of the drawbacks (including thrashing). Line of reasoning is logical, structured, and technically accurate. Level 2 (5-7 marks): Good discussion of paging and/or segmentation. Explains virtual memory well. Mentions some drawbacks but may lack detail or depth on thrashing. Line of reasoning is generally clear. Level 1 (1-4 marks): Basic definitions of paging/segmentation. Simple mention of virtual memory. Limited awareness of drawbacks. 0 marks: No worthy content.

Transitioning from decentralized flat-file spreadsheets to a centralized Relational Database Management System (RDBMS) offers significant advantages alongside some implementation challenges. Firstly, flat-file systems suffer from high data redundancy because the same student details must be repeated across separate fee, exam, and attendance spreadsheets. This redundancy leads to poor data integrity; if a student changes their address, updating it in one spreadsheet does not automatically update it in others, causing inconsistencies. An RDBMS addresses this through normalization, storing data in linked, non-redundant tables. Referential integrity is enforced using primary and foreign keys, ensuring that records cannot point to non-existent data. Secondly, security is highly limited in flat-file spreadsheets, which are often either fully accessible or fully locked. An RDBMS offers robust, granular security, allowing administrators to set specific database access permissions (e.g., teachers can view grades but not change payroll). It also supports views, presenting only relevant data to specific users. Thirdly, flat-files do not support concurrent access effectively; if multiple users attempt to edit a spreadsheet simultaneously, conflicts and data loss occur. An RDBMS handles concurrent access safely using record locking, preventing two users from updating the same record at the same time. However, the school group must consider several challenges: the significant initial cost of database software licenses and server infrastructure, the necessity of training administrative staff to write SQL queries or use the new interface, and the high complexity of cleansing and migrating fragmented legacy data into a structured relational schema without causing system downtime.

Level 3 (8-10 marks): Comprehensive evaluation covering all requested areas (integrity, redundancy, security, concurrency, challenges). Clear contrast between flat-files and RDBMS. Technical terminology (e.g., referential integrity, normalization, record locking, views) used accurately. Level 2 (5-7 marks): Good evaluation addressing most areas. Clearly identifies advantages of RDBMS over flat-files. Explains at least one challenge. Some technical terminology used. Level 1 (1-4 marks): Basic points made about databases vs spreadsheets. Limited range of discussion or purely descriptive without evaluation.

Deploying an automated machine-learning triage system in a healthcare trust raises critical ethical, moral, and legal questions. Ethically, the primary concern is algorithmic bias. Machine learning models learn from historical data; if this data contains biases (e.g., under-prioritizing or misdiagnosing minority groups due to historical systemic biases), the AI will replicate and entrench these inequalities. Another ethical issue is accountability and transparency: if a patient is mis-triaged and suffers harm, is the programmer, the medical trust, or the supervising clinician responsible? Furthermore, 'black box' deep learning models offer low explainability, meaning doctors cannot easily understand why a particular priority level was assigned. Morally, healthcare is built on empathy, compassion, and human connection. An automated system lacks the ability to sense subtle, non-verbal cues of distress or exhibit empathy, which are crucial in a clinical setting. It also risks dehumanizing patient care, making patients feel like numbers in a queue, and could lead to the deskilling of triage nurses whose diagnostic intuition is replaced by algorithms. Legally, the system must comply with data protection legislation, such as the UK Data Protection Act 2018 / GDPR. Triage involves highly sensitive special-category health data, requiring strict encryption, robust access controls, and explicit patient consent. Under GDPR, patients also have the right not to be subject to a decision based solely on automated processing, meaning there must always be a practical mechanism for human review. Additionally, the trust faces complex medical negligence liability issues if the software malfunctions, and potential violations of the Equality Act if the algorithm discriminates against protected characteristics.

Level 3 (8-10 marks): Balanced and mature discussion covering Ethical, Moral, and Legal issues thoroughly in the context of healthcare. Specific legal acts (e.g., GDPR/DPA, Equality Act) and concepts (accountability, algorithmic bias, consent, human oversight) are discussed clearly. Clear, logical line of reasoning. Level 2 (5-7 marks): Covers at least two of the three areas (ethical, moral, legal) with reasonable detail. Some relevant legal/ethical concepts mentioned. Line of reasoning is generally clear. Level 1 (1-4 marks): Simple points or general comments about AI in medicine without clearly distinguishing ethical, moral, or legal factors. Limited technical or legal terminology.

Abstraction simplifies the map by hiding details that are not relevant to navigation. First, the map removes complex visual distractions like building facades, greenery, or altitude variations. Second, the system simplifies the display by rendering only roads, major landmarks, and path directions to help the driver navigate efficiently.

One mark for identifying a detail that is removed (e.g., scenery, buildings). One mark for identifying a detail that is retained or simplified (e.g., road names, path direction).

The execution trace is as follows: puzzle(5) returns 5 * puzzle(3). puzzle(3) returns 3 * puzzle(1). puzzle(1) returns 1. Substituting the values: 5 * 3 * 1 = 15.

One mark for showing the correct recursive substitution steps (e.g., 5 * 3 * 1). One mark for the correct final answer of 15.

First, construct the tree: 12 is the root. 5 is placed to the left of 12. 18 is placed to the right of 12. 2 is placed to the left of 5. 9 is placed to the right of 5. A pre-order traversal visits nodes in the order: Root, Left, Right. Thus, the sequence is: 12, 5, 2, 9, 18.

One mark for correct tree structure or finding the first three nodes (12, 5, 2). One mark for the completely correct sequence: 12, 5, 2, 9, 18.

Each recursive call generates a new stack frame on the call stack, which holds a separate instance of the local variables. This keeps their values isolated. If global variables were used, subsequent recursive calls would overwrite the values, leading to incorrect calculations when unwinding the recursion.

One mark for mentioning that local variables are allocated on the call stack for each individual call level. One mark for explaining that global variables would be overwritten by subsequent calls, corrupting the calculation.

Preconditions define what must be true before a subroutine executes. For this division function, 1) the divisor b must not be zero to avoid a division-by-zero runtime error, and 2) both parameters a and b must be verified as positive integers in line with the specification.

One mark for stating that the divisor cannot be zero (or must be greater than zero). One mark for stating that both parameters must be positive integers / valid numeric types.

Depth-first search traverses as deep as possible down a path. When it encounters a dead end (no unvisited neighbors), it backtracks by popping nodes off the call stack (or recursion stack) until it returns to a node that has remaining unexplored adjacent edges, continuing the search from there.

One mark for identifying that the search retreats/moves backward when a dead end is reached. One mark for stating it goes back to the last node/intersection with unexplored options to continue searching.

At each step, the search space is divided by 2. \(128 = 2^7\). This means there are 7 divisions required to reduce the array to a single element. Testing that final element and verifying success/failure takes at most 8 comparisons in total (or 7 if we only count the split comparisons). Both 7 and 8 are accepted.

One mark for showing correct working of repeated halving or log base 2 calculation (e.g. \(128 \rightarrow 64 \rightarrow 32 \rightarrow 16 \rightarrow 8 \rightarrow 4 \rightarrow 2 \rightarrow 1\) or \(\log_2(128) = 7\)). One mark for stating the correct maximum comparisons of 7 or 8.

Concurrent processing is when a single processor switches rapidly between multiple tasks using time-slicing, giving the illusion that they are running simultaneously. Parallel processing is when multiple processors or cores execute different instructions at the exact same physical instant.

One mark for explaining concurrent processing as interleaving tasks/time-slicing on a single CPU core. One mark for explaining parallel processing as executing tasks simultaneously across multiple CPU cores or processors.

To find the value of puzzle(6):
1. Since 6 is even (6 mod 2 == 0), the function returns 6 + puzzle(5).
2. For puzzle(5), 5 is odd, so it returns 5 * puzzle(3).
3. For puzzle(3), 3 is odd, so it returns 3 * puzzle(1).
4. For puzzle(1), the base case n <= 1 is met, returning 1.

Now we substitute these values back:
- puzzle(3) = 3 * 1 = 3
- puzzle(5) = 5 * 3 = 15
- puzzle(6) = 6 + 15 = 21.

1 mark: Correct intermediate working showing the recursive steps (e.g., showing that puzzle(5) = 15 or showing the expression 6 + (5 * (3 * 1))).
1 mark: Correct final answer of 21.

Preconditions must be satisfied before a subroutine runs to avoid errors. For findAverage(scores):
1. The array must contain at least one element. If the array is empty, dividing the total score by the count of elements (zero) will cause a runtime division-by-zero error.
2. The elements in the array must be of numeric type so that mathematical addition and division operations can be performed without causing a type mismatch error.

1 mark per valid precondition identified (max 2):
- The array scores is not empty / size of scores > 0.
- The array contains only numeric values (integers/reals).
- All mark values are within a valid expected range (e.g., non-negative).

An elegant solution involves initializing a counter variable to 0, looping through the indices of the array from 0 to N-1, checking if the element at the current index is both greater than 0 and divisible by 2 with no remainder, and incrementing the counter if both conditions are met.

Example pseudocode:
count = 0
for i = 0 to N - 1
if (numbers[i] > 0) and (numbers[i] mod 2 == 0) then
count = count + 1
endif
next i

1 mark: Correct loop structure (from 0 to N-1 or equivalent bounds) and initialisation of count to 0.
1 mark: Correct combined condition check (greater than zero AND even) and incrementing the count variable inside the loop.

Concurrent processing allows multiple execution threads to make progress in overlapping periods.
- Benefit: It drastically improves the responsiveness and capacity of the retail platform. Users do not have to wait in a single sequential queue, allowing thousands of orders to be processed simultaneously.
- Drawback: It increases development complexity. Programming must account for concurrency conflicts such as race conditions (e.g., two users purchasing the exact same stock item at the same millisecond) which require record locking mechanisms to avoid data inconsistency.

1 mark for a valid benefit (e.g., faster response times for users, higher throughput, better utilization of multi-core CPU resources).
1 mark for a valid drawback (e.g., more complex to write/debug, risk of race conditions, risk of deadlocks, necessity of introducing resource-locking mechanisms).

We trace the algorithm step-by-step:
- Initially, queue contains [[A, 0]], visited set contains {A}.
- Iteration 1: Dequeue [A, 0]. currentNode = A, distance = 0. Neighbors of A are B, C. Since both are not in visited, they are added to visited. visited = {A, B, C}. queue = [[B, 1], [C, 1]].
- Iteration 2: Dequeue [B, 1]. currentNode = B, distance = 1. Neighbors of B are A, D, E. A is already visited. D and E are not. They are added to visited. visited = {A, B, C, D, E}. queue = [[C, 1], [D, 2], [E, 2]].
- Iteration 3: Dequeue [C, 1]. currentNode = C, distance = 1. Neighbors of C are A, F. A is visited. F is not. F is added to visited. visited = {A, B, C, D, E, F}. queue = [[D, 2], [E, 2], [F, 2]].
- Iteration 4: Dequeue [D, 2]. currentNode = D, distance = 2. Neighbors of D are B (visited). queue = [[E, 2], [F, 2]].
- Iteration 5: Dequeue [E, 2]. currentNode = E, distance = 2. Neighbors of E are B, F (both visited). queue = [[F, 2]].
- Iteration 6: Dequeue [F, 2]. currentNode = F == targetNode. Return distance = 2.

- 1 mark: Correct sequence of dequeued nodes (A, B, C, D, E, F).
- 1 mark: Correct final return value (2).
- 2 marks: Correct visited set at the start of Iteration 3 (A, B, C, D, E). Deduct 1 mark for any missing or extra node.

We trace the recursive steps in order:
1. calc(4, 3):
- Since 4 mod 2 == 0, this returns calc(3, 2) + 2.
2. calc(3, 2):
- Since 3 mod 2 != 0, this returns calc(1, 1) * 3.
3. calc(1, 1):
- Since 1 mod 2 != 0, this returns calc(-1, 0) * 3.
4. calc(-1, 0):
- Since n <= 0 or m <= 0 (where -1 <= 0 and 0 <= 0), this returns n + m = -1 + 0 = -1.

Working back up the recursion tree:
- calc(1, 1) = calc(-1, 0) * 3 = -1 * 3 = -3.
- calc(3, 2) = calc(1, 1) * 3 = -3 * 3 = -9.
- calc(4, 3) = calc(3, 2) + 2 = -9 + 2 = -7.

- 1 mark: Correctly trace calc(-1, 0) = -1.
- 1 mark: Correctly trace calc(1, 1) = -3.
- 1 mark: Correctly trace calc(3, 2) = -9.
- 1 mark: Correctly trace calc(4, 3) = -7.

Let's construct the Binary Search Tree:
1. "M" is the root.
2. "G" < "M" -> left child of "M".
3. "R" > "M" -> right child of "M".
4. "C" < "M", "C" < "G" -> left child of "G".
5. "K" < "M", "K" > "G" -> right child of "G".
6. "P" > "M", "P" < "R" -> left child of "R".
7. "Y" > "M", "Y" > "R" -> right child of "R".

From this tree:
- The parent of "P" is "R".
- The children of "G" are "C" (left) and "K" (right).

Post-order traversal (Left, Right, Root):
- Left subtree of "M" rooted at "G":
- Left child: "C" (visited)
- Right child: "K" (visited)
- Root: "G" (visited)
- Subtree sequence: C, K, G
- Right subtree of "M" rooted at "R":
- Left child: "P" (visited)
- Right child: "Y" (visited)
- Root: "R" (visited)
- Subtree sequence: P, Y, R
- Root of tree: "M" (visited)
- Complete sequence: C, K, G, P, Y, R, M.

- 1 mark: Correctly identifies R as the parent of P.
- 1 mark: Correctly identifies C and K as the left and right children of G.
- 2 marks: Correct post-order traversal sequence: C, K, G, P, Y, R, M (1 mark for a sequence with at most two ordering errors).

We trace the execution step-by-step:
- myArray is passed by reference, so any changes to array within the procedure affect myArray directly.
- idx (value 1) is passed by value, meaning the parameter index gets a copy (value 1) and any changes to index will not affect idx.
- num (value 5) is passed by reference, meaning the parameter val directly references num.

Inside process:
1. val = val + array[index] => val = 5 + myArray[1] = 5 + 20 = 25. Since val is a reference to num, num is updated to 25.
2. array[index] = array[index] * 2 => myArray[1] = 20 * 2 = 40.
3. index = index + 1 => index = 1 + 1 = 2. Since index is passed by value, this change is local to process.

After process finishes:
- num is 25.
- idx remains 1.
- myArray[1] is 40.

- 1 mark: Correct value of num (25).
- 1 mark: Correct value of idx (1).
- 1 mark: Correct value of myArray[1] (40).
- 1 mark: Correct explanation of pass-by-value mechanism preventing modification of the original argument idx.

Let's trace each operation step-by-step:
- Initial state: queue = [Null, Null, Null, Null, Null], head = 0, tail = 0, size = 0
1. enqueue("A"): queue[0] = "A", tail = (0+1)%5 = 1, size = 1
2. enqueue("B"): queue[1] = "B", tail = (1+1)%5 = 2, size = 2
3. enqueue("C"): queue[2] = "C", tail = (2+1)%5 = 3, size = 3
4. dequeue(): item = queue[0] ("A"), queue[0] = Null, head = (0+1)%5 = 1, size = 2
5. enqueue("D"): queue[3] = "D", tail = (3+1)%5 = 4, size = 3
6. enqueue("E"): queue[4] = "E", tail = (4+1)%5 = 0, size = 4
7. dequeue(): item = queue[1] ("B"), queue[1] = Null, head = (1+1)%5 = 2, size = 3
8. enqueue("F"): queue[0] = "F", tail = (0+1)%5 = 1, size = 4

Final queue array: ["F", Null, "C", "D", "E"], head = 2, tail = 1, size = 4.

- 1 mark: Correct final head value (2).
- 1 mark: Correct final tail value (1).
- 2 marks: Correct elements at each index of the array: index 0: "F", index 1: Null (or empty), index 2: "C", index 3: "D", index 4: "E" (deduct 1 mark for any incorrect element).

Let's trace the Insertion Sort:
- Initial: [15, 4, 8, 11, 2]
- Pass 1 (i = 1, key = 4):
Compare with 15. Shift 15 right. Insert 4.
Array: [4, 15, 8, 11, 2]
- Pass 2 (i = 2, key = 8):
Compare with 15. Shift 15. Compare with 4 (no shift). Insert 8.
Array: [4, 8, 15, 11, 2]
- Pass 3 (i = 3, key = 11):
Compare with 15. Shift 15. Compare with 8 (no shift). Insert 11.
Array: [4, 8, 11, 15, 2]
- Pass 4 (i = 4, key = 2):
Compare with 15, 11, 8, 4. Shift all right. Insert 2 at index 0.
Array: [2, 4, 8, 11, 15]

- 1 mark: Correct state after Pass 1 ([4, 15, 8, 11, 2]).
- 1 mark: Correct state after Pass 2 ([4, 8, 15, 11, 2]).
- 1 mark: Correct state after Pass 3 ([4, 8, 11, 15, 2]).
- 1 mark: Correct state after Pass 4 ([2, 4, 8, 11, 15]).

Let's trace the DFS backtracking pathfinder:
- Start at (0,0).
- Try Right: moves to (0,1) (success, open).
- From (0,1), try Right: moves to (0,2) (fails, wall at (0,2)).
- From (0,1), try Down: moves to (1,1) (success, open).
- From (1,1), try Right: moves to (1,2) (success, open).
- From (1,2), try Right: out of bounds (fails).
- From (1,2), try Down: moves to (2,2) (success, target reached!).

The successful path consists of cells: (0,0) -> (0,1) -> (1,1) -> (1,2) -> (2,2).
- The first wall encountered was at (0,2).
- The open cell at (2,0) was never visited because the search found a valid path to the target (2,2) without backtracking to search other directions (such as going down from (0,0), which was blocked by a wall at (1,0) anyway, or backtracking to other start branches).

- 2 marks: Correct coordinates of the path in order. (Deduct 1 mark for any missing/incorrect coordinates).
- 1 mark: Correctly identifies (0,2) as the first wall encountered.
- 1 mark: Explains that (2,0) is not visited because a path to (2,2) is successfully found first, preventing further exploration/backtracking.

We trace the algorithm step-by-step for each case:

Case A:
- Initial: mantissa = "0001", exponent = 3
- Loop Iteration 1:
- firstTwoBits = "00". Since it is not "01" or "10", normalize continues.
- mantissa = shiftLeft("0001") = "0010"
- exponent = 3 - 1 = 2
- Loop Iteration 2:
- firstTwoBits = "00".
- mantissa = shiftLeft("0010") = "0100"
- exponent = 2 - 1 = 1
- Loop Iteration 3:
- firstTwoBits = "01". This matches! Return ["0100", 1].

Case B:
- Initial: mantissa = "1110", exponent = -2
- Loop Iteration 1:
- firstTwoBits = "11". Since it is not "01" or "10", normalize continues.
- mantissa = shiftLeft("1110") = "1100"
- exponent = -2 - 1 = -3
- Loop Iteration 2:
- firstTwoBits = "11".
- mantissa = shiftLeft("1100") = "1000"
- exponent = -3 - 1 = -4
- Loop Iteration 3:
- firstTwoBits = "10". This matches! Return ["1000", -4].

- 2 marks: Case A (1 mark for showing intermediate mantissa "0010" / exponent 2; 1 mark for correct final output ["0100", 1]).
- 2 marks: Case B (1 mark for showing intermediate mantissa "1100" / exponent -3; 1 mark for correct final output ["1000", -4]).

We trace each step of the recursive calls:
- Initial Call: `crunch(8, 2)`. Because 8 is not <= 0 and 8 % 3 != 0, we call `crunch(8 - 1, 2 * 2)` which evaluates to `crunch(7, 4)`.
- First recursive call: `crunch(7, 4)`. Because 7 % 3 != 0, we call `crunch(7 - 1, 4 * 2)` which evaluates to `crunch(6, 8)`.
- Second recursive call: `crunch(6, 8)`. Since 6 % 3 == 0, we call `crunch(6 - 3, 8 + 2)` which evaluates to `crunch(3, 10)`.
- Third recursive call: `crunch(3, 10)`. Since 3 % 3 == 0, we call `crunch(3 - 3, 10 + 2)` which evaluates to `crunch(0, 12)`.
- Fourth recursive call: `crunch(0, 12)`. Since 0 <= 0, this returns `k` which is 12.

The progression is `crunch(7, 4)` -> `crunch(6, 8)` -> `crunch(3, 10)` -> `crunch(0, 12)` which eventually returns 12.

1 Mark: Identifies the first recursive call `crunch(7, 4)` (or shows parameter values 7 and 4).
1 Mark: Identifies the second recursive call `crunch(6, 8)`.
1 Mark: Identifies both subsequent recursive calls: `crunch(3, 10)` and `crunch(0, 12)` in order.
1 Mark: States the correct final returned value of 12.

A single pass of Bubble Sort compares adjacent items starting from the beginning of the array.

We loop from index 0 up to \(n-2\) because we compare `items[i]` with the adjacent element `items[i+1]`. Stopping at \(n-2\) prevents an index-out-of-bounds error.

Inside the loop, we check if `items[i] > items[i+1]`. If so, we perform a standard swap operation utilizing a temporary variable (`temp`) to store one of the values so it is not overwritten.

1 Mark: Correct loop boundaries that visit all adjacent elements without exceeding array limits (e.g., from 0 to \(n-2\) or 1 to \(n-1\)).
1 Mark: Correct comparison of adjacent items (e.g., `items[i] > items[i+1]` or equivalent logic based on loop variable).
1 Mark: Use of a temporary variable to hold one of the values during the swap sequence.
1 Mark: Correct assignment of both swapped elements to complete the swap sequence safely.

### 1. Search Strategies and Traversal
- **Breadth-First Search (BFS)**: Explores the grid level-by-level, starting from the source node (charging station) and visiting all immediate neighbors before moving to the neighbors' neighbors. Visually, this looks like a ripple expanding outwards across the grid.
- **Depth-First Search (DFS)**: Explores a single path as deeply as possible, moving from neighbor to neighbor until a dead-end or obstacle is met, then backtracking to the last node with unexplored branches. Visually, this is a single winding line probing deep into the grid.

### 2. Underlying Data Structures
- **BFS** relies on a **Queue** (First-In, First-Out / FIFO) structure. Discovered nodes are appended to the back, and the next node to explore is dequeued from the front.
- **DFS** relies on a **Stack** (Last-In, First-Out / LIFO) structure. Nodes are pushed onto the stack as they are discovered and popped off to be explored. This can be implemented explicitly using a stack structure or implicitly using the call stack via a recursive function.
- Both algorithms also require a data structure (such as a 2D array of booleans or a hash set) to track 'visited' nodes to prevent infinite loops in grids with cycles.

### 3. Time and Space Complexities
- **Time Complexity**: Both algorithms have a worst-case time complexity of \(O(V + E)\), where \(V\) is the number of open grid cells (vertices) and \(E\) is the number of possible directional movements between adjacent cells (edges). In a dense grid, \(E \approx 4V\).
- **Space Complexity**:
- BFS: \(O(V)\) in the worst case, as the queue must store the 'frontier' of the expanding wave. In an open grid layout, the frontier grows proportionally to the perimeter of the search space.
- DFS: \(O(V)\) in the worst case (e.g., a single long winding corridor with no branches). However, on average, the call stack size is limited to the maximum depth of the search path.

### 4. Shortest Path Guarantee & Warehouse Application
- **BFS** guarantees finding the shortest path (fewest cells) in an unweighted grid because it explores nodes in order of their distance from the source. This is crucial for a warehouse robot to minimize travel time and battery usage.
- **DFS** does not guarantee the shortest path. It will return the first path it finds to the target, which could be extremely long and convoluted, making it highly inefficient for warehouse operation.

### Level 3 (9 - 10.5 Marks)
- Comprehensive comparison of both search strategies and visual patterns.
- Correctly identifies and details the Queue (FIFO) for BFS and Stack (LIFO) / recursion for DFS, noting the necessity of tracking visited states.
- Accurately analyzes the time \(O(V + E)\) and space complexities of both algorithms, relating them directly to grid characteristics.
- Provides a clear and definitive argument for why BFS guarantees the shortest path whereas DFS does not, and links this to the practical performance of the warehouse robot.
- Logic is coherent, well-structured, and rich in technical vocabulary.

### Level 2 (5 - 8 Marks)
- Good comparison of DFS and BFS, though some aspects (like visited tracking or specific visual descriptions) may be brief.
- Correctly maps algorithms to Stack and Queue structures.
- Identifies the basic complexities, although the distinction in space complexity behavior in grids may lack depth.
- Clearly states that BFS guarantees the shortest path while DFS does not, with some application to the warehouse context.
- Structured and generally fluent, with minor omissions in detail.

### Level 1 (1 - 4 Marks)
- Basic identification of the two algorithms and their traversal mechanisms.
- May confuse the underlying data structures or fail to mention the visited list.
- Mentions complexities with errors, or provides a superficial comparison.
- Weak or missing link to the warehouse robot scenario.
- Lacks structure and relies on highly generalized descriptions.

### 0 Marks
- No creditworthy response provided.

### 1. Application of Concurrency to Merge Sort
Merge Sort is inherently suited to concurrent execution due to its divide-and-conquer nature. In a sequential implementation, the array is split, the left half is recursively sorted, then the right half, and finally, they are merged. In a concurrent implementation:
- The sorting of the left and right halves can be spawned as independent parallel threads running concurrently on separate CPU cores.
- This parallel division can continue recursively down the tree.
- A threshold (or 'cutoff') is typically set: when a sub-array becomes small enough, the algorithm switches to sequential merge sort (or insertion sort) to prevent thread-creation overhead from outweighing the performance gains.

### 2. Hardware and Software Mechanisms
- **Hardware**: Requires a multi-core or multi-processor architecture to achieve true physical parallelism. On single-core systems, concurrency is simulated via time-slicing, which would actually degrade sorting performance due to context-switching overhead.
- **Software**: A thread-scheduler (within the OS or runtime environment) maps threads to physical CPU cores. High-level frameworks like Fork/Join pools are often used to manage a fixed set of worker threads, avoiding the heavy cost of repeatedly creating and destroying OS-level threads.

### 3. Synchronization Issues, Hazards, and Mitigation
- **Race Conditions**: Occur when multiple threads attempt to access and modify the same memory location simultaneously. In Merge Sort, if threads write to shared indices of a target array or use shared counters without synchronization, the output will be corrupted. Mitigation: Threads must operate on strictly non-overlapping slices of memory, or access must be controlled using locks/semaphores.
- **Deadlocks**: Can occur if threads are blocked waiting for locks held by other threads. Mitigation: A fork-join design minimizes locks by keeping threads isolated to their own memory segments, only synchronizing at defined 'join' barrier points where a parent thread waits for child threads to complete.
- **Resource Exhaustion**: Creating too many threads can exhaust system memory. Mitigation: Implement a thread pool to limit the maximum number of concurrent active threads.

### 4. Amdahl's Law and Speedup Limits
Amdahl's Law calculates the maximum theoretical speedup \(S_{\text{latency}}\) of a program using \(N\) processors:
\[S_{\text{latency}}(s) = \frac{1}{(1-p) + \frac{p}{s}}\]
where \(p\) is the proportion of execution time that can be parallelized, and \(s\) is the speedup factor of that portion (e.g., the number of cores \(N\)).
- In parallel Merge Sort, the merging phase at the very top of the recursion tree requires merging two fully sorted halves. This final step is inherently sequential and must process all \(n\) elements. This sequential bottleneck represents the \(1-p\) component.
- As the number of processor cores approaches infinity, the execution time approaches the sequential merge bottleneck. Thus, Amdahl's Law proves that the algorithm cannot achieve linear speedup, and the benefits of adding more cores diminish rapidly.

### Level 3 (9 - 10.5 Marks)
- Clearly explains how Merge Sort's divide-and-conquer strategy naturally translates to concurrent execution, detailing recursion and thread-cutoff thresholds.
- Discusses multi-core hardware requirements, OS-level scheduling, and software-level fork/join or thread pool abstractions.
- Demonstrates deep understanding of concurrency hazards, correctly explaining race conditions and deadlocks, with explicit, valid mitigation strategies (e.g., thread isolation, join barriers, locks).
- Accurately details Amdahl's Law (including its mathematical formula/logic) and applies it to Merge Sort, identifying the final sequential merge phase as the key bottleneck.
- Writing is coherent, logically structured, and presents sophisticated technical terminology throughout.

### Level 2 (5 - 8 Marks)
- Explains the concept of splitting the sorting work into parallel threads.
- Mentions hardware/software requirements such as multi-core CPUs and basic thread management.
- Identifies race conditions and deadlocks, offering general mitigation methods.
- Mentions Amdahl's Law and notes that speedup is limited by sequential portions of the code, though the connection to the final merge step or the mathematical representation may be slightly hand-waved.
- Good structure with mostly accurate technical terms.

### Level 1 (1 - 4 Marks)
- Basic description of concurrent processing (e.g., doing things at the same time).
- Mentions threads but lacks clarity on how Merge Sort is parallelized.
- Mentions race conditions or deadlocks without clear definitions or solutions.
- Superficial or no mention of Amdahl's Law and its limitations.
- Unstructured, relying on high-level general knowledge without technical depth.

### 0 Marks
- No creditworthy response provided.

The class DeliveryVehicle is declared with three private attributes: vehicleID, maxPayload, and currentPayload. The constructor initializes these fields, setting currentPayload to 0.0. Getter methods are provided to access the private fields. The loadPackage method checks if adding the weight would exceed maxPayload; if not, it updates currentPayload and returns true, otherwise it returns false.

1 mark: Declaring class DeliveryVehicle with correct private attributes. 1 mark: Constructor correctly initialising attributes and setting currentPayload to 0.0. 1 mark: Implementation of all three getter methods returning correct attributes. 1 mark: loadPackage checking boundary condition correctly (currentPayload + weight <= maxPayload). 1 mark: loadPackage updating currentPayload and returning true/false correctly.

The class Drone is declared as inheriting from DeliveryVehicle. It contains the additional private attributes maxAltitude and batteryLevel. The constructor calls the superclass constructor first, then sets maxAltitude and batteryLevel. The flyTo method checks both the altitude limit and the battery threshold before returning true or false.

1 mark: Class header showing correct inheritance (inherits DeliveryVehicle). 1 mark: Correct private attributes declared. 1 mark: Constructor correctly calling parent constructor with super.new(id, maxLoad). 1 mark: Constructor setting maxAltitude and batteryLevel to 100.0. 1 mark: flyTo function correctly implementing the compound boolean check and returning true/false.

The subclass ElectricVan inherits from DeliveryVehicle. It initializes hasDriver to true and sets up a routeDestinations array of size 10 with empty strings. The addDestination method loops through the array, finding the first index where the value is empty, assigning the town, and returning true immediately. If the loop completes, it means the list is full, so it returns false.

1 mark: Correct class header indicating inheritance and declaring private attributes. 1 mark: Constructor calling parent constructor with correct parameters. 1 mark: Initializing hasDriver to true and routeDestinations to an array of 10 empty strings. 1 mark: addDestination method using a loop (0 to 9) to check elements. 1 mark: Correctly setting element to town and returning true, or returning false if full.

The overridden unloadAll() function first updates the subclass's batteryLevel attribute, preventing it from going below 0.0 using an if condition. It then calls the superclass method using super.unloadAll() to perform the standard unloading tasks and capture the weight, which it then returns.

1 mark: Correct method signature inside Drone context. 1 mark: Correctly subtracting 5.0 from batteryLevel. 1 mark: Ensuring batteryLevel does not drop below 0.0. 1 mark: Correctly calling super.unloadAll() or parent.unloadAll(). 1 mark: Returning the value retrieved from the parent call.

The function initializes an accumulator totalFree to 0.0. It loops through indices 0 to 49 of the fleet array. It checks if fleet[i] is not null to avoid a null pointer error. For each active vehicle, it calculates the remaining capacity using its getter methods and adds this to totalFree. Finally, it returns the accumulated total.

1 mark: Initialising total accumulation variable to 0.0. 1 mark: Loop correctly covering indices 0 to 49. 1 mark: Checking fleet[i] != null before accessing methods. 1 mark: Correctly calling getMaxPayload() and getCurrentPayload() and calculating the difference. 1 mark: Accumulating and returning the correct total.

The findSuitableVehicle method initializes bestIndex to -1 and bestCapacity to a very large number (sentinel). It loops through the fleet array, ignoring null elements. For each active vehicle, it calculates its free capacity. If this free capacity can hold the weight (freeCap >= weight) and is smaller than the bestCapacity found so far, it updates bestCapacity and records the current index. It returns bestIndex at the end.

1 mark: Initialising bestIndex to -1 and a bestCapacity variable to a large default value. 1 mark: Correct loop structure with null checks. 1 mark: Calculating free capacity and verifying if it is >= weight. 1 mark: Checking if the free capacity is strictly less than the currently recorded bestCapacity. 1 mark: Correctly updating tracking variables and returning the final index.

1.
- [ BLANK 1 ] must check if the tree is currently empty so the root can be initialized: root == null.
- [ BLANK 2 ] must check if the current node does not have a left child before attaching the new child node: currentNode.left == null.

2. Bug A calls the recursive routine insertNode by passing the root of the BST instead of the left child (currentNode.left). This resets the traversal to the top of the tree, causing infinite recursion. The correct statement is: insertNode(currentNode.left, newValue).

3. Bug B check is inverted. By checking if the right child is NOT null (currentNode.right != null) before creating a new node, the code incorrectly overwrites the right child if it exists. If it does not exist, it runs the 'else' branch and tries to call insertNode on a null object, crashing the application. The comparison operator must be corrected to == null.

1 mark: Completing [ BLANK 1 ] as root == null (or equivalent null check).
1 mark: Completing [ BLANK 2 ] as currentNode.left == null (or equivalent null check).
1 mark: Explaining that Bug A causes infinite recursion because the function repeatedly resets the search to the root.
1 mark: Correcting Bug A to insertNode(currentNode.left, newValue).
1 mark: Correcting Bug B to currentNode.right == null (or equivalent) and explaining that the original code overwrites existing nodes or causes a crash.

1.
- [ BLANK A ] must initialize the index j to point to the element immediately before i: i - 1.
- [ BLANK B ] must check if the element at index j is larger than the key value we are positioning, to trigger the shift: arr[j] > key.
- [ BLANK C ] must assign the key value back to its final inserted position: arr[j + 1].

2. Bug 1: In insertion sort, we decrement j to traverse backwards through the sorted sub-array. Incrementing j (j = j + 1) will keep the loop running indefinitely or raise an Index Out of Bounds exception. The corrected line is: j = j - 1.

3. If the loop stops when j > 0, the element at index 0 (arr[0]) is never compared. This means if a new value is smaller than every sorted item, the shift stops early and the value is erroneously placed at index 1 instead of index 0.

1 mark: Correctly completing [ BLANK A ] as i - 1.
1 mark: Correctly completing [ BLANK B ] as arr[j] > key.
1 mark: Correctly completing [ BLANK C ] as arr[j + 1].
1 mark: Identifying and correcting Bug 1 to j = j - 1, explaining that incrementing j causes an infinite loop or index out of bounds error.
1 mark: Explaining that changing j >= 0 to j > 0 prevents the item at index 0 from being checked, resulting in an unsorted array if the key is the minimum element.

### Detailed Solution

#### 1. Inheritance vs. Composition Analysis
* **Inheritance (IS-A relationship):**
* `ForkliftAGV` and `TowingAGV` inherit from a base `AGV` class.
* *Advantages:* Avoids code duplication for shared attributes (ID, battery charge, position). Easy to set up initially.
* *Disadvantages:* Rigid hierarchy. If a hybrid AGV is created that can both lift and tow, multiple inheritance (which is not supported in many languages) or duplicate code is required. It also breaks encapsulation to some extent because subclasses are highly dependent on the base class implementation details (fragile base class problem).
* **Composition (HAS-A relationship):**
* A generic `AGV` class contains instances of behavior components (e.g., an optional `LiftAbility` reference and `TowAbility` reference).
* *Advantages:* Exceptional flexibility. Behaviors can be added, removed, or changed at runtime. Stronger encapsulation as components are completely decoupled and self-contained.
* *Disadvantages:* More complex design initially; requires writing delegate methods inside the container class to call component methods.

#### 2. Polymorphism
* Polymorphism allows a collection (e.g., an array or list) of the base class type `AGV` to store instances of `ForkliftAGV` and `TowingAGV` seamlessly.
* During the system update loop, the main program can iterate through the list and call `.update()` on each object. The program does not need to know the specific subclass type; the correct overridden method is resolved dynamically at runtime.

#### 3. High-Level OOP Pseudocode (Inheritance Approach Example)
```
class AGV
private id
private batteryCharge
private position

public constructor(newId, startPos)
id = newId
batteryCharge = 100
position = startPos
endconstructor

public procedure update()
batteryCharge = batteryCharge - 1
endprocedure
endclass

class ForkliftAGV inherits AGV
private maxLiftHeight

public constructor(newId, startPos, height)
super(newId, startPos)
maxLiftHeight = height
endconstructor

public override procedure update()
super.update()
// Forklift-specific pathfinding/lift checking
endprocedure
endclass

// Polymorphic Update Loop
class WarehouseController
private agvList = []

public procedure updateAll()
for i = 0 to agvList.length - 1
agvList[i].update()
next i
endprocedure
endclass
```

This question is marked using a levels-of-response grid:

### Level 3 (7-9 Marks)
* **Detailed & Accurate Comparison:** Detailed comparison of inheritance vs. composition in this scenario, referencing specific challenges (e.g., hybrid AGVs, fragile base class, dynamic behavior adjustment).
* **Polymorphism & Encapsulation:** Clear explanation of how polymorphism allows a single collection to handle multiple AGV types, and how encapsulation is affected by both designs.
* **Pseudocode:** Correct, logically sound pseudocode that defines a base/subclass or component structure, including a working update loop demonstrating polymorphism or composition delegation.

### Level 2 (4-6 Marks)
* **Sound Comparison:** Sound understanding of both paradigms with some attempt to apply them to the AGV scenario.
* **Polymorphism & Encapsulation:** Explanation of either polymorphism or encapsulation with minor omissions.
* **Pseudocode:** Mostly correct pseudocode with minor syntax or logical errors, but showing the overall structural layout.

### Level 1 (1-3 Marks)
* **Basic Understanding:** Identifies basic definitions of inheritance and/or composition but with limited comparison.
* **Polymorphism & Encapsulation:** Lacks depth or contains significant errors regarding polymorphism/encapsulation.
* **Pseudocode:** Incomplete, absent, or heavily flawed pseudocode.