2025 Cambridge IGCSE Computer Science (0478) Practice Paper with Answers

To convert the hexadecimal number A3 to denary: 1. Identify the values of each digit: A is 10, and 3 is 3. 2. Multiply by the place values: \( (10 \times 16^1) + (3 \times 16^0) \). 3. Calculate: \( 160 + 3 = 163 \).

1 mark for showing correct working (e.g. multiplying 10 by 16). 0.5 marks for the correct final answer of 163.

Image resolution is the concentration or total count of pixels in an image (for example, 1920 x 1080 pixels). Higher resolution results in more detail and larger file size.

1 mark for stating that it is the total number of pixels (or detail) that make up an image. 0.5 marks for noting how it is represented (e.g., width x height, pixels per inch, or its relation to file quality).

Full-duplex data transmission allows data to travel in both directions at the same time over the same medium, such as a telephone call or high-speed internet connection.

1 mark for identifying that transmission goes in both directions/bidirectionally. 0.5 marks for stating that this happens at the same time/simultaneously.

The Program Counter is a special-purpose register within the CPU that stores the address of the next instruction that needs to be fetched from memory for execution.

1 mark for stating that it holds/stores the memory address of the next instruction. 0.5 marks for mentioning that this is for the next fetch/execution cycle.

A check digit is a validation method designed to detect errors made during manual data entry (such as mistyping or transposing digits). A classic example is the final digit of an ISBN or a barcode.

1 mark for correctly identifying 'human data entry' or 'validation' (and not data transmission). 0.5 marks for a correct example (ISBN, EAN, barcode, or vehicle identification number).

An interrupt is a signal generated by hardware or software that alerts the CPU to suspend its current activities and execute a specific piece of code called an interrupt service routine.

1 mark for defining it as a signal sent to the CPU/processor to get attention. 0.5 marks for mentioning that it can be initiated by either hardware devices or software applications.

Spyware is malicious software installed secretly on a computer. It captures keystrokes, browsing history, and personal credentials, then transmits this sensitive information to unauthorized third parties without user consent.

1 mark for defining spyware as malware that monitors/records user actions or keystrokes without consent. 0.5 marks for explaining that it sends this private data (passwords/personal info) to an external attacker.

An actuator is an output device that takes electrical output signals from a controller/microprocessor and converts them into physical action, such as spinning a motor, opening a valve, or ringing a bell.

1 mark for explaining that it converts electrical control signals/commands into physical movement/action. 0.5 marks for providing a valid example (e.g., motor, solenoid valve, buzzer, pump).

To convert 133 to 8-bit binary: 133 = 128 + 4 + 1, which gives 10000101. To convert 10000101 to hexadecimal, split it into two 4-bit nibbles: 1000 (which is 8 in hex) and 0101 (which is 5 in hex). Combining them gives 85.

1 mark for correct binary: 10000101. 0.5 marks for correct hexadecimal: 85 (accept 85 hex, 85_16).

Simplex transmission is unidirectional. Data goes only from sender to receiver, with no path for a return signal. A microphone is a classic example as it only inputs sound data to the computer.

1 mark for definition: data is transmitted in one direction only (unidirectional). 0.5 marks for a valid device (e.g., microphone, keyboard, speaker, monitor, television broadcast antenna).

Before sending, the sender calculates a checksum value based on the bytes of the payload. This checksum is appended to the packet. Upon receipt, the receiver performs the same calculation on the data. If the calculated checksum does not match the transmitted checksum, a transmission error is flagged.

1 mark for: checksum value is calculated from the block of data (using an algorithm) and sent alongside the data. 0.5 marks for: receiver recalculates the checksum and compares it; any difference indicates an error.

During the fetch stage, the CPU looks at the Program Counter to find the address of the instruction it needs to retrieve. Once retrieved, the PC is incremented to point to the next instruction in sequence.

1 mark for: stores/holds the memory address of the next instruction. 0.5 marks for: to be fetched (and then increments).

Phishing is an email-based social engineering attack where the user is enticed to click a link. Pharming is a technical exploit that poisons DNS records or modifies host files, redirecting a user even if they type the legitimate URL directly into their browser.

1 mark for: phishing requires user interaction (clicking a link in an email/message). 0.5 marks for: pharming redirects automatically (by poisoning DNS/modifying host files, even when correct URL is typed).

An interpreter is highly beneficial during development because it translates and runs code line-by-line, stopping instantly on any error, making diagnostics straightforward. However, it is less efficient because this translation overhead happens every single time the code is executed.

1 mark for a valid advantage: easier/faster to debug (stops at error, allows real-time correction). 0.5 marks for a valid disadvantage: slower execution speed (each line must be translated on the fly).

1. Hexadecimal is much easier for humans to read, write, and remember compared to long strings of binary digits.
2. It is more compact and takes up less space on a screen (one hex digit represents four binary bits, or a nibble).
3. It reduces the likelihood of making transcription or typing errors when entering values.

One mark per correct reason, up to a maximum of 3 marks:
- Easier for humans to read/write/interpret/understand (compared to binary)
- Shorter / more compact (takes up less screen space/characters to display)
- Less chance of transcription/input errors (during typing/coding)
- Easy to convert between hexadecimal and binary (and vice versa)
(Do NOT accept 'takes up less storage space/memory')

Benefit: Data is sent faster / higher data transfer rate because multiple bits are sent simultaneously over several wires.
Drawback: Over longer distances, the bits can become out of sync (data skewing) or experience electromagnetic interference between wires (crosstalk).

One mark for a valid benefit, one mark for a valid drawback:

Benefit (max 1):
- Faster data transmission speed / higher throughput (as multiple bits are sent at the same time).
- Fits well with computer buses which are designed to handle 32-bit or 64-bit parallel data.

Drawback (max 1):
- Risk of data skewing (bits arriving at different times).
- Risk of crosstalk / interference between adjacent wires.
- More expensive to implement / physically bulkier (due to requiring multiple parallel wires/tracks).

1. At the end of each Fetch-Decode-Execute (FDE) cycle, the CPU checks if an interrupt signal has been received.
2. If an interrupt is detected, the CPU saves the contents of its current registers (including the Program Counter) onto a stack.
3. The CPU then loads the appropriate Interrupt Service Routine (ISR) / interrupt handler to process the request.
4. Once the interrupt is serviced, the saved register values are restored, and the CPU resumes the execution of the interrupted program.

One mark per valid point, up to a maximum of 3 marks:
- CPU checks for interrupts at the end of the current instruction cycle / fetch-decode-execute cycle.
- The state of the current program / registers / Program Counter (PC) is saved (to memory/stack).
- The CPU identifies the source of the interrupt.
- The CPU runs / executes the Interrupt Service Routine (ISR) / interrupt handler.
- Once completed, the previous program state is restored (from the stack) and execution resumes.

1. The microprocessor continuously receives readings from the moisture sensor (converted to digital values) and compares them with a pre-set threshold value.
2. If the moisture level is below the threshold, the microprocessor sends an electrical control signal to the actuator (the water valve) to open the valve and begin watering. (Once the desired moisture level is reached, it sends a signal to close the valve).

One mark per valid explanation point, up to a maximum of 2 marks:
- Microprocessor compares sensor values (or digital readings) against a pre-set threshold/range.
- If the readings are outside the range, the microprocessor sends an output/electrical signal to the actuator.
- The actuator physically acts / opens/closes the water valve (to start or stop water flow).

1. Before transmission, the sending device calculates a checksum value using an algorithm on the data block.
2. This calculated checksum is transmitted along with the block of data.
3. Upon receiving the data, the receiving device applies the same algorithm to the data block to calculate its own checksum.
4. The receiver compares its calculated checksum with the received checksum. If they match, the data is assumed to be error-free; if they differ, an error has occurred, and a retransmission is requested.

One mark per valid descriptive point, up to a maximum of 3 marks:
- (Sender calculates) a checksum value using an algorithm/mathematical formula on the block of data.
- The calculated checksum is transmitted with the data block.
- (On receipt) the receiving device applies the same algorithm/calculation to the received data block.
- The receiver compares the calculated checksum to the received checksum.
- If the two values do not match / differ, an error is detected (and a request to retransmit is sent).

1. SSDs have no moving parts, which makes them much more robust and durable if the laptop is dropped or bumped during transport.
2. SSDs have significantly faster read/write speeds, leading to faster boot times and quicker loading of files/applications.

One mark per correct reason, up to a maximum of 2 marks:
- SSDs have no moving parts (which makes them more robust/shock-resistant if dropped).
- Faster read/write speeds (allowing faster boot times / application loading).
- Lower power consumption (which extends the laptop's battery life).
- Generate less heat (improving performance in a compact laptop casing).
- SSDs are lighter in weight (making the laptop more portable).
- SSDs run silently (as there is no spinning platter/read-write head noise).

1. The firewall monitors all incoming and outgoing data traffic between the LAN and the external internet.
2. It compares each packet of data against a pre-defined set of security rules and criteria (such as IP addresses, protocols, or port numbers).
3. If a packet does not meet the specified criteria, the firewall blocks or filters it out, thereby preventing unauthorized access (hacking attempts) or unauthorized data transmission.

One mark per descriptive point, up to a maximum of 3 marks:
- Firewall acts as a barrier / monitors incoming and outgoing network traffic.
- Compares data/packets against a set of pre-defined rules / criteria / security policy.
- Blocks / filters out traffic/packets that violate the rules.
- Restricts access to specific ports / blocks unauthorized IP addresses.
- Can alert network administrators of suspicious activity/intrusion attempts.
- Prevents unauthorized outbound transmission of sensitive data.

Machine learning refers to the ability of a computer system to learn and adapt without following explicit, hard-coded instructions. It uses algorithms to analyze large amounts of training data, identify patterns, and make predictions or decisions based on new, unseen data.

One mark per valid point, up to a maximum of 2 marks:
- A subset of AI where systems automatically learn / improve performance from experience/data.
- Does not rely on explicit / hard-coded programming (for every eventuality).
- Uses algorithms to analyze training data / identify patterns.
- Applies learned patterns to make predictions / decisions on new/unseen data.

1. Solid State Drives (SSDs) use flash memory, which contains non-volatile NAND flash gates.
2. This technology uses floating gate transistors to store electrical charges.
3. Electrons are trapped in the floating gate; the presence or absence of trapped electrons (electric charge) represents a binary 1 or 0.
4. Controlling the flow of electricity allows data to be read, written, or erased in pages and blocks.

One mark per correct point, up to a maximum of 3 marks:
- Uses flash memory / NAND flash gates [1]
- Utilizes floating gate transistors [1]
- Electrons are trapped / blocked in a floating gate [1]
- The presence/absence of charge (trapped electrons) represents binary 0 and 1 [1]
- Data is read/written in blocks/pages [1]

1. Direct hardware control: Assembly language can access specific memory addresses and hardware registers directly, which is needed to control actuators and sensors in the robotic arm.
2. Execution speed / memory efficiency: Assembly programs compile into highly optimized machine code that runs very quickly and uses minimal RAM/storage, which is critical for real-time response.

One mark for each reason explained, up to a maximum of 2 marks:
- Allows direct control/access of hardware registers / specific memory addresses [1]
- Code executes faster / has high performance (necessary for real-time systems) [1]
- Code occupies less memory / is highly compact / efficient [1]
- No translation overhead during execution [1]

1. The temperature sensor continuously takes physical readings of the greenhouse temperature.
2. These analogue signals are converted into digital data using an Analogue-to-Digital Converter (ADC) so the microprocessor can process them.
3. The microprocessor compares the digital reading against pre-set / stored target parameters.
4. If the temperature is out of range, the microprocessor sends a control signal to an actuator (e.g., to activate a heater, fan, or open vents) to correct the temperature.

One mark per correct point, up to a maximum of 3 marks:
- Sensor continuously takes readings and sends data to the microprocessor [1]
- Analogue-to-digital converter (ADC) is used to convert the sensor's signals [1]
- Microprocessor compares the digital data with pre-set/stored values [1]
- Microprocessor sends a signal to an actuator to adjust the temperature (e.g. heater/vent/fan) [1]
- The process forms a continuous loop [1]

1. Authentication: The digital certificate is issued by a trusted Certificate Authority (CA) to verify that the website is authentic and belongs to the claimed organization, preventing spoofing.
2. Encryption: It contains the website's public key, which the browser uses to encrypt data and establish a secure symmetric key session for subsequent communications.

One mark per correct description point, up to a maximum of 2 marks:
- Authenticates / verifies the identity of the website [1]
- Issued / signed by a trusted Certificate Authority (CA) [1]
- Contains the website's public key [1]
- Used to establish a secure SSL/TLS connection / exchange session keys [1]

Matching connections:
1. 'Measures physical force applied to a specific area' connects to 'Pressure sensor'.
2. 'Detects heat radiating from objects or motion within its field of view' connects to 'Infrared sensor'.
3. 'Monitors the level of thermal energy in an environment' connects to 'Temperature sensor'.

One mark for each correct line up to a maximum of 3 marks:
- Measures physical force... -> Pressure sensor [1]
- Detects heat radiating... -> Infrared sensor [1]
- Monitors the level of thermal energy... -> Temperature sensor [1]

Matching connections:
1. 'A value calculated from the digits of a number...' connects to 'Check digit'.
2. 'An extra bit added to a byte...' connects to 'Parity check'.
3. 'A transmission control method...' connects to 'Automatic Repeat Query (ARQ)'.

One mark for each correct line up to a maximum of 3 marks:
- Calculated value appended to number -> Check digit [1]
- Extra bit added to byte -> Parity check [1]
- Acknowledgments and timeouts -> Automatic Repeat Query (ARQ) [1]

Matching connections:
1. 'Holds the memory address of the instruction...' connects to 'Memory Address Register (MAR)'.
2. 'Holds the data or instruction that has just been...' connects to 'Memory Data Register (MDR)'.
3. 'Keeps track of the memory location of the next...' connects to 'Program Counter (PC)'.

One mark for each correct line up to a maximum of 3 marks:
- Address of current memory operation -> Memory Address Register (MAR) [1]
- Data retrieved or waiting to write -> Memory Data Register (MDR) [1]
- Memory location of next instruction -> Program Counter (PC) [1]

The correct completed statements are:

The program counter holds the address of the next instruction to be retrieved from memory. When the CPU needs to read data from a specific memory location, this address is copied into the memory address register. The CPU then uses the address bus to transmit this address to memory. The data located at that address is sent back to the CPU via the data bus and is placed into the memory data register. If a mathematical calculation is required, the data is sent to the arithmetic logic unit to be processed.

Award 1 mark for each correct term in the correct position, up to a maximum of 6 marks:
1. program counter
2. memory address register
3. address bus
4. data bus
5. memory data register
6. arithmetic logic unit

Data transmission methods:
- Serial
- Simplex

Explanation:

Serial:
- Data is sent one bit at a time over a single wire.
- There is less chance of the data bits becoming skewed over the distance of the cable.
- It is more cost-effective to install as it requires fewer wires.

Simplex:
- Data only needs to be transmitted in one direction (from the wind speed sensor to the computer).
- There is no requirement for the computer to send data or instructions back to the sensor.

One mark for each correct data transmission method (Max 2 marks):
- Serial
- Simplex

Any three from (Max 3 marks):

Serial:
- Only one wire/channel is used // bits are sent one at a time // bits are sent in order.
- Less chance of data being skewed over a distance // less chance of transmission errors.
- Easier / cheaper to install over this distance.

Simplex:
- Data only needs to be sent in one direction.
- Data does not need to be sent back to the wind speed sensor.

`Borrowable` stores only True/False values, so Boolean is correct. `DateAcquired` stores calendar dates, so Date/Time is correct.

- 1 mark for `Borrowable` data type as Boolean
- 1 mark for `DateAcquired` data type as Date/Time

To display the names of the students, we use `SELECT StudentName`. To filter specifically for the 'Chess' club, we use the condition `WHERE ClubName = 'Chess'`.

- 1 mark for SELECT StudentName
- 1 mark for WHERE ClubName = 'Chess' (or ClubName = "Chess")

(i) `MemberID` uniquely identifies each club member.
(ii) `LastName` cannot be a primary key because last names can contain duplicate values (e.g., multiple members named Smith).

- 1 mark for (i) MemberID
- 1 mark for (ii) Stating that LastName is not unique / can be duplicated

1. The `FROM` keyword indicates the table from which records are selected.
2. The `WHERE` keyword is used to specify search conditions to filter the output records.

- 1 mark for 1. FROM
- 1 mark for 2. WHERE

(i) `Price` contains decimal fractional values, so `Real` is the most appropriate data type.
(ii) `StockLevel` represents whole numbers for quantity count, so `Integer` is the most appropriate data type.

- 1 mark for (i) Real
- 1 mark for (ii) Integer

Extreme test data is used to test the limits of what is acceptable by the system. In this scenario, the values 11 and 18 are the extreme valid limits, and both should be accepted. Abnormal test data represents data that is completely outside the acceptable range or of an incorrect data type. In this scenario, inputting an age of 5, 99, or a text string like 'ten' represents abnormal data, and all should be rejected by the system's validation rules.

1 mark for defining extreme test data with a correct example from the scenario (e.g., 11 or 18).
1 mark for defining abnormal test data with a correct example from the scenario (e.g., under 11, over 18, or text).
1 mark for stating that extreme data is accepted while abnormal data is rejected.

A limit check checks only one boundary (e.g., verifying only that a value is less than or equal to 100, which would incorrectly allow negative values like -5). A range check enforces two boundaries (e.g., verifying that the value is \(\ge 0\) AND \(\le 100\)), ensuring that any value outside this interval is rejected.

1 mark for explaining that a limit check only tests a single boundary / one side of the data (minimum or maximum).
1 mark for explaining that a range check validates both the lower and upper boundaries of the acceptable data range.

Validation checks if the password meets the rules set by the system (such as length or character type checks) to ensure it is secure. Verification ensures that the password entered is the one intended by the user, typically done by requiring double entry (typing the password twice) and comparing them to ensure they match exactly.

1 mark for explaining validation in this context (e.g., length check / presence check / format check).
1 mark for explaining verification in this context (e.g., double entry / re-typing the password to check for a match).
1 mark for distinguishing their purposes (validation checks against rules/criteria, verification checks against user entry errors).

To validate a telephone number, a presence check is used first to guarantee that the user has actually typed something and not skipped the field. A length check is then applied to ensure that the input contains a valid number of characters (for example, exactly 11 digits), preventing truncated or excessively long entries.

1 mark for explaining that a presence check prevents the field from being left blank / ensures data is entered.
1 mark for explaining that a length check ensures the number of characters/digits entered meets a specific limit or range (e.g., exactly 11 characters).

The correct logic expression is:
\(H = T \text{ AND } (A \text{ OR } M)\)

Alternative acceptable forms:
- \(H = (A \text{ OR } M) \text{ AND } T\)
- \(H = T \cdot (A + M)\)

1 mark for: \(A \text{ OR } M\) (or \(A + M\))
1 mark for: \(T \text{ AND } \dots\) (or \(T \cdot \dots\))
1 mark for: Correct use of brackets to group the OR operation first.

Let us evaluate \(X\) for each row:
1. \(A=0, B=0, C=0 \implies X = (0) \text{ OR } \text{NOT } (0) = 1\)
2. \(A=0, B=0, C=1 \implies X = (0) \text{ OR } \text{NOT } (0) = 1\)
3. \(A=0, B=1, C=0 \implies X = (0) \text{ OR } \text{NOT } (0) = 1\)
4. \(A=0, B=1, C=1 \implies X = (0) \text{ OR } \text{NOT } (1) = 0\)
5. \(A=1, B=0, C=0 \implies X = (0) \text{ OR } \text{NOT } (0) = 1\)
6. \(A=1, B=0, C=1 \implies X = (0) \text{ OR } \text{NOT } (0) = 1\)
7. \(A=1, B=1, C=0 \implies X = (1) \text{ OR } \text{NOT } (0) = 1\)
8. \(A=1, B=1, C=1 \implies X = (1) \text{ OR } \text{NOT } (1) = 1\)

3 marks for all 8 outputs correct (1, 1, 1, 0, 1, 1, 1, 1)
2 marks for 6 or 7 outputs correct
1 mark for 4 or 5 outputs correct

The correct logic expression is:
\(X = \text{NOT } (A \text{ OR } B) \text{ AND } C\)

Alternative acceptable forms:
- \(X = (A \text{ NOR } B) \text{ AND } C\)
- \(X = C \text{ AND } \text{NOT } (A \text{ OR } B)\)

1 mark for representing the first gate: \(\text{NOT } (A \text{ OR } B)\) or \(A \text{ NOR } B\)
1 mark for linking with the second gate: \(\dots \text{ AND } C\)
1 mark for correct grouping/brackets to ensure the NOR operation occurs before the AND operation.

Line 03: The loop condition only runs 9 times. It should be changed to Count <= 10 (or Count < 11).
Line 05: The algorithm is adding the loop counter instead of the input number. It should be changed to Total <- Total + Num.
Line 06: The count is decremented, leading to an infinite loop. It should be incremented to Count <- Count + 1.

1 mark for identifying Line 03 and its correction.
1 mark for identifying Line 05 and its correction.
1 mark for identifying Line 06 and its correction.

Line 01: Found is initialized to TRUE, meaning the loop on Line 04 will never execute. It should be initialized to FALSE.
Line 07: When the SearchValue is found, Found should be set to TRUE to stop the search and flag success. Currently, it is set to FALSE.
Line 09: Index is decremented, which will lead to an infinite loop or index error. It must be incremented: Index <- Index + 1.

1 mark for identifying Line 01 and its correction.
1 mark for identifying Line 07 and its correction.
1 mark for identifying Line 09 and its correction.

Line 03: The condition checks for a fail (< 50) rather than a pass. It should be changed to Marks[I] >= 50.
Line 05: The counter is reset to 1 rather than incremented. It should be changed to PassCount <- PassCount + 1.
Line 08: The output displays the loop variable I (which will be 51) instead of the final tally. It should be changed to OUTPUT "Number of passes: ", PassCount.

1 mark for identifying Line 03 and its correction.
1 mark for identifying Line 05 and its correction.
1 mark for identifying Line 08 and its correction.

First, the variables are initialized with `X = 22`, `Y = 6`, and `Z = 0`.
- Loop 1: Since `22 >= 6` is true, `X` becomes `22 - 6 = 16`, and `Z` becomes `0 + 1 = 1`.
- Loop 2: Since `16 >= 6` is true, `X` becomes `16 - 6 = 10`, and `Z` becomes `1 + 1 = 2`.
- Loop 3: Since `10 >= 6` is true, `X` becomes `10 - 6 = 4`, and `Z` becomes `2 + 1 = 3`.
- Loop 4: Since `4 >= 6` is false, the loop terminates.
Finally, the outputs are printed:
`Quotient: 3`
`Remainder: 4`

1 mark for correct initial values of X, Y, and Z.
1 mark for correct intermediate values of X and Z throughout the loop cycles.
1 mark for both correct output statements matching the final values.

Dry-running the loop with array values:
- Initially, `Count` is set to `0`.
- `k = 1`: `Num[1] (15) < Num[2] (10)` is false. `Count` remains `0`.
- `k = 2`: `Num[2] (10) < Num[3] (18)` is true. `Count` becomes `1`.
- `k = 3`: `Num[3] (18) < Num[4] (12)` is false. `Count` remains `1`.
- `k = 4`: `Num[4] (12) < Num[5] (14)` is true. `Count` becomes `2`.
- `k = 5`: `Num[5] (14) < Num[6] (9)` is false. `Count` remains `2`.
- Output displays `Count is 2`.

1 mark for tracking the correct increments of the loop counter `k` and variable `Count`.
1 mark for the correct final output value.

The function begins by declaring local variables and initializing HighScore to 0. It then opens the file Scores.txt for reading. Using a loop that continues until the end of the file is reached, it reads each score, compares it to the current HighScore, and updates HighScore if the read score is larger. Finally, it closes the file and returns the highest score.

1 mark: Correct function header with returns clause and matching ENDFUNCTION / RETURN statement. 1 mark: Correctly opening and closing Scores.txt. 1 mark: Correctly looping through the file using EOF and updating the highest score variable.

The function CalculateAverage is defined with the array Rainfall as a parameter. A local total variable is initialized to 0. A FOR loop runs from 1 to 12 to accumulate the sum of all elements in the array. The average is calculated by dividing the total by 12, and this average is returned.

1 mark: Correct function header with Rainfall parameter and matching RETURN/ENDFUNCTION. 1 mark: Correct loop from 1 to 12 accumulating the sum of elements. 1 mark: Correct calculation of average (Total / 12) and returning of the correct variable.

The procedure LogVisitor is defined with an integer parameter. Inside, it uses OPENFILE with the WRITE (or APPEND) option to open VisitorLog.txt. It writes the parameter value using WRITEFILE, then closes the file using CLOSEFILE.

1 mark: Correct procedure header with VisitorID parameter and matching ENDPROCEDURE. 1 mark: Opening VisitorLog.txt for write/append and closing it correctly. 1 mark: Writing the visitor ID using WRITEFILE.

The solution employs standard algorithmic structures including nested iteration, input validation using a repeat-until loop, tracking minimum and maximum values within a loop, subtraction logic to discard extreme values, nested conditional structures to categorize awards, and summation variables to keep track of statistics.

### Explanation of Core Logic:
1. **Outer & Inner Loops**: The program loops through 40 students (`StudentIndex`), and within that, loops through 5 judges (`JudgeIndex`) to fetch and store each score.
2. **Validation**: A `REPEAT...UNTIL` loop checks that the input is in the correct range of `0` to `50`. If not, an error message is printed, and the user is re-prompted.
3. **Finding High/Low**: We initialize `HighestScore` to a low value (`-1`) and `LowestScore` to a high value (`51`). For each of the 5 scores, if it exceeds the highest, we update `HighestScore`. If it is lower than the lowest, we update `LowestScore`.
4. **Discarding and Totalling**: By summing all five scores in `TotalScore` and then subtracting `HighestScore` and `LowestScore`, we accurately find the sum of the remaining three intermediate scores.
5. **Classification**: A nested `IF...THEN...ELSE` statement checks the ranges for Gold, Silver, and Participation, updating the respective award counters and outputting individual results.
6. **Final Statistics**: At the very end of the script, outside of any loops, the cumulative counts are outputted with descriptive messages.

### Marks allocated for AO2 (Apply knowledge and understanding): Max 9 marks
- **Input & Validation (3 marks)**:
- **1 mark**: Nested loop structure correctly looping through 40 students and 5 judges.
- **1 mark**: Inputting each score into the 2D array `JudgeScore[StudentIndex, JudgeIndex]`.
- **1 mark**: Validating that each score is in the range 0 to 50 inclusive using a loop or conditional structure.
- **Calculating Final Score (3 marks)**:
- **1 mark**: Initialising `TotalScore`, `HighestScore`, and `LowestScore` appropriately inside the student loop.
- **1 mark**: Correct logic to find the highest score and the lowest score among the 5 judges.
- **1 mark**: Correctly calculating `FinalScore` as the sum of the 3 intermediate scores (e.g., `TotalScore - HighestScore - LowestScore`).
- **Determining Awards & Outputs (3 marks)**:
- **1 mark**: Correct selection structure (`IF...THEN...ELSE`) to determine award category based on specified boundaries.
- **1 mark**: Correctly incrementing counters for `GoldCount`, `SilverCount`, and `ParticipationCount`.
- **1 mark**: Outputting individual student results (name + award) and final overall counters outside the loop with appropriate message strings.

### Marks allocated for AO3 (Provide solutions): Max 6 marks
- **Quality & Accuracy of Solution (6 marks)**:
- **5-6 marks**: The program is written in a highly logical sequence, is accurate, uses suitable identifiers throughout, and is fully commented. All aspects of the scenario have been fully solved.
- **3-4 marks**: The program is written in a logical order, contains only minor logical or semantic errors, uses mostly meaningful identifiers, and contains some relevant comments.
- **1-2 marks**: The program is mostly complete but contains significant logical errors, lacks relevant comments, or uses inappropriate identifier names.