MetadataPastPaper.sampleTitle

The term \(\overline{A \cdot B}\) represents a NAND operation on inputs A and B, which corresponds to Gate 1. The \(\oplus\) symbol represents an exclusive-OR (XOR) operation between the output of Gate 1 and C, which corresponds to Gate 2.

0.5 marks for correctly identifying Gate 1 as NAND (or NOT AND). 1.0 mark for correctly identifying Gate 2 as XOR (or EOR / Exclusive OR).

The output of the NOT gate is \(\overline{Q}\). This and P are inputs to a NOR gate, giving the boolean expression \(Y = \overline{P + \overline{Q}}\). Substituting P = 0 and Q = 0 gives \(\overline{0 + \overline{0}} = \overline{0 + 1} = \overline{1} = 0\).

0.5 marks for the correct boolean expression (accept equivalents such as \(\overline{P} \cdot Q\)). 1.0 mark for the correct output value of 0.

To store user preferences in an embedded device like a smart refrigerator, the storage medium must satisfy two conditions: it must retain data when power is disconnected (non-volatile), and it must allow the data to be modified when the user changes their preferences (writeable). RAM is volatile, meaning it loses all stored data when the refrigerator is powered off or unplugged, making it unsuitable. Traditional ROM is non-volatile but is read-only; its contents are hardcoded during manufacture and cannot be altered by the user. EEPROM combines both necessary characteristics: it is non-volatile (retaining settings without power) and electrically erasable/re-programmable, allowing the controller to write new temperature settings whenever the user modifies them.

1 mark: Explaining that RAM is volatile and would lose the user preferences when the refrigerator is powered down or unplugged. 1 mark: Explaining that traditional ROM is read-only / immutable and therefore cannot be updated with new user preferences. 1 mark: Explaining that EEPROM is non-volatile, ensuring settings are retained without power. 1 mark: Explaining that EEPROM can be written to/reprogrammed electronically, allowing user updates to be saved.

A Solid-State Drive (SSD) is far superior to a Magnetic Hard Disk Drive (HDD) for this specific deployment. HDDs contain spinning magnetic platters and moving read/write heads. In an environment with heavy vibrations, these heads can crash onto the platters, causing physical damage and data loss. SSDs use flash memory and have no moving parts, making them robust against shock and vibration. Additionally, remote stations rely on limited power sources (like solar panels or batteries); SSDs require less power because they do not have to drive an electric motor to spin platters. Finally, the mechanical components and lubricants in HDDs can fail or seize up in extreme cold, whereas silicon-based flash memory operates reliably in a much wider temperature range.

1 mark: Correctly identifying SSD as the suitable medium. 1 mark: Identifying that SSDs have no moving parts, making them highly resistant to physical vibration/shock. 1 mark: Identifying that SSDs consume less power, which is critical for remote/solar-powered operation. 1 mark: Identifying that SSDs are more reliable in extreme cold because they lack mechanical parts/lubricants that can fail.

When capturing a rapid burst of high-resolution images, the volume of data produced is extremely large and generated too quickly for the SD card's write speeds. RAM, being high-speed primary storage, acts as a temporary buffer. The camera's sensor dumps the raw image data directly into the RAM buffer almost instantaneously, ensuring the user can continue taking photos without lag. Once the burst is complete, the camera's controller gradually reads the image data from the volatile RAM, processes/compresses it, and writes it to the SD card. The SD card is non-volatile flash memory, which ensures the photos are permanently stored and will not be lost when the camera is powered down.

1 mark: Explaining that RAM acts as a temporary buffer to temporarily hold the captured image data. 1 mark: Explaining that RAM is used because its write speeds are much faster than those of the SD card, preventing lag during capture. 1 mark: Explaining that the SD card is non-volatile secondary storage. 1 mark: Explaining that the SD card's role is to permanently save the files from the RAM buffer so they survive power-off states.

In NAND flash memory, the storage is organized into pages (typically 4KB) which are grouped into larger blocks (typically 256KB or 512KB). While the controller can read and write data to individual pages, it cannot overwrite an existing page directly because flash memory cells must be erased before they can be rewritten. Crucially, erasure can only be performed on entire blocks, not individual pages. To update a single page of data, the SSD must perform a 'read-erase-modify-write' cycle: it reads all pages in the block containing the target page into RAM, erases the entire physical block on the flash chip, modifies the target page in RAM, and then writes the entire block back to the flash memory. This causes 'write amplification', meaning more data is physically written than was requested. Because floating-gate transistors in NAND flash degrade physically with each write/erase cycle, this process accelerates wear and reduces the drive's write endurance (lifespan).

1 mark: Explaining that read/write operations occur at the page level, but erase operations can only occur at the block level. 1 mark: Describing the process: the block containing the data must be read to RAM, the physical block erased, and the modified data written back. 1 mark: Explaining the concept of write amplification (writing more data than requested). 1 mark: Linking this repetitive erase/write process to the physical degradation of flash memory cells, which reduces the drive's overall lifespan.

A magnetic HDD is vastly superior to optical storage for continuous 24/7 video surveillance for three key reasons: First, data throughput. Recording 8 continuous high-definition video feeds requires high write speeds and random access performance to handle concurrent writes; optical drives have low write speeds and long seek times, which would cause buffer overflows. Second, storage capacity. HD footage from 8 cameras generates hundreds of gigabytes daily. A single HDD can easily store 8TB to 18TB of data, whereas a standard Blu-ray disc stores only 25GB to 50GB, requiring impractical constant disc-swapping. Third, durability and automation. Security systems use loop-recording where the oldest footage is continuously overwritten. HDDs handle millions of write cycles seamlessly, whereas rewritable optical discs wear out rapidly after a few thousand cycles and cannot be managed as automated, maintenance-free storage pools.

1 mark: Explaining that HDDs have much faster write speeds and higher data transfer rates to handle multiple simultaneous HD video streams. 1 mark: Explaining that HDDs provide much larger storage capacities (terabytes) needed for massive quantities of continuous footage. 1 mark: Explaining that HDDs allow seamless, automated circular overwriting of old data and have higher write endurance than rewritable optical discs, which require physical replacement or wear out quickly.

During the development phase, an interpreter is highly advantageous because: 1. It translates and executes code line-by-line. If a runtime error is encountered, execution stops immediately at that line, allowing the programmer to identify the exact location of the bug. 2. There is no need to compile the entire source code into machine code before running it. This saves time and allows the developer to test small, incremental changes instantly.

Award up to 2.5 marks: - 1 mark: For explaining that errors are reported immediately / execution stops at the error line (making debugging easier). - 1 mark: For explaining that there is no need to wait for a complete compilation process to run/test the program (faster development cycle). - 0.5 marks: For explicitly contrasting this with a compiler (e.g., noting that a compiler requires compiling the entire program before execution or does not pinpoint the runtime execution point as easily).

For commercial distribution, a compiler is preferred because: 1. It translates the entire high-level code into an independent executable machine code file. The user does not need to have the translator software installed on their system to run the program. 2. Since the source code is not distributed, the company's intellectual property is protected against unauthorized copying, modification, or reverse engineering. 3. The program runs much faster because the translation process has already been completed; it does not need to be translated line-by-line at runtime.

Award up to 2.5 marks: - 1 mark: For identifying that the source code is protected / not distributed, preventing unauthorized modification/theft. - 1 mark: For identifying that execution is faster (no runtime translation) or that the user does not need the translator/interpreter installed to run it. - 0.5 marks: For a clear comparative point highlighting the corresponding drawback of using an interpreter (e.g., an interpreter requires the source code to be shared, or requires the user to install the interpreter).

Let's trace the execution of the program step-by-step:
1. LDD 100: Loads the direct value from address 100 (which is 5) into the Accumulator. (ACC = 5)
2. ADD 101: Adds the value at address 101 (which is 12) to the Accumulator. (ACC = 5 + 12 = 17)
3. STO 102: Stores the current value of the Accumulator into memory address 102. (Address 102 = 17)
4. LDX 100: Uses indexed addressing. The effective address is calculated as the operand plus the contents of the Index Register: 100 + IX = 100 + 5 = 105. The value at memory address 105 (which is 20) is loaded into the Accumulator. (ACC = 20)
5. INC IX: Increments the Index Register by 1. (IX = 6)
6. DEC ACC: Decrements the Accumulator by 1. (ACC = 19)
7. STO 103: Stores the current value of the Accumulator into memory address 103. (Address 103 = 19)
8. END: The program terminates.

Final values:
ACC = 19
IX = 6
Address 102 = 17
Address 103 = 19

- 1.0 mark: Correct final value of Memory address 102 (17).
- 1.0 mark: Correct final value of Memory address 103 (19).
- 0.5 marks: Correct final value of ACC (19).
- 0.5 marks: Correct final value of IX (6).
- 0.5 marks: Clear working showing the correct calculation of the indexed address (100 + 5 = 105) for the LDX instruction.

Let's trace the loop execution step-by-step:

First Iteration:
1. LDD 120: Loads the value from address 120 (0) into the Accumulator. (ACC = 0)
2. ADD #10: Adds the immediate value 10 to ACC. (ACC = 10)
3. STO 120: Stores 10 in memory address 120. (Address 120 = 10)
4. LDD 121: Loads the value from address 121 (2) into ACC. (ACC = 2)
5. SUB #1: Subtracts immediate value 1 from ACC. (ACC = 1)
6. STO 121: Stores 1 in memory address 121. (Address 121 = 1)
7. CMP #0: Compares ACC (1) with 0. The comparison result is not equal.
8. JPN LOOP: Jumps back to LOOP because the last comparison was not equal.

Second Iteration:
1. LDD 120: Loads the value from address 120 (10) into ACC. (ACC = 10)
2. ADD #10: Adds immediate value 10 to ACC. (ACC = 20)
3. STO 120: Stores 20 in memory address 120. (Address 120 = 20)
4. LDD 121: Loads the value from address 121 (1) into ACC. (ACC = 1)
5. SUB #1: Subtracts immediate value 1 from ACC. (ACC = 0)
6. STO 121: Stores 0 in memory address 121. (Address 121 = 0)
7. CMP #0: Compares ACC (0) with 0. The comparison result is equal.
8. JPN LOOP: Does not jump because the last comparison was equal.
9. END: The program terminates.

Final values:
ACC = 0
Address 120 = 20
Address 121 = 0

- 1.0 mark: Correct final value of Memory address 120 (20) with intermediate working showing it reached 10.
- 1.0 mark: Correct final value of Memory address 121 (0) with intermediate working showing it reached 1.
- 0.5 marks: Correct final value of ACC (0) at termination.
- 1.0 mark: Demonstrates clear understanding of the CMP and JPN instruction logic (correctly jumping once and exiting on the second comparison).

Symmetric encryption uses a single shared key to both encrypt and decrypt data. Its main advantage is computational efficiency, making it very fast and suitable for high-volume transactions. However, its primary drawback is the key distribution problem: the key must be shared securely beforehand. Asymmetric encryption uses a public key for encryption and a private key for decryption. While it solves the key sharing issue, it is highly resource-intensive and slow, making it impractical for continuous high-volume streams. Therefore, the standard evaluation is to use a hybrid approach (such as SSL/TLS), where asymmetric encryption is used initially to securely agree upon a symmetric key, which is then used for the actual high-volume data transmission.

Award 1 mark per valid point, up to a maximum of 4 marks. Max 2 marks for symmetric evaluation, max 2 marks for asymmetric evaluation, and 1 mark for the synthesis/hybrid conclusion. [1 mark] Symmetric encryption is fast and computationally efficient, making it ideal for high volumes of data. [1 mark] Symmetric encryption has a key distribution security risk (the key must be shared securely). [1 mark] Asymmetric encryption is slow and resource-heavy, making it poor for encrypting raw high-volume data. [1 mark] Asymmetric encryption resolves key exchange risks since the private key is never transmitted. [1 mark] Best practice/hybrid solution uses asymmetric encryption to exchange a symmetric session key.

The firewall and proxy server perform complementary roles. The firewall sits at the boundary of the school's network. It inspects incoming and outgoing IP packets and compares them against security policies. It blocks unauthorized access attempts from external networks (e.g., hacker scans or malicious traffic on closed ports). The proxy server, on the other hand, acts as an intermediary between the internal client computers and the internet. It masks internal IP addresses to provide anonymity. Crucially, it inspects application-layer web requests, comparing requested URLs against a blacklist of inappropriate websites and blocking access. It also caches frequently visited safe websites to reduce bandwidth usage.

Award 1 mark for each clear point up to 4 marks. [1 mark] Firewall monitors/filters incoming and outgoing network traffic based on rules. [1 mark] Firewall prevents unauthorized external users/hackers from accessing the internal network. [1 mark] Proxy server acts as an intermediary, hiding internal IP addresses from the public internet. [1 mark] Proxy server filters outbound requests by checking URLs against blacklists of inappropriate websites.

To create a digital signature, the sender first inputs the digital contract into a cryptographic hash algorithm to produce a unique message digest. The sender then encrypts this digest using their private key; this encrypted digest is the digital signature. Upon receiving the email, the recipient decrypts the digital signature using the sender's public key to retrieve the original digest. This proves authenticity (non-repudiation) because only the owner of the matching private key could have encrypted it. The recipient then runs the received contract through the same hash algorithm to produce a new digest. If this new digest matches the decrypted digest, it proves integrity (the contract has not been modified during transmission).

Award 1 mark for each point up to 4 marks. [1 mark] Sender hashes the contract to generate a unique digest. [1 mark] Sender encrypts this digest with their private key to create the signature. [1 mark] Recipient decrypts the signature using the sender's public key (proving authenticity). [1 mark] Recipient hashes the document and compares the hashes; a match proves no alteration (integrity).

A single-byte parity check (even or odd) adds a single parity bit to a byte. It is highly limited because if an even number of bits flip (e.g., two bits change from 0 to 1) within the same byte, the parity remains unchanged, and the error goes undetected. It is only reliable for detecting a single bit flip. In contrast, a checksum is calculated by summing the binary values of all the bytes in a transmission block and appending the result. The receiver performs the same calculation on the block. A checksum is far more robust because it is highly unlikely that multiple arbitrary bit flips or transposition errors (where data is swapped) will result in the same mathematical sum, making checksums significantly more effective for noisy networks.

Award 1 mark for each point up to 4 marks. [1 mark] Parity check only successfully detects an odd number of bit errors (or a single bit flip). [1 mark] Parity check fails to detect errors if an even number of bits flip in the same byte. [1 mark] Checksum sums all the bytes in a block and transmits the value. [1 mark] Checksum is highly likely to detect multiple bit errors and byte transpositions across the entire block, making it superior for noisy environments.

To transition from UNF to 1NF: 1. Identify and remove the repeating group (BookID, BookTitle, DateBorrowed, DateDue). 2. Create a separate relation for the repeating group's attributes. 3. Form a composite primary key in the new relation by combining the primary key of the original relation (MemberID) with one or more fields from the repeating group to uniquely identify each row (BookID and DateBorrowed). 4. The original relation retains its primary key (MemberID) and non-repeating attributes. Schemas: MEMBER(MemberID, MemberName) Primary Key: MemberID. LOAN(MemberID, BookID, DateBorrowed, BookTitle, DateDue) Primary Key: (MemberID, BookID, DateBorrowed).

1.25 marks: Explanation of removing the repeating group and creating a separate table. 1.25 marks: Defining the correct tables: MEMBER and LOAN with correct fields. 1.25 marks: Correctly identifying MemberID as the primary key for MEMBER, and (MemberID, BookID, DateBorrowed) as the composite primary key for LOAN.

The query requires: 1. SELECT clause with CourierID and the aggregate function SUM(DeliveryFee). 2. FROM clause specifying the DELIVERY table. 3. WHERE clause to filter individual rows where DeliveryStatus is 'Completed' before grouping. 4. GROUP BY clause to aggregate by CourierID. 5. HAVING clause to filter the grouped results where the aggregated sum is greater than 500. Code: SELECT CourierID, SUM(DeliveryFee) FROM DELIVERY WHERE DeliveryStatus = 'Completed' GROUP BY CourierID HAVING SUM(DeliveryFee) > 500;

1.00 mark: SELECT CourierID, SUM(DeliveryFee) FROM DELIVERY. 1.00 mark: WHERE DeliveryStatus = 'Completed'. 1.00 mark: GROUP BY CourierID. 0.75 marks: HAVING SUM(DeliveryFee) > 500.

(a) Referential integrity is a system of rules that ensures relationships between records in related tables are valid and that users do not accidentally delete or change related data. (b) CustomerID in the ORDER table acts as a Foreign Key because it refers to the primary key CustomerID in the CUSTOMER table. (c) An index created on a non-primary key field like PostCode to speed up data retrieval is known as a Secondary Key.

1.25 marks: (a) Referential integrity (Accept: referential integrity rule). 1.25 marks: (b) Foreign key (Accept: FK). 1.25 marks: (c) Secondary key (Accept: secondary index).

Explanation: A table is in 3NF if it is in 2NF and contains no transitive dependencies (where a non-key attribute depends on another non-key attribute). In PET_TREATMENT, PetName depends on PetID, and TreatmentDescription depends on TreatmentCode. Since PetID and TreatmentCode are not candidate keys of the table, these represent transitive dependencies, violating 3NF. Conversion: We remove these dependencies by creating separate tables. 1. PET(PetID, PetName) where PetID is the Primary Key. 2. TREATMENT(TreatmentCode, TreatmentDescription) where TreatmentCode is the Primary Key. 3. PET_TREATMENT(TreatmentID, PetID, TreatmentCode, Cost) where TreatmentID is the Primary Key, and PetID and TreatmentCode are Foreign Keys.

1.25 marks: Correct explanation of transitive dependency (non-key field depending on another non-key field) with reference to PetName depending on PetID or TreatmentDescription depending on TreatmentCode. 2.50 marks: Three correctly normalised relations with correct attributes and designated primary keys (0.83 marks per correct table and primary key specification).

Step 1: Convert the binary number to be subtracted (\(00101011_2\)) into its negative equivalent using two's complement.
- Original binary: \(00101011\)
- One's complement (invert bits): \(11010100\)
- Two's complement (add 1): \(11010101\)

Step 2: Add the two's complement value to the first binary number:
```
01011101
+ 11010101
----------
(1)00110010
```

Step 3: Discard the carry bit beyond the 8th bit to get the final 8-bit result:
\(00110010_2\) (equivalent to 50 in denary).

- 1 mark for correctly converting the subtrahend to its two's complement form: \(11010101\).
- 1 mark for attempting to add the two binary values showing correct binary carry logic.
- 1 mark for the correct final 8-bit answer: \(00110010\).

1. The CIDR suffix of \(/26\) indicates that the first 26 bits of the subnet mask are set to 1. In octet form:
- Octet 1: 8 bits = 255
- Octet 2: 8 bits = 255
- Octet 3: 8 bits = 255
- Octet 4: 2 bits = \(128 + 64 = 192\)
This gives a subnet mask of \(255.255.255.192\).

2. To find the network ID, perform a bitwise AND operation between the fourth octet of the IP address (74) and the fourth octet of the subnet mask (192):
- 74 in binary: \(01001010_2\)
- 192 in binary: \(11000000_2\)
- Bitwise AND: \(01000000_2\) which equals 64 in decimal.
Therefore, the network address is \(192.168.100.64\).

Total: 2.67 marks (rounded/distributed as follows):
- 1 mark for correctly identifying the subnet mask as 255.255.255.192.
- 1.67 marks for correctly calculating the network ID as 192.168.100.64 (1 mark for showing/understanding the binary bitwise AND process, 0.67 marks for the correct final IP address).

1. The formula for the number of links in a fully connected mesh network of \(n\) nodes is \(\frac{n(n-1)}{2}\). For \(n = 6\): \(\frac{6 \times 5}{2} = 15\) links.
2. In a star topology, each of the \(n\) workstations has exactly one direct link to the central switch, resulting in \(n\) links. For \(n = 6\), this is 6 links.
3. Advantage: A mesh network does not suffer from a single point of central device failure (unlike the switch in a star topology) and has high redundancy; if one connection fails, packets can still find an alternative route.

Total: 2.67 marks
- 1 mark for correct calculation of mesh links (15).
- 1 mark for correct calculation of star links (6).
- 0.67 marks for identifying a valid advantage of a mesh network (e.g., redundancy, no central single point of failure, fault tolerance).

1. An IPv6 address consists of 128 bits.
2. Compression steps for \(2001:0db8:0000:0000:0000:ff00:0042:8329\):
- Remove leading zeros in each group: \(2001:db8:0:0:0:ff00:42:8329\)
- Replace the longest consecutive run of zero groups with double colons (\(::\)): \(2001:db8::ff00:42:8329\)

Total: 2.67 marks
- 1 mark for stating '128 bits'.
- 1.67 marks for the fully correct compressed IPv6 address '2001:db8::ff00:42:8329'. (Accept 1 mark partial credit if leading zeros were removed but the double-colon was omitted or misplaced).

Let's evaluate each sub-expression step-by-step:

1. Evaluate the arithmetic inside the `MID` function parameters:
- `Num1 MOD Num2` = `15 MOD 4` = `3`
- `(Num1 MOD Num2) + 1` = `3 + 1` = `4` (This is the start index for `MID`)
- `Num2 - 1` = `4 - 1` = `3` (This is the length for `MID`)

2. Evaluate the `MID` function:
- `MID("Cambridge9618", 4, 3)` extracts a substring starting from index 4 with a length of 3 characters.
- Index 1: 'C', Index 2: 'a', Index 3: 'm', Index 4: 'b', Index 5: 'r', Index 6: 'i'.
- The resulting substring is `"bri"`.

3. Evaluate the second part of the concatenation:
- `Num1 DIV Num2` = `15 DIV 4` = `3`
- `NUM_TO_STR(3)` converts the integer to string `"3"`.

4. Concatenate the two results:
- `"bri" & "3"` = `"bri3"`.

1 mark: Correct evaluation of `MID` start index as 4 and length as 3.
1 mark: Correct extraction of `"bri"` from the string.
1 mark: Correct evaluation of `Num1 DIV Num2` as 3 and conversion to `"3"`.
0.66 marks: Correct final concatenated string `"bri3"` (must include quotes or be clearly represented as a string).

Accept: "bri3"
Reject: bri3 (without indicator of string), "bri 3"

Let's evaluate each part of the compound conditional statement:

1. Evaluate `NOT(IsActive)`:
- `NOT(TRUE)` = `FALSE`

2. Evaluate the left side of the `AND` operator: `ASC(Code) > 66`:
- `Code` is `'D'`.
- Knowing the standard ASCII values (where 'A' is 65, 'B' is 66, 'C' is 67, 'D' is 68):
- `ASC('D')` = `68`
- `68 > 66` = `TRUE`

3. Evaluate the right side of the `AND` operator: `INT(Score * 2) = 29`:
- `Score * 2` = `14.5 * 2` = `29.0`
- `INT(29.0)` = `29`
- `29 = 29` = `TRUE`

4. Combine with the `AND` operator:
- `TRUE AND TRUE` = `TRUE`

5. Combine with the `OR` operator:
- `FALSE OR TRUE` = `TRUE`

6. Determine the data type:
- The final value `TRUE` belongs to the `BOOLEAN` data type.

1 mark: Correct evaluation of `NOT(IsActive)` as `FALSE`.
1 mark: Correct evaluation of `ASC(Code) > 66` as `TRUE` (by correctly mapping 'D' to 68).
1 mark: Correct evaluation of `INT(Score * 2) = 29` as `TRUE`.
0.66 marks: Correct final evaluation of `TRUE` with the correct data type of `BOOLEAN`.

Accept: True, TRUE, Boolean, BOOLEAN

Let's evaluate each sub-expression of the concatenation step-by-step:

1. Evaluate the first substring operation: `UCASE(LEFT(StrA, 2))`
- `LEFT("Prog", 2)` extracts the first 2 characters from the left: `"Pr"`.
- `UCASE("Pr")` converts the string to uppercase: `"PR"`.

2. Evaluate the arithmetic conversion: `NUM_TO_STR(INT(Value * 2))`
- `Value * 2` = `4.5 * 2` = `9.0`
- `INT(9.0)` extracts the integer part: `9`.
- `NUM_TO_STR(9)` converts the integer to string: `"9"`.

3. Evaluate the third substring operation: `RIGHT(StrB, 2)`
- `RIGHT("9618", 2)` extracts the last 2 characters from the right: `"18"`.

4. Concatenate all three parts:
- `"PR"` & `"9"` & `"18"` = `"PR918"`.

1 mark: Correct evaluation of `UCASE(LEFT(StrA, 2))` as `"PR"`.
1 mark: Correct evaluation of `NUM_TO_STR(INT(Value * 2))` as `"9"`.
1 mark: Correct evaluation of `RIGHT(StrB, 2)` as `"18"`.
0.66 marks: Correctly concatenated final string `"PR918"`.

Accept: "PR918"
Reject: PR918 (without double quotes), "Pr918", "PR9.018"

To convert the flowchart logic systematically into a sequential `WHILE` loop:
1. Initialize the counter: `EvenCount <- 0`.
2. Perform an initial read of the loop variable: `INPUT Num`.
3. Evaluate the entry condition for the loop: Since the flowchart terminates when `Num < 0`, the loop must continue while `Num >= 0`. Thus, `WHILE Num >= 0 DO` is used.
4. Inside the loop, check if the number is even using the modulo operator: `IF Num MOD 2 = 0 THEN EvenCount <- EvenCount + 1 ENDIF`.
5. Before the end of the loop, prompt for the next input to update the loop condition: `INPUT Num`.
6. Once the loop terminates, output the final counter value: `OUTPUT EvenCount`.

- 1.0 Mark: Correct initialization of `EvenCount` to 0 AND the initial `INPUT Num` before the loop begins.
- 1.0 Mark: Correct loop syntax and logical condition (`WHILE Num >= 0 DO` matching with `ENDWHILE`) including the update state (`INPUT Num`) at the end of the loop body.
- 1.0 Mark: Correct selection logic to check if `Num` is even (`IF Num MOD 2 = 0 THEN` or equivalent) and incrementing `EvenCount`.
- 0.5 Mark: Correctly outputting `EvenCount` after the loop terminates.

The flowchart uses nested decisions, which translate to nested selection structures in pseudocode:
- The primary condition is `Score >= 80`.
- If this is true, the program immediately checks the nested condition `Attendance >= 90` to decide between outputting "Grade A with Distinction" and "Grade A".
- If the primary condition is false, the program falls back to the outer `ELSE` block, where a secondary nested condition checks `Score >= 50` to output either "Pass" or "Fail".

- 0.5 Marks: Correct input statements for `Score` and `Attendance`.
- 1.0 Mark: Correct outer conditional structure (`IF Score >= 80 THEN ... ELSE ... ENDIF`).
- 1.0 Mark: Correct nested structure under the `THEN` block for checking `Attendance >= 90` and outputting the correct messages.
- 1.0 Mark: Correct nested structure under the outer `ELSE` block for checking `Score >= 50` and outputting "Pass" or "Fail".

To define the record structure, we use the TYPE ... ENDTYPE block. The student's name should be declared as a STRING, and the pointer as an INTEGER.

```
TYPE ListNode
DECLARE StudentName : STRING
DECLARE NextPointer : INTEGER
ENDTYPE
```

Next, we declare the 1D array of type `ListNode` with the specified bounds 1 to 100:

```
DECLARE StudentList : ARRAY[1:100] OF ListNode
```

Finally, we declare the two pointer variables as integers:

```
DECLARE HeadPointer : INTEGER
DECLARE FreePointer : INTEGER
```

1 mark: Correct structure of `TYPE ListNode` ... `ENDTYPE` with both student name (STRING) and next pointer (INTEGER) fields.
1 mark: Correct declaration of the array `StudentList` as a 1D array of size `1:100` of type `ListNode`.
1 mark: Correct declaration of `HeadPointer` as an INTEGER.
1 mark: Correct declaration of `FreePointer` as an INTEGER.

First, define the user-defined record type `TrackNode` with three integer fields:

```
TYPE TrackNode
DECLARE TrackID : INTEGER
DECLARE PlayCount : INTEGER
DECLARE NextPointer : INTEGER
ENDTYPE
```

Second, declare the 1D array `Playlist` holding 50 instances of this record:

```
DECLARE Playlist : ARRAY[1:50] OF TrackNode
```

Third, declare the start pointer variable:

```
DECLARE StartPointer : INTEGER
```

1 mark: Correct `TYPE TrackNode` ... `ENDTYPE` syntax structure.
1 mark: All three fields inside the record structure correctly declared as INTEGER.
1 mark: Correct array declaration for `Playlist` (1 to 50) of type `TrackNode`.
1 mark: Correct declaration of pointer `StartPointer` as an INTEGER.

Below is the step-by-step logic used in the algorithm:
1. **Function Header**: The function `AveragePass` is defined to accept a 1D array of 100 integers, returning a `REAL` value since an average can have decimal components.
2. **Variable Initialization**: A `Sum` accumulator and a `Count` tracker are both initialized to 0. An `Index` loop variable is declared.
3. **Looping**: A `FOR` loop iterates from 1 to 100 to process each element in the `Scores` array.
4. **Conditional Check**: Within the loop, an `IF` statement checks if the current index value is 50 or above.
5. **Accumulation**: If the threshold is met, the score is added to `Sum` and `Count` is incremented.
6. **Final Evaluation**: After the loop, we check if `Count` is greater than 0. If it is, the calculated average (`Sum / Count`) is returned. Otherwise, `-1.0` is returned to signal that no passing scores were found.

Award up to 6 marks for the following points:

1. **Function Header & Footer**: Correct declaration of function name, passing parameter correctly typed as an array of size 100, and correct return type `REAL` (plus matching `ENDFUNCTION`). (1 mark)
2. **Initialization**: Initialize accumulator variables (e.g., `Sum <- 0` and `Count <- 0`) before entering the loop. (1 mark)
3. **Loop**: A loop from 1 to 100 to check every item in the array. (1 mark)
4. **Conditional Statement**: Correct condition checking if array elements are greater than or equal to 50 (e.g., `IF Scores[Index] >= 50`). (1 mark)
5. **Running Calculations**: Correctly calculating `Sum` and incrementing `Count` within the conditional block. (1 mark)
6. **Result & Return**: Division-by-zero check (e.g., checking if `Count > 0`), returning correct calculated real value, and returning -1 (or -1.0) otherwise. (1 mark)

Let us trace the execution of `FunString("pRaCtiCe")` step-by-step:

1. `Str` is "pRaCtiCe", which has a length of 8.
2. Initial states: `Res` is initialized to "", and `i` is set to 8.
3. **First iteration (i = 8)**:
- `i > 0` (8 > 0) is TRUE.
- `Ch` is the character at position 8: 'e'.
- 'e' is between 'a' and 'z' (lowercase), so we concatenate `UCASE('e')` ('E') to `Res`.
- `Res` becomes "E".
- `i` is updated to 8 - 2 = 6.
4. **Second iteration (i = 6)**:
- `i > 0` (6 > 0) is TRUE.
- `Ch` is the character at position 6: 'i'.
- 'i' is lowercase, so we concatenate `UCASE('i')` ('I') to `Res`.
- `Res` becomes "EI".
- `i` is updated to 6 - 2 = 4.
5. **Third iteration (i = 4)**:
- `i > 0` (4 > 0) is TRUE.
- `Ch` is the character at position 4: 'C'.
- 'C' is NOT lowercase (uppercase), so we concatenate "*" to `Res`.
- `Res` becomes "EI*".
- `i` is updated to 4 - 2 = 2.
6. **Fourth iteration (i = 2)**:
- `i > 0` (2 > 0) is TRUE.
- `Ch` is the character at position 2: 'R'.
- 'R' is NOT lowercase, so we concatenate "*" to `Res`.
- `Res` becomes "EI**".
- `i` is updated to 2 - 2 = 0.
7. **Termination**:
- `i > 0` (0 > 0) is FALSE.
- The loop terminates and the function returns "EI**".

Completed trace table:
| i | Ch | Res |
|---|----|-----|
| 8 | | "" |
| | 'e'| "E" |
| 6 | | |
| | 'i'| "EI"|
| 4 | | |
| | 'C'| "EI*"|
| 2 | | |
| | 'R'| "EI**"|
| 0 | | |

Award marks as follows:
- 1 mark: For row showing i = 8, Ch = 'e', and Res = "E"
- 1 mark: For row showing i = 6, Ch = 'i', and Res = "EI"
- 1 mark: For row showing i = 4, Ch = 'C', Res = "EI*" and i = 2, Ch = 'R', Res = "EI**"
- 1 mark: For showing i = 0 as the final state causing loop termination.

Let us trace the algorithm character by character with `Word = "BoXCaR"`:

1. Initial state: `Out` is initialized to "".
2. **k = 1**:
- `Ch` is "B".
- `1 MOD 3 = 1` is TRUE.
- `Out` becomes `"" & "B"` = "B".
3. **k = 2**:
- `Ch` is "o".
- `2 MOD 3 = 1` is FALSE.
- `Ch` is not "X", so we lowercase `Ch` (still "o") and append to `Out`.
- `Out` becomes `"B" & "o"` = "Bo".
4. **k = 3**:
- `Ch` is "X".
- `3 MOD 3 = 1` is FALSE.
- `Ch` is "X", so we append "?" to `Out`.
- `Out` becomes `"Bo" & "?"` = "Bo?".
5. **k = 4**:
- `Ch` is "C".
- `4 MOD 3 = 1` is TRUE.
- `Out` becomes `"Bo?" & "C"` = "Bo?C".
6. **k = 5**:
- `Ch` is "a".
- `5 MOD 3 = 1` is FALSE.
- `Ch` is not "X", so we lowercase `Ch` and append.
- `Out` becomes `"Bo?C" & "a"` = "Bo?Ca".
7. **k = 6**:
- `Ch` is "R".
- `6 MOD 3 = 1` is FALSE.
- `Ch` is not "X", so we lowercase `Ch` ("r") and append.
- `Out` becomes `"Bo?Ca" & "r"` = "Bo?Car".

Completed trace table:
| k | Ch | k MOD 3 = 1 | Out |
|---|----|-------------|-----|
| | | | "" |
| 1 | 'B'| TRUE | "B" |
| 2 | 'o'| FALSE | "Bo"|
| 3 | 'X'| FALSE | "Bo?"|
| 4 | 'C'| TRUE | "Bo?C"|
| 5 | 'a'| FALSE | "Bo?Ca"|
| 6 | 'R'| FALSE | "Bo?Car"|

Award marks as follows:
- 1 mark: For correct trace of steps k = 1 and k = 2.
- 1 mark: For correct trace of step k = 3 showing substitution of 'X' with '?'.
- 1 mark: For correct trace of steps k = 4 and k = 5.
- 1 mark: For correct final step k = 6 and final correct value of `Out` as "Bo?Car".

The function first validates that all lengths are positive and that c is the strictly longest side. It then calculates the difference between \(a^2 + b^2\) and \(c^2\). Since we cannot use a built-in absolute value function, we check if the difference is negative and multiply it by -1 to get the absolute difference. Finally, we check if this difference is strictly less than 0.0001.

1 Mark: Correct function header with parameters and return type. 1 Mark: Correct validation that all parameters are greater than 0, and c is greater than both a and b. 1 Mark: Correct calculation of squared differences and manual absolute value logic. 1 Mark: Correct tolerance comparison and returning appropriate BOOLEAN values.

The function begins by checking if the radius r is positive. If r is valid, it calculates the squared distance between the points as \((x - cx)^2 + (y - cy)^2\). It then calculates the squared boundary as \((r + 0.005)^2\). Finally, it compares these two squared values and returns TRUE if the squared distance is less than or equal to the squared boundary, and FALSE otherwise.

1 Mark: Correct function header with appropriate parameters, types, and BOOLEAN return type. 1 Mark: Correct validation of radius range (r > 0). 1 Mark: Correct calculation of squared distance between coordinates. 1 Mark: Correct calculation of the squared allowed boundary with tolerance, followed by correct conditional comparison and return statements.

1. Data couples: RoomNumber (String, input to GetRoomDetails), RoomRate (Real, output from GetRoomDetails and input to ComputeFinalBill), NumNights (Integer, input to ComputeFinalBill), and TotalCost (Real, output from ComputeFinalBill). 2. Control couple: IsAvailable (Boolean, output from GetRoomDetails). 3. Graphical representations: Data couples are represented by arrows with an open/unfilled circle at their tail. Control couples are represented by arrows with a solid/filled circle at their tail.

1 mark: Correctly identifying RoomNumber, RoomRate, NumNights, and TotalCost as data couples. 1 mark: Correctly identifying IsAvailable as a control couple. 1.5 marks: Describing the representation of a data couple as an arrow with an open circle at its tail. 1.5 marks: Describing the representation of a control couple as an arrow with a filled/solid circle at its tail.

1. Repetition (iteration) is shown by a curved arrow (loop) drawn across the connection line linking MonitorSystem to ReadSensor. 2. Selection (conditional calling) is shown by a small diamond symbol placed on the bottom edge of the parent module MonitorSystem where the connection lines to TriggerAlarm and LogNormalTemp originate. 3. Parameter passing: CurrentTemp is a data couple passed from ReadSensor to MonitorSystem, represented by an arrow pointing upwards (from child to parent) with an open (unfilled) circle at its tail.

1.5 marks: Describing the curved loop arrow around the connection line for iteration. 1.5 marks: Describing the diamond symbol at the base of the parent module for selection. 1.5 marks: Correctly identifying the direction (upwards/to parent) and type (data couple with open circle at tail) of the CurrentTemp parameter.

1. The parent module is ProcessInventory. The direct sub-modules called are CalculateRetail, CheckProfitability, and RecordItem. 2. Parameters passed to CheckProfitability: CostPrice (REAL) and SellingPrice (REAL). Value returned to parent: IsProfitable (BOOLEAN). 3. The visual symbol to indicate conditional execution (selection) is a small diamond shape drawn at the junction where the connection line to RecordItem connects to the parent module ProcessInventory.

1.5 marks: Correctly identifying ProcessInventory as the parent module and listing all three sub-modules. 2 marks: Listing CostPrice (REAL) and SellingPrice (REAL) as passed parameters, and IsProfitable (BOOLEAN) as the returned control parameter. 1.5 marks: Correctly identifying the diamond symbol on the connection line representing selection/conditional execution.

PROCEDURE ProcessClass(SourceFile : STRING, TargetClass : STRING) DECLARE Line, ID, Name, Class, MarkStr : STRING DECLARE Mark, i, FieldCount : INTEGER DECLARE CurrentChar : CHAR OPENFILE SourceFile FOR READ OPENFILE "Selected.txt" FOR WRITE WHILE NOT EOF(SourceFile) READFILE SourceFile, Line ID ← "" Name ← "" Class ← "" MarkStr ← "" FieldCount ← 1 FOR i ← 1 TO LENGTH(Line) CurrentChar ← MID(Line, i, 1) IF CurrentChar = '#' THEN FieldCount ← FieldCount + 1 ELSE IF FieldCount = 1 THEN ID ← ID & CurrentChar ELSEIF FieldCount = 2 THEN Name ← Name & CurrentChar ELSEIF FieldCount = 3 THEN Class ← Class & CurrentChar ELSEIF FieldCount = 4 THEN MarkStr ← MarkStr & CurrentChar ENDIF ENDIF ENDFOR IF Class = TargetClass THEN Mark ← STR_TO_NUM(MarkStr) IF Mark >= 70 THEN WRITEFILE "Selected.txt", ID & ":" & Name & ":PASS" ENDIF ENDIF ENDWHILE CLOSEFILE SourceFile CLOSEFILE "Selected.txt" ENDPROCEDURE

1 mark: Correct PROCEDURE header with two string parameters. 1 mark: Correctly opening 'SourceFile' for READ and 'Selected.txt' for WRITE. 1 mark: Correctly using a WHILE NOT EOF(SourceFile) loop to read all lines. 1 mark: Parsing the line character-by-character to extract individual fields using MID and counting '#' delimiters. 1 mark: Correctly extracting the ClassCode and MarkStr fields. 1 mark: Correctly converting MarkStr to an integer and checking if Class matches TargetClass and Mark >= 70. 1 mark: Correctly writing the output line in the format ID & ':' & Name & ':PASS' to 'Selected.txt'. 1 mark: Correctly closing both files at the end of the procedure.

FUNCTION ValidateAndExport(InputFile : STRING, OutputFile : STRING) RETURNS INTEGER DECLARE Email : STRING DECLARE ValidCount, AtPos, DotPos, AtCount, i, LengthEmail : INTEGER DECLARE CurrentChar : CHAR DECLARE IsValid : BOOLEAN ValidCount ← 0 OPENFILE InputFile FOR READ OPENFILE OutputFile FOR WRITE WHILE NOT EOF(InputFile) READFILE InputFile, Email LengthEmail ← LENGTH(Email) IsValid ← TRUE IF LengthEmail < 3 THEN IsValid ← FALSE ELSE IF MID(Email, 1, 1) = "." OR MID(Email, 1, 1) = "@" OR MID(Email, LengthEmail, 1) = "." OR MID(Email, LengthEmail, 1) = "@" THEN IsValid ← FALSE ELSE AtCount ← 0 AtPos ← 0 FOR i ← 1 TO LengthEmail CurrentChar ← MID(Email, i, 1) IF CurrentChar = "@" THEN AtCount ← AtCount + 1 AtPos ← i ENDIF ENDFOR IF AtCount <> 1 THEN IsValid ← FALSE ELSE DotPos ← 0 FOR i ← AtPos + 1 TO LengthEmail IF MID(Email, i, 1) = "." THEN DotPos ← i ENDIF ENDFOR IF DotPos = 0 THEN IsValid ← FALSE ENDIF ENDIF ENDIF ENDIF IF IsValid = TRUE THEN WRITEFILE OutputFile, Email ValidCount ← ValidCount + 1 ENDIF ENDWHILE CLOSEFILE InputFile CLOSEFILE OutputFile RETURN ValidCount ENDFUNCTION

1 mark: Correct FUNCTION header with return type INTEGER and correct RETURN statement. 1 mark: Correctly opening InputFile for READ and OutputFile for WRITE, and closing both at the end. 1 mark: Using a loop with NOT EOF(InputFile) to process all emails in the file. 1 mark: Implementing Rule 3: Checking if the email is too short, or if the first or last character is '.' or '@'. 1 mark: Implementing Rule 1: Counting the occurrences of '@' and ensuring there is exactly one. 1 mark: Implementing Rule 2: Searching for at least one '.' character after the position of the '@'. 1 mark: Correctly writing valid emails to OutputFile and updating/returning the count of valid emails.