2025 Cambridge IGCSE Computer Science (0478) 模拟试题及答案详解

Hexadecimal notation is more compact than binary (representing 4 bits as a single character), which makes it significantly easier for human programmers to read, write, remember, and debug. This reduces the likelihood of transcription errors without changing how the computer itself processes the data.

1 mark for stating that it is easier for humans to read, write, remember, or is less prone to errors. 0.5 mark for explaining that it is a shorter or more compact representation (each hex digit represents exactly 4 binary bits).

Serial data transmission sends data one bit at a time over a single wire. This significantly reduces the cost of cabling and eliminates the problem of data skewing/crosstalk over long distances. However, because it only transmits one bit at a time, it has a slower rate of data transfer compared to parallel transmission over short distances.

1 mark for a valid advantage (e.g., lower cabling cost, less crosstalk, or no data skewing over long distances). 0.5 mark for a valid disadvantage (e.g., slower data transfer rate over short distances).

This social engineering technique is known as phishing. It uses deceptive emails to trick users into revealing sensitive information. The worker can identify it as fake by looking for spelling and grammatical errors, generic greetings (like 'Dear User' instead of their name), or hovering over the link to verify that the target URL does not match the official company domain.

0.5 mark for identifying the threat as phishing. 1 mark for explaining a valid identification method (e.g., checking for spelling mistakes, checking the sender's actual email domain, or verifying the destination URL by hovering over the link).

The Memory Address Register (MAR) is a CPU register that holds the physical address of the current memory location in RAM that is being accessed for a read or write operation. It is directly connected to the address bus to specify the target memory location.

1 mark for explaining that it holds the address of the memory location currently being read from or written to. 0.5 mark for stating that it sends this address to memory via the address bus.

Sample resolution (also known as bit depth) refers to the number of bits allocated to represent the amplitude of each audio sample. A higher sample resolution allows for a wider dynamic range and a more accurate representation of the original analog sound wave, but increases file size.

1 mark for defining sample resolution as the number of bits used to represent/store each audio sample. 0.5 mark for explaining its effect (e.g., higher resolution leads to more accurate sound reproduction or a larger file size).

Solid State Drives (SSDs) use flash memory and have no moving mechanical parts, which makes them highly shock-resistant and durable for portable field laptops. Additionally, SSDs provide significantly faster read/write speeds, allowing files to load much faster.

1 mark for explaining the physical durability/robustness due to no moving parts (essential for portable laptops). 0.5 mark for mentioning another benefit such as faster read/write speeds, lighter weight, or lower power consumption.

An expert system mimics the decision-making ability of a human expert. It consists of three primary components: the User Interface (to interact with the user), the Inference Engine (the reasoning system that applies rules to the data), and the Knowledge Base (the repository of facts and rules).

0.5 mark for each correct component identified: User interface, Inference engine, and Knowledge base (up to a maximum of 1.5 marks).

A two-input XOR gate outputs a 1 (high) if and only if one of the inputs is 1 and the other is 0 (i.e., the inputs are different). If both inputs are 0 or both inputs are 1 (the inputs are the same), the output is 0 (low).

1 mark for stating that the output is high/1 when the inputs are different (one is 1 and the other is 0). 0.5 mark for stating that the output is low/0 when both inputs are identical (both 0 or both 1).

1. MIDI files contain performance instructions (such as pitch, volume, and tempo) rather than actual audio, whereas MP3 files contain actual compressed audio recordings.
2. MIDI files are significantly smaller in file size compared to MP3 files because they do not store digital audio waveforms.

One mark per correct difference (max 1.5):
- MIDI stores performance data/instructions whereas MP3 stores actual recording of sound [0.75]
- MIDI files are much smaller in size than MP3 files [0.75]
- MIDI requires a synthesizer/instrument to generate sound on playback whereas MP3 can be played directly on any standard audio player [0.75]

1. It is a plug-and-play interface, meaning devices are automatically detected and configured without needing a computer restart.
2. It can provide power to the connected device, removing the need for a separate external power supply.

One mark per correct benefit (max 1.5):
- It is plug-and-play / hot-swappable [0.75]
- It provides electrical power to run the device [0.75]
- It is a universal standard / widely compatible [0.75]
- It has a high data transmission rate [0.75]

1. MAR: Stores the memory address of the next instruction or data byte that needs to be fetched from memory.
2. MDR: Temporarily stores the instruction or data that has just been read from memory (or is about to be written to memory).

One mark for MAR role and one mark for MDR role (max 1.5):
- MAR: Holds the memory address of the current instruction/data to be fetched from RAM [0.75]
- MDR: Holds the actual data/instruction that has been fetched from RAM [0.75]

Role: To monitor and control incoming and outgoing network traffic based on predetermined security rules.
Method: Packet filtering, which inspects packets of data to check if they meet set criteria and blocks those that do not.

One mark for stating the role, one mark for describing a method (max 1.5):
- Role: Monitors traffic / acts as a filter/barrier between the internal network and the internet [0.75]
- Method: Packet filtering (examines packets and blocks those failing criteria) // IP address blocking (blocks traffic from known bad IPs) [0.75]

(a) To represent -27 in 8-bit two's complement:
1. Find the binary representation of +27:
128 64 32 16 8 4 2 1
0 0 0 1 1 0 1 1 => 00011011
2. Invert all the bits (one's complement):
11100100
3. Add 1 to the result:
11100100 + 1 = 11100101

(b) To convert 11100101 to hexadecimal:
1. Split the 8-bit binary into two 4-bit nibbles:
1110 and 0101
2. Convert each nibble to denary, then to hex:
1110 = 14 in denary = E in hex
0101 = 5 in denary = 5 in hex
3. Combine the hex digits: E5

(a) Max 2 marks:
- 1 mark for correct working (e.g. correct binary for +27 or one's complement shown)
- 1 mark for correct final 8-bit binary: 11100101

(b) Max 2 marks:
- 1 mark for converting nibbles correctly (e.g. 1110 to E or 0101 to 5)
- 1 mark for correct final hexadecimal representation: E5

(a) In parallel transmission, multiple bits (usually a byte) are sent at the exact same time using multiple physical wires or communication channels. Half-duplex means that the transmission path is shared so that data can flow in both directions (bi-directionally), but only one direction at any given instant.

(b) Serial transmission sends data bit by bit over a single wire. This eliminates the risk of bits arriving out of sync (skewing), which is a common issue with parallel lines over long distances. It also greatly reduces cabling costs.

(a) Max 3 marks:
- 1 mark for explaining that multiple bits are sent at the same time / simultaneously.
- 1 mark for explaining that multiple physical lines/channels/wires are used.
- 1 mark for explaining that transmission can go in both directions, but not at the same time.

(b) Max 1 mark:
- 1 mark for stating that serial prevents data skewing / bits arriving out of synchronization.
- Alternative: 1 mark for stating that serial is cheaper / requires fewer wires to install over long distances.

(i) The Program Counter (PC) keeps track of the memory address of the next instruction that needs to be executed. Once the current cycle's address is sent to the MAR, the PC is automatically incremented by 1 so that it points to the next sequential instruction in memory.

(ii) The Memory Address Register (MAR) serves as a holding register for the memory address that is currently being accessed for a read or write operation. During the fetch phase, it takes the address copied from the PC and places it on the address bus to locate the instruction in RAM.

(i) Program Counter (PC) - Max 2 marks:
- 1 mark: Holds the address of the next instruction to be fetched.
- 1 mark: Increments (by 1) to prepare for the subsequent cycle.

(ii) Memory Address Register (MAR) - Max 2 marks:
- 1 mark: Receives/copies the address of the instruction from the PC.
- 1 mark: Temporarily holds this address while the memory is being accessed (via the address bus).

(a) A Denial of Service (DoS) attack involves sending a massive flood of traffic or resource requests to a target system or web server. The volume of traffic is so immense that it exhausts the server's network bandwidth, memory, or processing power, rendering it unable to handle legitimate incoming connections.

(b) Two direct consequences include:
1. Legitimate customers are locked out or face severe delays, leading to immediately lost sales transactions.
2. Long-term reputational damage, as users lose confidence in the reliability and safety of the e-commerce service.

(a) Max 2 marks:
- 1 mark: Flooding the server/network with a very high volume of requests/traffic.
- 1 mark: Overwhelming the system resources/bandwidth so it cannot process legitimate requests.

(b) Max 2 marks (any two from):
- Legitimate users/customers cannot access the website/services [1]
- The server slows down significantly or crashes [1]
- Loss of revenue/sales during the downtime [1]
- Damage to the brand's reputation / loss of customer trust [1]

(a) To convert analogue sound to digital, a microphone captures the continuous sound wave. An Analogue-to-Digital Converter (ADC) samples (measures) the amplitude of the wave at fixed, frequent intervals of time. These numeric measurements are then rounded to the nearest available digital value and represented as binary numbers.

(b) The sample rate determines how many samples are taken per second, and the sample resolution (bit depth) determines the number of bits used to store each sample. Increasing either parameter means that a larger number of bits must be recorded for every second of audio, directly causing the file size to grow.

(a) Max 2 marks:
- 1 mark: The amplitude of the analogue sound wave is measured/sampled at regular time intervals.
- 1 mark: These measurements are converted to/stored as binary values.

(b) Max 2 marks:
- 1 mark: Higher sample rate/resolution means more data/bits are captured and saved per second.
- 1 mark: This leads to an increase in the overall storage size of the audio file (or vice versa).

(a) An interrupt is a specialized signal generated by hardware (such as a keyboard press or a printer warning) or software (such as an error like division by zero). It is sent directly to the CPU to request that it halt what it is doing and prioritize the incoming request.

(b) At the end of each fetch-decode-execute cycle, the CPU checks if any interrupts are active. If an interrupt is present, the CPU halts its current operations, saves the contents of its registers (its state) onto a stack in memory, calls the appropriate Interrupt Service Routine (ISR) program, executes it, and once complete, restores the saved register contents to continue where it left off.

(a) Max 2 marks:
- 1 mark: A signal sent to the CPU from a hardware device or software.
- 1 mark: Requests immediate attention / pauses execution of the current program.

(b) Max 2 marks (any two from):
- Pauses/suspends execution of the current task [1]
- Saves the current state / register values (to memory/stack) [1]
- Executes the specific Interrupt Service Routine (ISR) to handle the interrupt [1]
- Restores the saved state and resumes the previous program [1]

(a) An expert system consists of:
1. User Interface: The gateway allowing a non-expert user (or doctor) to interact with the system by inputting queries/symptoms and viewing the produced outputs.
2. Knowledge Base: A massive repository of domain-specific facts, logic, and rules gathered from human industry experts.
3. Inference Engine: The reasoning processor that applies logical reasoning methods to the user input against the rules in the knowledge base to derive solutions.

(b) A primary limitation is that it lacks human intuition and common sense. If a patient presents a completely novel combination of symptoms not stored in the rules, the system might fail completely or provide a dangerously incorrect diagnosis.

(a) Max 3 marks:
- 1 mark: User Interface - accepts user input (symptoms) and displays results/diagnoses.
- 1 mark: Knowledge Base - stores the factual knowledge and IF-THEN rules established by human experts.
- 1 mark: Inference Engine - the program that applies logical rules to search the knowledge base and draw conclusions.

(b) Max 1 mark:
- 1 mark: Lacks human empathy/intuition/judgment.
- Alternative: 1 mark: Highly dependent on the accuracy/completeness of the knowledge base (garbage in, garbage out).

(a) A Domain Name Server (DNS) behaves like an address book for the internet. When a user types a human-readable domain name (like www.example.com), the browser queries a DNS. The DNS searches its records to match the domain name to its corresponding IP address (like 192.0.2.1) and returns it to the browser, allowing it to connect to the host server.

(b) Web browsers store cookies, which are sent by the website to the user's computer. They store useful state data, such as keeping a user logged in, remembering their interface preferences (e.g., dark mode or language), or tracking an active shopping cart, avoiding the frustration of repetitive inputs.

(a) Max 2 marks:
- 1 mark: Translates/resolves a user-friendly domain name (URL) into a numeric IP address.
- 1 mark: Looks up the matching entry in a database and returns it to the web browser.

(b) Max 2 marks (any two from):
- Stores user preferences (e.g. language/theme) to keep the site customized [1]
- Remembers login session details so the user does not have to log in repeatedly [1]
- Tracks past browsing history or cart content to offer personalized recommendations [1]

1. Before transmission, the sender calculates a checksum value using a specific algorithm applied to the block of data.
2. The calculated checksum value is appended to the data block and transmitted along with it.
3. Upon receiving the transmission, the receiver applies the exact same algorithm to the received data block to calculate its own checksum value.
4. The receiver compares its calculated checksum with the transmitted checksum. If they match, the data is assumed error-free; if they do not match, an error is detected, and a retransmission request is sent.

Award 1 mark per point up to a maximum of 4 marks:
- One mark for stating the sender calculates the checksum before transmission using a specific algorithm/formula.
- One mark for stating the checksum is sent/appended with the data block.
- One mark for stating the receiver recalculates the checksum using the same algorithm on the received data.
- One mark for stating that both values are compared, and if they differ, an error has occurred / retransmission is requested.

1. The CPU checks for interrupt signals at the end of each fetch-decode-execute cycle.
2. If an interrupt is detected, the CPU suspends the execution of the current program.
3. The current status of the CPU registers (including the Program Counter) is saved onto a stack.
4. The CPU identifies the source of the interrupt and runs the appropriate Interrupt Service Routine (ISR).
5. Once the ISR is completed, the saved registers are restored from the stack, and the CPU resumes executing the original program from where it was suspended.

Award 1 mark per point up to a maximum of 4 marks:
- One mark for stating the CPU checks for interrupts at the end of an instruction/FDE cycle.
- One mark for stating the current task is suspended and register values (e.g. Program Counter/Accumulator) are saved on a stack.
- One mark for running the Interrupt Service Routine (ISR).
- One mark for restoring the registers and resuming the original program.

1. Convert the sample resolution from bits to bytes:
\(16\text{ bits} = 2\text{ bytes}\).

2. Calculate the total size in bytes:
\(40,000\text{ samples/sec} \times 2\text{ bytes/sample} \times 50\text{ seconds} = 4,000,000\text{ bytes}\).

3. Convert the total bytes to Megabytes (MB):
\(4,000,000\text{ bytes} / 1,000,000\text{ bytes/MB} = 4\text{ MB}\).

- 1 mark for converting resolution to bytes (16 bits = 2 bytes) or correctly multiplying with 16 and dividing by 8 later.
- 1 mark for correct formula expression: 40,000 * 2 * 50 (or 40,000 * 16 * 50 / 8).
- 1 mark for showing correct intermediate value (e.g., 4,000,000 bytes or 32,000,000 bits).
- 1 mark for correct final answer with units: 4 MB (accept 4).

(i) The place values of an 8-bit two's complement integer are -128, 64, 32, 16, 8, 4, 2, 1.
For 11001101:
\(-128 \times 1 + 64 \times 1 + 32 \times 0 + 16 \times 0 + 8 \times 1 + 4 \times 1 + 2 \times 0 + 1 \times 1\)
\(= -128 + 64 + 8 + 4 + 1 = -51\).

(ii) Convert 88 to unsigned binary first:
\(88 = 64 + 16 + 8 \rightarrow 01011000\).
Invert all bits (flip): \(10100111\).
Add 1: \(10100111 + 1 = 10101000\).
Verification: \(-128 + 32 + 8 = -88\).

(i)
- 1 mark for identifying place values or showing the addition: -128 + 64 + 8 + 4 + 1.
- 1 mark for correctly reaching the final value of -51.

(ii)
- 1 mark for correct positive representation (01011000) and showing conversion step (inverting bits: 10100111).
- 1 mark for correct final binary representation: 10101000.

(i) Translating the conditions:
- 'Temperature is high AND humidity is NOT low' -> \(T \text{ AND NOT } H\)
- 'Humidity is low AND ventilation is NOT open' -> \(H \text{ AND NOT } V\)
Combining them with OR gives: \(A = (T \text{ AND NOT } H) \text{ OR } (H \text{ AND NOT } V)\).

(ii) Let's evaluate each row:
- Row 1: 0 0 0 -> (0 AND 1) OR (0 AND 1) = 0
- Row 2: 0 0 1 -> (0 AND 1) OR (0 AND 0) = 0
- Row 3: 0 1 0 -> (0 AND 0) OR (1 AND 1) = 1
- Row 4: 0 1 1 -> (0 AND 0) OR (1 AND 0) = 0
- Row 5: 1 0 0 -> (1 AND 1) OR (0 AND 1) = 1
- Row 6: 1 0 1 -> (1 AND 1) OR (0 AND 0) = 1
- Row 7: 1 1 0 -> (1 AND 0) OR (1 AND 1) = 1
- Row 8: 1 1 1 -> (1 AND 0) OR (1 AND 0) = 0

(i)
- 1 mark for (T AND NOT H)
- 1 mark for (H AND NOT V) joined by OR

(ii)
- 2 marks for all 8 outputs correct (0, 0, 1, 0, 1, 1, 1, 0)
- 1 mark for 5 to 7 outputs correct

(i) Byte 2, Bit 7.

(ii)
1. Count the number of 1s in each row (Byte 1 to Parity Byte):
- Byte 1: 4 (even)
- Byte 2: 5 (odd) -> Error!
- Byte 3: 4 (even)
- Byte 4: 4 (even)
- Parity Byte: 4 (even)
Therefore, Byte 2 contains the error.

2. Count the number of 1s in each column (Bit 7 to Bit 0):
- Bit 7: 3 (odd) -> Error!
- Bit 6: 2 (even)
- Bit 5: 4 (even)
- Bit 4: 4 (even)
- Bit 3: 2 (even)
- Bit 2: 2 (even)
- Bit 1: 4 (even)
- Bit 0: 0 (even)
Therefore, Bit 7 contains the error.

3. The intersection of Byte 2 and Bit 7 determines the single corrupted bit.

(i)
- 1 mark for identifying Byte 2.
- 1 mark for identifying Bit 7.

(ii)
- 1 mark for explaining that Byte 2 has an odd number of 1s (or fails the even parity check).
- 1 mark for explaining that Bit 7 has an odd number of 1s (or fails the even parity check).

(i)
- Total number of pixels = \(800 \times 600 = 480,000\text{ pixels}\).
- Colour depth = \(24\text{ bits} = 3\text{ bytes per pixel}\).
- Size in bytes = \(480,000 \times 3 = 1,440,000\text{ bytes}\).
- Size in KB = \(1,440,000 / 1000 = 1440\text{ KB}\).

(ii)
- New colour depth = \(8\text{ bits} = 1\text{ byte per pixel}\).
- Size in bytes = \(480,000 \times 1 = 480,000\text{ bytes}\).
- Size in KB = \(480,000 / 1000 = 480\text{ KB}\).
- Alternatively: New size = \(1440\text{ KB} \times (8 / 24) = 480\text{ KB}\).

(i)
- 1 mark for calculating total pixels (480,000) or converting 24 bits to 3 bytes.
- 1 mark for correct final answer of 1440 KB (with units).

(ii)
- 1 mark for calculating total size using 8 bits per pixel (e.g., 480,000 bytes) or showing proportional reduction (1440 / 3).
- 1 mark for correct final answer of 480 KB (with units).

Let's perform the dry run step-by-step:
- Fluctuations is initialized to 0.
- INPUT PrevTemp receives the first temperature reading: 18.
- Count = 1:
- INPUT NextTemp receives 22.
- Diff = 22 - 18 = 4.
- Since Diff > 3, Fluctuations increases to 1.
- PrevTemp becomes 22.
- Count = 2:
- INPUT NextTemp receives 15.
- Diff = 15 - 22 = -7.
- Since Diff < 0, Diff is multiplied by -1, becoming 7.
- Since Diff > 3 (7 > 3), Fluctuations increases to 2.
- PrevTemp becomes 15.
- Count = 3:
- INPUT NextTemp receives 17.
- Diff = 17 - 15 = 2.
- Since Diff < 3, Fluctuations remains 2.
- PrevTemp becomes 17.
- Count = 4:
- INPUT NextTemp receives 21.
- Diff = 21 - 17 = 4.
- Since Diff > 3, Fluctuations increases to 3.
- PrevTemp becomes 21.
- After loop termination, OUTPUT Fluctuations displays 3.

- 1 mark: Correct values in Count and NextTemp columns.
- 1 mark: Correct calculated values in Diff (showing -7 then 7) and updated PrevTemp values.
- 1 mark: Correct values in Fluctuations column and final output of 3.

Matching analysis:
- Checking if data consists only of a specific data type (digits/letters) is a Type check.
- Checking if a required input is not empty is a Presence check.
- Checking if a value lies within a set minimum and maximum is a Range check.

1 mark for each correct line matched, up to a maximum of 3 marks.

- Initialization (lines 01-03): BelowFiftyCount = 0, AboveFiftySum = 0, AboveFiftyCount = 0.
- Index = 1: Marks[1] = 45. Marks[1] < 50 is true. BelowFiftyCount becomes 1.
- Index = 2: Marks[2] = 80. Marks[2] < 50 is false. AboveFiftySum becomes 80. AboveFiftyCount becomes 1.
- Index = 3: Marks[3] = 32. Marks[3] < 50 is true. BelowFiftyCount becomes 2.
- Index = 4: Marks[4] = 90. Marks[4] < 50 is false. AboveFiftySum becomes 80 + 90 = 170. AboveFiftyCount becomes 2.
- Index = 5: Marks[5] = 70. Marks[5] < 50 is false. AboveFiftySum becomes 170 + 70 = 240. AboveFiftyCount becomes 3.
- Loop ends. AboveFiftyCount > 0 is true. AverageAboveFifty becomes 240 / 3 = 80.
- OUTPUT BelowFiftyCount outputs 2.
- OUTPUT AverageAboveFifty outputs 80.

- 1 mark: Correct initial row values and correct Index progression (1 to 5) with corresponding Marks[Index] values.
- 1 mark: Correct BelowFiftyCount progression (0, 1, 2).
- 1 mark: Correct AboveFiftySum (80, 170, 240) and AboveFiftyCount (1, 2, 3) progressions.
- 1 mark: Correct calculated AverageAboveFifty as 80 and correct final OUTPUT values (2, 80).

TooCold <- 0
TooHot <- 0
Total <- 0
FOR Count <- 1 TO 10
OUTPUT "Enter temperature:"
INPUT Temp
IF Temp < 15 THEN
TooCold <- TooCold + 1
ELSE
IF Temp > 30 THEN
TooHot <- TooHot + 1
ENDIF
ENDIF
Total <- Total + Temp
NEXT Count
Average <- Total / 10
OUTPUT "Too cold count: ", TooCold
OUTPUT "Too hot count: ", TooHot
OUTPUT "Average temperature: ", Average

1 mark: Initialising variables (TooCold, TooHot, Total set to 0)
1 mark: A count-controlled loop running exactly 10 times
1 mark: Correct conditional checks for (< 15) and (> 30) and incrementing corresponding counters
1 mark: Accumulating the total and calculating the average outside the loop (Total / 10)
1 mark: Outputting the counts and average with appropriate messages

OPENFILE "passed.txt" FOR WRITE
OUTPUT "Enter student name:"
INPUT Name
WHILE Name <> "END" DO
OUTPUT "Enter student mark:"
INPUT Mark
IF Mark >= 50 THEN
WRITEFILE "passed.txt", Name
ENDIF
OUTPUT "Enter student name:"
INPUT Name
ENDWHILE
CLOSEFILE "passed.txt"

1 mark: Opening the file "passed.txt" for writing and closing it at the end using CLOSEFILE
1 mark: Inputting first student name before/at start of loop and inputting mark inside loop
1 mark: Loop with appropriate termination condition (e.g., WHILE Name <> "END")
1 mark: Correct conditional check IF Mark >= 50
1 mark: Writing only the name to the file inside the positive check branch

MaxRain <- -1
MaxDay <- 0
TotalRain <- 0
FOR Day <- 1 TO 30
TotalRain <- TotalRain + Rainfall[Day]
IF Rainfall[Day] > MaxRain THEN
MaxRain <- Rainfall[Day]
MaxDay <- Day
ENDIF
NEXT Day
OUTPUT "Maximum rainfall was: ", MaxRain, " on day ", MaxDay
OUTPUT "Total monthly rainfall was: ", TotalRain

1 mark: Initialising tracking variables (MaxRain to a low/negative value, TotalRain to 0)
1 mark: A count-controlled loop running from 1 to 30 to iterate through the array
1 mark: Correctly accumulating the TotalRain by adding each array element
1 mark: Comparing array element to MaxRain and updating both MaxRain and MaxDay with the current loop index
1 mark: Outputting the final maximum value, its index (day), and total rainfall with appropriate descriptive messages

REPEAT
OUTPUT "Please enter a secure password:"
INPUT UserPassword
LengthValid <- (LENGTH(UserPassword) = 8)
ContentValid <- (UserPassword <> "password")
IF NOT LengthValid OR NOT ContentValid THEN
OUTPUT "Invalid password. Try again."
ENDIF
UNTIL LengthValid AND ContentValid
OUTPUT "Password accepted"

1 mark: Use of a post-conditioned or pre-conditioned loop to repeat the input process
1 mark: Prompting for and inputting the password inside/at the start of the loop
1 mark: Checking the length of the password is exactly 8 characters using LENGTH()
1 mark: Checking that the password does not equal the forbidden word "password"
1 mark: Correct logical connection to exit loop only when both conditions are met, and outputting "Password accepted"

Distinctions <- 0
Fails <- 0
FOR i <- 1 TO 100
IF Scores[i] >= 75 THEN
Distinctions <- Distinctions + 1
ELSE
IF Scores[i] < 40 THEN
Fails <- Fails + 1
ENDIF
ENDIF
NEXT i
PctDist <- (Distinctions / 100) * 100
PctFail <- (Fails / 100) * 100
OUTPUT "Percentage of distinctions: ", PctDist, "%"
OUTPUT "Percentage of fails: ", PctFail, "%"

1 mark: Initialising count variables (Distinctions and Fails set to 0)
1 mark: Count-controlled loop iterating exactly 100 times (from 1 to 100)
1 mark: Correct conditional checks on array elements (Scores[i] >= 75 and Scores[i] < 40) incrementing appropriate counters
1 mark: Correct calculation of percentages outside the loop (dividing counts by 100 and multiplying by 100)
1 mark: Outputting both calculated percentages with descriptive messages

// Input and validate sector names
FOR i <- 1 TO 3
REPEAT
OUTPUT "Enter name for Sector ", i
INPUT SectorName[i]
Valid <- TRUE
IF LENGTH(SectorName[i]) < 3 THEN
Valid <- FALSE
OUTPUT "Error: Name must be at least 3 characters long."
ENDIF
// Check for uniqueness against previous entries
FOR j <- 1 TO i - 1
IF SectorName[i] = SectorName[j] THEN
Valid <- FALSE
OUTPUT "Error: Name must be unique."
ENDIF
NEXT j
UNTIL Valid = TRUE
NEXT i

// Initialize total and max rainfall tracking arrays
FOR i <- 1 TO 3
TotalRain[i] <- 0.0
MaxDayRain[i] <- 0.0
NEXT i

// Generate random daily rainfall values and calculate statistics
FOR i <- 1 TO 3
FOR day <- 1 TO 30
// Generate random real number between 0.0 and 80.0 inclusive
RainfallData[i, day] <- RANDOM() * 80.0
TotalRain[i] <- TotalRain[i] + RainfallData[i, day]

// Track the single highest daily rainfall for the tie-breaker
IF RainfallData[i, day] > MaxDayRain[i] THEN
MaxDayRain[i] <- RainfallData[i, day]
ENDIF
NEXT day
NEXT i

// Determine the overall wettest sector with tie-breaker logic
WettestIndex <- 1
FOR i <- 2 TO 3
IF TotalRain[i] > TotalRain[WettestIndex] THEN
WettestIndex <- i
ELSE
// Handle tie-breaker
IF TotalRain[i] = TotalRain[WettestIndex] THEN
IF MaxDayRain[i] > MaxDayRain[WettestIndex] THEN
WettestIndex <- i
ENDIF
ENDIF
ENDIF
NEXT i

OUTPUT "The overall wettest agricultural sector is ", SectorName[WettestIndex], " with a total rainfall of ", TotalRain[WettestIndex], " mm."

// Sort and output in descending order of total rainfall (simple bubble sort for 3 items)
Order[1] <- 1
Order[2] <- 2
Order[3] <- 3

FOR p <- 1 TO 2
FOR q <- 1 TO 2
Idx1 <- Order[q]
Idx2 <- Order[q+1]
IF TotalRain[Idx1] < TotalRain[Idx2] THEN
Temp <- Order[q]
Order[q] <- Order[q+1]
Order[q+1] <- Temp
ENDIF
NEXT q
NEXT p

OUTPUT "--- SECTOR RAINFALL REPORT (Descending Order) ---"
FOR i <- 1 TO 3
Idx <- Order[i]
OUTPUT "Sector Name: ", SectorName[Idx], " | Total Rainfall: ", TotalRain[Idx], " mm"
NEXT i

AO2: Apply knowledge and understanding (Max 9 marks)
- 7-9 marks: The range of programming techniques used is highly appropriate. All requirements are fully addressed with correct 2D array references and complex logic (tie-breaker and sorting).
- 4-6 marks: Some programming techniques used are appropriate. More than one requirement is met, but there are minor logic errors in tie-breaker, sorting, or validation.
- 1-3 marks: At least one programming technique used (e.g. basic input or 1D array iteration), but major requirements remain unaddressed.

AO3: Provide solutions to problems (Max 6 marks)
- 5-6 marks: The program is fully commented. Meaningful identifiers are used throughout. The solution is logically ordered and accurate.
- 3-4 marks: Some comments are included. Most identifiers are meaningful. The solution contains minor inaccuracies or slight structural flaws.
- 1-2 marks: Few or no comments. Identifiers are unclear and the solution structure is illogical.

Detailed breakdown of functional marks for guidance:
- R1: Input and validate sector names (Max 4 marks)
* Inputting 3 sector names in a loop.
* Validation check for minimum length (>= 3 characters).
* Validation check for uniqueness against previously entered names.
* Repetition loop to re-enter name if validation fails.
- R2: Generation and storage (Max 4 marks)
* Outer loop for sectors (1 to 3) and inner loop for days (1 to 30).
* Correct assignment to a 2D array structure: RainfallData[sector, day].
* Accumulating total rainfall for each sector.
* Correct tracking of maximum single-day rainfall for each sector.
- R3: Logic, Tie-breaker, and Sorting (Max 4 marks)
* Comparing total rainfalls to identify the maximum.
* Correct conditional block to evaluate MaxDayRain in case of a tie.
* Sorting the sectors in descending order of total rainfall.
* Outputting final sorted details and winner with appropriate text messages.

To complete this query, select the `FullName` and `ActivityType` fields from the `MemberActivity` table. The conditions in the WHERE clause must check that `DurationMinutes` is greater than 45 and that `TrainerRequired` is equal to 'No'.

```sql
SELECT FullName, ActivityType
FROM MemberActivity
WHERE DurationMinutes > 45 AND TrainerRequired = 'No';
```

One mark per correct SQL line:
- SELECT FullName, ActivityType (1 mark)
- FROM MemberActivity (1 mark)
- WHERE DurationMinutes > 45 AND TrainerRequired = 'No'; (1 mark - accept single, double, or no quotes around No; accept lowercase/uppercase SQL keywords)

(i) `ISBN` is the correct field.
(ii) An ISBN (International Standard Book Number) uniquely identifies each book published worldwide. Other fields like Title, Author, or Genre can contain duplicate values across multiple records.

- (i) 1 mark for identifying ISBN.
- (ii) 1 mark for explaining that it is a unique identifier / uniquely identifies each book record / contains no repeating or duplicate data.