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

The Program Counter (PC) holds the memory address of the next instruction to be fetched from primary storage (RAM) during the fetch–decode–execute cycle. Once the address is copied to the Memory Address Register (MAR), the PC is incremented to point to the subsequent instruction.

Award 1 mark for D (Program Counter (PC)). All other options score 0.

An 8-bit register can store values from 0 to 255 (or 2^8 - 1). When the sum of two numbers exceeds 255 (or produces a 9th carry bit), the extra most significant bit is lost or cannot be accommodated by the 8-bit register, resulting in an overflow error.

Award 1 mark for identifying that the calculation exceeds register capacity / result is greater than 255; award 1 mark for stating that the 9th bit / carry bit cannot be stored or causes an incorrect result (scaled to 1.7 marks).

ASCII uses standard 7 or 8 bits per character, limiting it to 128 or 256 unique characters (primarily English alphabet and basic punctuation). Unicode uses 16 or 32 bits per character, enabling representation of millions of characters across diverse world languages, scripts, and emojis.

Award 1 mark for comparing bit length / storage per character (e.g. Unicode uses 16/32 bits whereas ASCII uses 7/8 bits); award 1 mark for explaining that Unicode can represent more symbols/languages/characters worldwide (scaled to 1.7 marks).

A standard packet header contains essential metadata required for routing and reassembly, including the destination IP address, sender (originator) IP address, and the packet sequence/order number.

Award 1 mark for each valid item from: Destination IP address, Sender/Originator IP address, Packet sequence number / packet ID, Packet length / size (to a maximum of 2 points, scaled to 1.7 marks).

In ARQ, after transmitting a packet, the sender starts a countdown timer. If the recipient does not return a positive acknowledgement before the timeout period finishes (due to packet loss or corruption), the sender assumes the transmission failed and sends the packet again.

Award 1 mark for stating that the timeout is the predetermined waiting time for an acknowledgement; award 1 mark for stating that data is automatically resent if the timer expires before receipt of an ACK (scaled to 1.7 marks).

During the fetch stage, the address in the Program Counter is copied to the MAR. The Program Counter is then incremented by one so that it points to the subsequent instruction in memory.

Award 1 mark for holding the address of the next instruction to be fetched; award 1 mark for stating it is incremented / updated to point to the next instruction in sequence (scaled to 1.7 marks).

Upon receiving an interrupt signal, the CPU checks its priority. If accepted, it halts the current instruction sequence, stores the state and registers in memory, and jumps to the relevant Interrupt Service Routine (ISR). Once the ISR completes, the CPU restores the previous state and resumes the original task.

Award 1 mark for stating current execution is suspended and registers/state are saved; award 1 mark for stating the CPU runs the Interrupt Service Routine (ISR) / interrupt handler (scaled to 1.7 marks).

Session cookies exist only during the active browsing session and are erased when the user terminates the browser session. Persistent cookies are written to the client hard disk/storage and remain active across multiple sessions until their predefined expiration date passes or they are deleted.

Award 1 mark for session cookie deleted when browser is closed / temporary; award 1 mark for persistent cookie stored on hard disk / retained across sessions until expiry (scaled to 1.7 marks).

An expert system is composed of a knowledge base (repository of facts and data), a rule base (set of IF-THEN rules), an inference engine (the reasoning mechanism that applies rules to data), and a user interface.

Award 1 mark for each valid component from: Knowledge base, Inference engine, Rule base, User interface / explanation facility (to a maximum of 2 points, scaled to 1.7 marks).

1. The Program Counter stores the address of the next instruction to be fetched from main memory.
2. The address is transferred to the Memory Address Register (MAR).
3. The Program Counter is then incremented by 1 so that it points to the subsequent instruction in sequence.

Award 1 mark for each valid point up to a maximum of 2 marks:
- Holds / stores the memory address of the next instruction to be fetched [1]
- Increments (by 1) after the address is copied to MAR [1]

ARQ uses acknowledgements and timeouts. Retransmission is triggered if:
1. The receiver detects corrupted data and sends back a negative acknowledgement (NACK).
2. The packet (or acknowledgement) is lost in transit, causing the sender's timer to expire (timeout) before receiving any acknowledgement.

Award 1 mark for each valid point (max 2 marks):
- Receiving a negative acknowledgement / NACK [1]
- A timeout occurs / time limit expires before receiving an acknowledgement [1]

Step 1: Convert the positive magnitude \(+43\) into 8-bit binary:
\(43 = 32 + 8 + 2 + 1 = 00101011_2\)

Step 2: Invert all bits (one's complement):
\(00101011 \rightarrow 11010100\)

Step 3: Add 1 to the result (two's complement):
\(11010100 + 1 = 11010101_2\)

Alternative check using place values: \(-128 + 64 + 16 + 4 + 1 = -128 + 85 = -43\).

Award 1 mark for correct working (e.g. converting 43 to 00101011 and showing inversion / addition of 1, or correct place-value evaluation) [1]
Award 1 mark for the correct final 8-bit binary representation: 11010101 [1]

Interrupts are signals sent from a device or program to the CPU to request immediate attention. Common causes include:
- Hardware I/O completion (e.g. data transfer finished from storage)
- Hardware faults/warnings (e.g. out of paper, power fluctuation)
- Software execution errors (e.g. illegal operation, arithmetic overflow, divide by zero)
- User input events (e.g. key press or mouse click)

Award 1 mark for each valid reason up to a maximum of 2 marks:
- Hardware error / device fault (e.g. paper jam, disk read failure) [1]
- I/O operation completion / data ready to be processed [1]
- Software exception / runtime error (e.g. division by zero, null pointer) [1]
- User interaction / hardware input event (e.g. key pressed, mouse movement) [1]

Pharming is a cyber attack that modifies DNS resolution tables or local host files. When a victim types a legitimate URL into their browser, the altered DNS table translates the valid domain name into the attacker's server IP address, seamlessly redirecting the user to a bogus website designed to capture login details.

Award 1 mark for the mechanism and 1 mark for the effect/outcome:
- Malicious code alters DNS server records / local host file [1]
- When user enters a legitimate URL/domain name, they are redirected to a fraudulent/fake IP address [1]

An expert system consists of four primary components:
1. User Interface (allows interaction)
2. Knowledge Base (stores factual information and domain data)
3. Rule Base (contains IF-THEN rules and logic relationships)
4. Inference Engine (applies rules to the knowledge base to deduce solutions and make decisions)

Award 1 mark for each valid component up to a maximum of 2 marks:
- Knowledge base [1]
- Inference engine [1]
- Rule base [1]
(Do NOT accept User Interface as it is excluded in the question)

1. The web browser sends the domain name (requested by the user) to a DNS server (resolver/lookup).
2. The DNS server looks up its database of domain names and matching IP addresses.
3. The DNS server returns the specific IP address back to the user's web browser (or forwards the query to other DNS servers if not found).
4. The browser then uses this resolved IP address to establish communication and request the webpage directly from the target web server hosting the files.

Award 1 mark for each valid step explained, up to a maximum of 4 marks:
- Browser sends the domain name/URL to a DNS server [1]
- DNS server searches / queries its database / records for matching IP address [1]
- If not found locally, the request is passed/forwarded to higher-level/other DNS servers [1]
- DNS server returns the IP address to the browser [1]
- Browser uses the IP address to send a request (via HTTP/HTTPS) to the web server [1]

1. The CPU finishes executing the current instruction in the fetch-decode-execute cycle.
2. The current state and register contents (such as Program Counter and accumulator) are saved onto a stack or temporary memory area.
3. The operating system checks the priority/source of the interrupt and loads the relevant Interrupt Service Routine (ISR) / interrupt handler.
4. Once the ISR has finished execution, the saved register values and program state are restored, allowing the original task to resume seamlessly.

Award 1 mark per valid point up to a maximum of 4 marks:
- CPU completes the current execution cycle / instruction [1]
- The current contents of the registers / program state / Program Counter are saved (to a stack / memory) [1]
- The operating system / CPU determines the source / priority of the interrupt [1]
- The corresponding Interrupt Service Routine (ISR) / interrupt handler is loaded/executed [1]
- After the ISR finishes, the saved register values/state are restored [1]
- The previous process / original task resumes execution [1]

1. Asymmetric encryption uses a pair of mathematically linked but non-identical keys: a public key and a private key.
2. The receiving company distributes its public key openly to any client wishing to send files, while strictly keeping its corresponding private key confidential.
3. The client encrypts the plaintext data using the recipient's public key before sending it across the network.
4. Once encrypted, the ciphertext can only be decrypted using the corresponding private key held solely by the company, ensuring unauthorized interceptors cannot decrypt or read the file.

Award 1 mark for each valid explanation point up to a maximum of 4 marks:
- Uses a pair of mathematically linked keys / a public key and a private key [1]
- Public key is made available to everyone/the sender; private key is kept secret/confidential by the recipient [1]
- Sender/client encrypts the file/data using the recipient's public key [1]
- Only the recipient can decrypt the file using their corresponding private key [1]
- Data cannot be decrypted with the public key / unauthorized parties cannot read the ciphertext [1]

1. Storage mechanism: An SSD stores data in non-volatile flash memory using millions of microscopic transistors configured with floating gates and control gates.
2. The presence or absence of trapped electrical charge (electrons) in the floating gate alters the threshold voltage, representing binary bits (0s and 1s).
3. Durability aspect: Unlike an HDD, which relies on physical spinning magnetic platters and moving mechanical read/write actuator arms, an SSD has zero moving mechanical parts.
4. Consequently, SSDs are much more resistant to mechanical failure, physical shock, and drops (eliminating the risk of a head crash).

Award 1 mark per valid point up to a maximum of 4 marks (maximum 2 marks for operation, maximum 2 marks for durability):

Operation:
- Uses flash / non-volatile NAND memory [1]
- Uses floating gate / control gate transistors [1]
- Traps / controls electrical charge (electrons) to represent binary states / 0s and 1s [1]

Durability:
- SSD has no moving / mechanical parts [1]
- HDD has moving read/write heads / spinning magnetic platters [1]
- SSD is not vulnerable to head crashes / physical shock / dropping / vibration [1]

1. Temperature sensors continuously monitor the ambient conditions in the greenhouse and send analog data, which is converted to digital data (via an ADC) for processing.
2. The microprocessor receives the digitized data and compares it against preset target temperature thresholds stored in memory.
3. If the reading is outside the acceptable range (e.g. too cold), the microprocessor generates an output control signal sent to an actuator (e.g., activating a heating unit).
4. If the reading is too high, the microprocessor activates actuators to open motorised roof vents or run cooling fans; the entire monitoring-comparison-action cycle repeats continuously.

Award 1 mark per valid point up to a maximum of 4 marks:
- Temperature sensor measures/records the environmental temperature continuously [1]
- Sensor sends data to the microprocessor (ADC converts analogue sensor data to digital) [1]
- Microprocessor compares received reading with preset / stored threshold value(s) [1]
- If temperature is below threshold, microprocessor signals an actuator to turn on heating [1]
- If temperature is above threshold, microprocessor signals an actuator to open vents / turn on cooling fans [1]
- The process repeats continuously / in a loop [1]

1. Sample rate refers to how many audio samples are captured per second (measured in Hz/kHz). A higher sample rate samples the analogue wave more frequently, reproducing the original analogue waveform more accurately and resulting in higher sound quality.
2. Sample resolution (bit depth) refers to the number of bits allocated per sample. A higher sample resolution provides more discrete amplitude levels, resulting in closer approximation of volume levels and higher fidelity.
3. File size is directly proportional to both parameters (File size = sample rate × sample resolution × duration × number of channels).
4. Increasing either sample rate or sample resolution causes more data bits to be stored per unit of time, which increases the total file size.

Award 1 mark per valid point up to a maximum of 4 marks:
- Sample rate: increasing sample rate captures more samples per second / closer approximation to original wave / improves quality [1]
- Sample resolution: increasing sample resolution allocates more bits per sample / gives finer amplitude levels / reduces quantization error / improves quality [1]
- Increasing sample rate increases the total number of samples stored, thus increasing file size [1]
- Increasing sample resolution increases bits stored per sample, thus increasing file size [1]
- Stating the relationship: higher quality / fidelity leads to larger file size (or vice versa) [1]

1. Program Counter (PC) holds the memory address of the next instruction to be fetched.
2. Memory Address Register (MAR) receives the address from the PC.
3. Address bus carries the memory address from the MAR to primary storage (RAM).
4. Memory Data Register (MDR) temporarily stores the instruction fetched from RAM.
5. Current Instruction Register (CIR) holds the fetched instruction ready for the Control Unit to decode.

1 mark for each correct term placed in the corresponding gap:
• (1) Program Counter / PC [1]
• (2) Memory Address Register / MAR [1]
• (3) Address bus [1]
• (4) Memory Data Register / MDR [1]
• (5) Current Instruction Register / CIR [1]

Method 1 (Invert and add 1):
1. Convert positive \(+77\) to 8-bit binary: \(64 + 8 + 4 + 1 = 01001101\).
2. Invert all bits (one's complement): \(10110010\).
3. Add 1 to get two's complement: \(10110010 + 1 = 10110011\).

Method 2 (Place values):
Place values: \(-128, 64, 32, 16, 8, 4, 2, 1\)
\(-128 + 32 + 16 + 2 + 1 = -77\)
Binary: \(10110011\).

1 mark for correct method shown (e.g. converting \(+77\) to \(01001101\) and inverting/adding 1, or correct place value addition).
0.75 marks for the correct final 8-bit binary value: 10110011.

Method 1 (Direct place value calculation):
Place value weights: \(-128, 64, 32, 16, 8, 4, 2, 1\)
Bits: \(1, 1, 0, 1, 0, 1, 1, 0\)
Calculation: \(-128 + 64 + 16 + 4 + 2 = -128 + 86 = -42\).

Method 2 (Invert and add 1 to find magnitude):
1. Invert bits: \(00101001\)
2. Add 1: \(00101010_2 = 32 + 8 + 2 = 42\)
3. Apply negative sign: \(-42\).

1 mark for showing valid working (e.g. \(-128 + 64 + 16 + 4 + 2\) or inverting and adding 1 to get \(+42\)).
0.75 marks for the correct final denary answer: -42.

Method 1 (Invert and add 1):
1. Convert positive \(+105\) to 8-bit binary: \(64 + 32 + 8 + 1 = 01101001\).
2. Invert all bits (one's complement): \(10010110\).
3. Add 1 to the result: \(10010110 + 1 = 10010111\).

Method 2 (Place values):
Place values: \(-128, 64, 32, 16, 8, 4, 2, 1\)
\(-128 + 16 + 4 + 2 + 1 = -105\)
Binary: \(10010111\).

1 mark for correct method shown (e.g. converting \(+105\) to \(01101001\) and inverting bits, or using \(-128\) base weight).
0.75 marks for the correct final 8-bit binary value: 10010111.

Method 1 (Direct place value calculation):
Place value weights: \(-128, 64, 32, 16, 8, 4, 2, 1\)
Bits: \(1, 0, 1, 0, 1, 1, 0, 0\)
Calculation: \(-128 + 32 + 8 + 4 = -128 + 44 = -84\).

Method 2 (Invert and add 1):
1. Invert bits: \(01010011\)
2. Add 1: \(01010100_2 = 64 + 16 + 4 = 84\)
3. Apply negative sign: \(-84\).

1 mark for showing correct working (e.g. \(-128 + 32 + 8 + 4\) or inverting and adding 1 to find \(84\)).
0.75 marks for the correct final denary answer: -84.

In Cambridge IGCSE pseudocode, string indexing begins at position 1. The function `SUBSTRING(string, start, length)` extracts a substring beginning at character index `start` for a total of `length` characters.

In the string `"CHEMISTRY"`:
- Index 1: `C`
- Index 2: `H`
- Index 3: `E`
- Index 4: `M`
- Index 5: `I`
- Index 6: `S`
- Index 7: `T`
- Index 8: `R`
- Index 9: `Y`

Starting at index 3 with a length of 4 characters extracts indices 3, 4, 5, and 6, which gives `"EMIS"`.

1 mark for A ("EMIS").
Accept only A.

To select only the description and unit price, the `SELECT` clause must specify `Description, UnitPrice`.
The table is specified by `FROM PRODUCT`.
The condition to filter for the category 'Electronics' is `WHERE Category = 'Electronics'`.
To order results from highest price to lowest price (descending order), the clause is `ORDER BY UnitPrice DESCENDING`.

Therefore, the correct SQL query is:
`SELECT Description, UnitPrice FROM PRODUCT WHERE Category = 'Electronics' ORDER BY UnitPrice DESCENDING;`

1 mark for A.
Accept only A.

(a) The count of students is a whole number with no fractional part, so INTEGER is required.
(b) The mass contains a fractional/decimal component, so REAL is required.
(c) A single character enclosed in quotes is represented by CHAR.
(d) A flag indicating one of two states (TRUE or FALSE) is represented by BOOLEAN.

1 mark for each correct data type:
(a) INTEGER
(b) REAL
(c) CHAR (accept CHARACTER)
(d) BOOLEAN

Validation checks if input data follows set criteria (e.g. range, type, length, presence) automatically by the system. Verification checks that data input is identical to the source document, performed either by double data entry or visual checking.

1 mark for a correct explanation of validation:
- Automated check / check by software to ensure data is acceptable / sensible / within rules / valid format.

1 mark for a correct explanation of verification:
- Check that data matches the original source / is entered correctly without transcription errors (e.g., via visual check or double entry).

Note: Reject answers stating validation checks that data is 'correct' or 'true'.

A primary key ensures every record has a unique identifier so that specific rows can be referenced and retrieved unambiguously. Surnames cannot serve this purpose because two or more distinct individuals may share the exact same surname, violating the uniqueness constraint.

1 mark for stating the purpose:
- Uniquely identifies each record / row / entity in a table.

1 mark for the reason:
- Surnames are not unique / duplicates can exist / different people can share the same surname.

A FOR loop is predetermined (fixed iterations), whereas a WHILE loop is condition-controlled and checks the condition at the start, meaning it will not execute at all if the initial condition is false.

1 mark for FOR loop:
- When the number of iterations / repetitions is known / fixed in advance.

1 mark for WHILE loop:
- When the number of iterations is unknown / depends on a condition (being met) / when the loop body might need to execute zero times.

(a) Opening a file in WRITE mode truncates the file, clearing any previous contents.
(b) Closing a file flushes write buffers to disk, prevents file locking or corruption, and releases operating system resources.

(a) 1 mark for:
- Existing data is deleted / overwritten / wiped / lost / a new empty file is created.

(b) 1 mark for any one of:
- To save / write all buffered data to storage / disk.
- To release system memory / file handle / allow other processes to access the file.
- To prevent data loss / corruption.

(a) The total number of characters in "CS2026P2" is 8.
(b) SUBSTRING starting at index 3 with length 4 extracts characters at positions 3, 4, 5, and 6: "2026".
(c) SUBSTRING at index 1 with length 2 extracts "CS", and LCASE converts it to lowercase: "cs".

1 mark for each correct result:
(a) 8
(b) "2026" (accept 2026)
(c) "cs" (quotes optional, must be lowercase)

Step-by-step execution for `Num = 7283`:
1. Initialisation: `Count <- 0`, `Num <- 7283`.
2. Iteration 1:
- `Num > 0` is `TRUE`
- `Rem <- MOD(7283, 10) = 3`
- `3 > 4` is `FALSE` (`Count` remains `0`)
- `Num <- DIV(7283, 10) = 728`
3. Iteration 2:
- `Num > 0` is `TRUE`
- `Rem <- MOD(728, 10) = 8`
- `8 > 4` is `TRUE` -> `Count <- 0 + 1 = 1`
- `Num <- DIV(728, 10) = 72`
4. Iteration 3:
- `Num > 0` is `TRUE`
- `Rem <- MOD(72, 10) = 2`
- `2 > 4` is `FALSE` (`Count` remains `1`)
- `Num <- DIV(72, 10) = 7`
5. Iteration 4:
- `Num > 0` is `TRUE`
- `Rem <- MOD(7, 10) = 7`
- `7 > 4` is `TRUE` -> `Count <- 1 + 1 = 2`
- `Num <- DIV(7, 10) = 0`
6. Loop terminates as `Num > 0` is `FALSE`.
7. `OUTPUT "Result: ", 2`

Trace table rows:
| Num | Count | Rem | OUTPUT |
| --- | --- | --- | --- |
| 7283 | 0 | | |
| 728 | | 3 | |
| 72 | 1 | 8 | |
| 7 | | 2 | |
| 0 | 2 | 7 | |
| | | | Result: 2 |

1 mark for correct values in `Rem` column in correct order (3, 8, 2, 7).
1 mark for correct sequence of values in `Num` column (7283, 728, 72, 7, 0).
1 mark for correct sequence of values in `Count` column (0, 1, 2).
0.5 marks for correct final output `Result: 2` (allow `2` or `"Result: ", 2`).

Step-by-step execution:
1. Initialisation: `Total <- 0`
2. `Index = 1`:
- `CurrentVal <- Values[1] = 12`
- `MOD(12, 3) = 0` (condition `TRUE`)
- `Total <- 0 + 12 = 12`
3. `Index = 2`:
- `CurrentVal <- Values[2] = 5`
- `MOD(5, 3) = 2 <> 0` (condition `FALSE`, `Total` unchanged)
4. `Index = 3`:
- `CurrentVal <- Values[3] = 18`
- `MOD(18, 3) = 0` (condition `TRUE`)
- `Total <- 12 + 18 = 30`
5. `Index = 4`:
- `CurrentVal <- Values[4] = 7`
- `MOD(7, 3) = 1 <> 0` (condition `FALSE`, `Total` unchanged)
6. `Index = 5`:
- `CurrentVal <- Values[5] = 14`
- `MOD(14, 3) = 2 <> 0` (condition `FALSE`, `Total` unchanged)
7. Loop ends, `OUTPUT 30`.

Trace Table:
| Index | CurrentVal | Total | OUTPUT |
| --- | --- | --- | --- |
| | | 0 | |
| 1 | 12 | 12 | |
| 2 | 5 | | |
| 3 | 18 | 30 | |
| 4 | 7 | | |
| 5 | 14 | | |
| | | | 30 |

1 mark for correct `Index` values from 1 to 5 and corresponding `CurrentVal` values (12, 5, 18, 7, 14).
1 mark for initial `Total` of 0 and correct updates to `Total` (12, 30).
1 mark for no incorrect updates in `Total` on iterations where condition is false.
0.5 marks for correct final output `30`.

Step-by-step evaluation for each input combination:

1. $\text{A}=0, \text{B}=0, \text{C}=0$:
- $(\text{A} \text{ OR } \text{NOT } \text{B}) = (0 \text{ OR } 1) = 1$
- $(\text{B} \text{ XOR } \text{C}) = (0 \text{ XOR } 0) = 0$
- $X = 1 \text{ AND } 0 = 0$

2. $\text{A}=0, \text{B}=0, \text{C}=1$:
- $(\text{A} \text{ OR } \text{NOT } \text{B}) = (0 \text{ OR } 1) = 1$
- $(\text{B} \text{ XOR } \text{C}) = (0 \text{ XOR } 1) = 1$
- $X = 1 \text{ AND } 1 = 1$

3. $\text{A}=0, \text{B}=1, \text{C}=0$:
- $(\text{A} \text{ OR } \text{NOT } \text{B}) = (0 \text{ OR } 0) = 0$
- $(\text{B} \text{ XOR } \text{C}) = (1 \text{ XOR } 0) = 1$
- $X = 0 \text{ AND } 1 = 0$

4. $\text{A}=0, \text{B}=1, \text{C}=1$:
- $(\text{A} \text{ OR } \text{NOT } \text{B}) = (0 \text{ OR } 0) = 0$
- $(\text{B} \text{ XOR } \text{C}) = (1 \text{ XOR } 1) = 0$
- $X = 0 \text{ AND } 0 = 0$

5. $\text{A}=1, \text{B}=0, \text{C}=0$:
- $(\text{A} \text{ OR } \text{NOT } \text{B}) = (1 \text{ OR } 1) = 1$
- $(\text{B} \text{ XOR } \text{C}) = (0 \text{ XOR } 0) = 0$
- $X = 1 \text{ AND } 0 = 0$

6. $\text{A}=1, \text{B}=0, \text{C}=1$:
- $(\text{A} \text{ OR } \text{NOT } \text{B}) = (1 \text{ OR } 1) = 1$
- $(\text{B} \text{ XOR } \text{C}) = (0 \text{ XOR } 1) = 1$
- $X = 1 \text{ AND } 1 = 1$

7. $\text{A}=1, \text{B}=1, \text{C}=0$:
- $(\text{A} \text{ OR } \text{NOT } \text{B}) = (1 \text{ OR } 0) = 1$
- $(\text{B} \text{ XOR } \text{C}) = (1 \text{ XOR } 0) = 1$
- $X = 1 \text{ AND } 1 = 1$

8. $\text{A}=1, \text{B}=1, \text{C}=1$:
- $(\text{A} \text{ OR } \text{NOT } \text{B}) = (1 \text{ OR } 0) = 1$
- $(\text{B} \text{ XOR } \text{C}) = (1 \text{ XOR } 1) = 0$
- $X = 1 \text{ AND } 0 = 0$

Final completed table column $X$:
$$\begin{array}{|c|c|c|c|c|}
\hline
\textbf{A} & \textbf{B} & \textbf{C} & \textbf{Working space} & \textbf{X} \\
\hline
0 & 0 & 0 & 1 \text{ AND } 0 & \mathbf{0} \\
\hline
0 & 0 & 1 & 1 \text{ AND } 1 & \mathbf{1} \\
\hline
0 & 1 & 0 & 0 \text{ AND } 1 & \mathbf{0} \\
\hline
0 & 1 & 1 & 0 \text{ AND } 0 & \mathbf{0} \\
\hline
1 & 0 & 0 & 1 \text{ AND } 0 & \mathbf{0} \\
\hline
1 & 0 & 1 & 1 \text{ AND } 1 & \mathbf{1} \\
\hline
1 & 1 & 0 & 1 \text{ AND } 1 & \mathbf{1} \\
\hline
1 & 1 & 1 & 1 \text{ AND } 0 & \mathbf{0} \\
\hline
\end{array}$$

4 marks total:
- 4 marks for all 8 correct outputs in column X
- 3 marks for 6 or 7 correct outputs
- 2 marks for 4 or 5 correct outputs
- 1 mark for 2 or 3 correct outputs
- 0 marks for 0 or 1 correct output

Correct output sequence for X: 0, 1, 0, 0, 0, 1, 1, 0

(a) Deriving the logic expression:
- First condition: movement detected AND system armed $\rightarrow (M \text{ AND } S)$
- Second condition: door open AND system armed AND movement NOT detected $\rightarrow (D \text{ AND } S \text{ AND NOT } M)$
- Combined with OR: $X = (M \text{ AND } S) \text{ OR } (D \text{ AND } S \text{ AND NOT } M)$

(b) Completing the truth table:
- Row 1 ($0, 0, 0$): $(0 \text{ AND } 0) \text{ OR } (0 \text{ AND } 0 \text{ AND } 1) = 0 \text{ OR } 0 = 0$
- Row 2 ($0, 0, 1$): $(0 \text{ AND } 1) \text{ OR } (0 \text{ AND } 1 \text{ AND } 1) = 0 \text{ OR } 0 = 0$
- Row 3 ($0, 1, 0$): $(0 \text{ AND } 0) \text{ OR } (1 \text{ AND } 0 \text{ AND } 1) = 0 \text{ OR } 0 = 0$
- Row 4 ($0, 1, 1$): $(0 \text{ AND } 1) \text{ OR } (1 \text{ AND } 1 \text{ AND } 1) = 0 \text{ OR } 1 = 1$
- Row 5 ($1, 0, 0$): $(1 \text{ AND } 0) \text{ OR } (0 \text{ AND } 0 \text{ AND } 0) = 0 \text{ OR } 0 = 0$
- Row 6 ($1, 0, 1$): $(1 \text{ AND } 1) \text{ OR } (0 \text{ AND } 1 \text{ AND } 0) = 1 \text{ OR } 0 = 1$
- Row 7 ($1, 1, 0$): $(1 \text{ AND } 0) \text{ OR } (1 \text{ AND } 0 \text{ AND } 0) = 0 \text{ OR } 0 = 0$
- Row 8 ($1, 1, 1$): $(1 \text{ AND } 1) \text{ OR } (1 \text{ AND } 1 \text{ AND } 0) = 1 \text{ OR } 0 = 1$

Completed table:
$$\begin{array}{|c|c|c|c|}
\hline
\textbf{M} & \textbf{D} & \textbf{S} & \textbf{X} \\
\hline
0 & 0 & 0 & \mathbf{0} \\
\hline
0 & 0 & 1 & \mathbf{0} \\
\hline
0 & 1 & 0 & \mathbf{0} \\
\hline
0 & 1 & 1 & \mathbf{1} \\
\hline
1 & 0 & 0 & \mathbf{0} \\
\hline
1 & 0 & 1 & \mathbf{1} \\
\hline
1 & 1 & 0 & \mathbf{0} \\
\hline
1 & 1 & 1 & \mathbf{1} \\
\hline
\end{array}$$

(a) 2 marks:
- 1 mark for $(M \text{ AND } S)$
- 1 mark for $(D \text{ AND } S \text{ AND NOT } M)$ correctly joined with $\text{OR}$
Accept equivalent correct expressions such as: $X = (M \text{ AND } S) \text{ OR } ((D \text{ AND } S) \text{ AND NOT } M)$

(b) 2 marks:
- 2 marks for all 8 rows correct (0, 0, 0, 1, 0, 1, 0, 1)
- 1 mark for 6 or 7 rows correct

To construct the SQL statement according to the requirements:

1. SELECT clause: We need to output the plant name and price.
`SELECT PlantName, Price`

2. FROM clause: The data is retrieved from the `PLANT_STOCK` table.
`FROM PLANT_STOCK`

3. WHERE clause: We must filter for plants of type `'Perennial'` AND a stock level of at least 10 (≥ 10 or > 9).
`WHERE PlantType = 'Perennial'`
`AND QuantityInStock >= 10`

4. ORDER BY clause: The list must be sorted by price in ascending order.
`ORDER BY Price ASCENDING` (or `ORDER BY Price ASC` / `ORDER BY Price`)

1 mark per correct line / section (total 5 marks):

- 1 mark for `PlantName, Price` (accept fields in either order)
- 1 mark for `PLANT_STOCK`
- 1 mark for `PlantType = 'Perennial'` (accept double quotes `"Perennial"`)
- 1 mark for `AND QuantityInStock >= 10` (accept `AND QuantityInStock > 9`)
- 1 mark for `Price ASCENDING` (accept `Price ASC` or `Price`)

Note: SQL keywords are case-insensitive. Allow follow-through if WHERE and AND lines are swapped or written on one line.

```text
// Alternative 1: REPEAT ... UNTIL loop
REPEAT
OUTPUT "Enter mark (0 - 100): "
INPUT Mark
IF Mark < 0 OR Mark > 100 THEN
OUTPUT "Invalid mark, please re-enter"
ENDIF
UNTIL Mark >= 0 AND Mark <= 100
OUTPUT "Mark accepted"

// Alternative 2: WHILE loop
OUTPUT "Enter mark (0 - 100): "
INPUT Mark
WHILE Mark < 0 OR Mark > 100 DO
OUTPUT "Invalid mark, please re-enter"
INPUT Mark
ENDWHILE
OUTPUT "Mark accepted"
```

1 mark for each point (max 4 marks):
- 1 mark: Initial prompt and `INPUT` of mark.
- 1 mark: Correct loop structure (e.g. `REPEAT ... UNTIL` or `WHILE ... DO`) with correct condition to continue while invalid / stop when valid.
- 1 mark: Correct conditional check and output of error message `"Invalid mark, please re-enter"` when `Mark < 0 OR Mark > 100`.
- 1 mark: Output of `"Mark accepted"` only after exiting the loop.

```text
DECLARE Count : INTEGER
DECLARE Total : REAL
DECLARE Day : INTEGER

Count <- 0
Total <- 0.0
FOR Day <- 1 TO 30
IF DailyRainfall[Day] > 15.0 THEN
Count <- Count + 1
Total <- Total + DailyRainfall[Day]
ENDIF
NEXT Day
OUTPUT "Days with rainfall > 15mm: ", Count
OUTPUT "Total rainfall on these days: ", Total
```

1 mark for each point (max 4 marks):
- 1 mark: Initialising both `Count` and `Total` to zero before the loop.
- 1 mark: Correct loop iterating through the array from 1 to 30 (`FOR Day <- 1 TO 30 ... NEXT Day`).
- 1 mark: Correct `IF` condition (`DailyRainfall[Day] > 15.0`) with correct incrementing of `Count` and accumulation of `Total`.
- 1 mark: Output of both final `Count` and `Total` outside the loop with appropriate text messages.

```text
FUNCTION CountVowels(Sentence : STRING) RETURNS INTEGER
DECLARE NumVowels, Index : INTEGER
DECLARE NextChar : CHAR

NumVowels <- 0
FOR Index <- 1 TO LENGTH(Sentence)
NextChar <- UCASE(SUBSTRING(Sentence, Index, 1))
IF NextChar = 'A' OR NextChar = 'E' OR NextChar = 'I' OR NextChar = 'O' OR NextChar = 'U' THEN
NumVowels <- NumVowels + 1
ENDIF
NEXT Index
RETURN NumVowels
ENDFUNCTION
```

1 mark for each point (max 4 marks):
- 1 mark: Correct function header with parameter and `RETURNS INTEGER`, and closing `ENDFUNCTION`.
- 1 mark: Initialising counter variable to 0 and loop iterating from 1 to `LENGTH(Sentence)`.
- 1 mark: Extracting single character using `SUBSTRING` and checking if vowel (handling uppercase/lowercase, e.g. via `UCASE` or checking both sets) and incrementing counter.
- 1 mark: `RETURN` statement returning the vowel counter value.

```text
DECLARE Score, Total, Count : INTEGER
DECLARE Average : REAL

OPENFILE "Scores.txt" FOR READ
Total <- 0
Count <- 0
READFILE "Scores.txt", Score
WHILE Score <> -1 DO
Total <- Total + Score
Count <- Count + 1
READFILE "Scores.txt", Score
ENDWHILE
CLOSEFILE "Scores.txt"

Average <- Total / Count
OUTPUT "The average score is: ", Average
```

1 mark for each point (max 4 marks):
- 1 mark: `OPENFILE "Scores.txt" FOR READ` and `CLOSEFILE "Scores.txt"` correctly placed.
- 1 mark: Reading initial value with `READFILE` and repeating with a `WHILE Score <> -1` loop reading subsequent values.
- 1 mark: Totalling the scores and counting the number of scores inside the loop.
- 1 mark: Correctly calculating average (`Total / Count`) after loop and outputting it with a suitable message.

// Declare arrays
DECLARE CamperName : ARRAY[1:40] OF STRING
DECLARE CamperAge : ARRAY[1:40] OF INTEGER
DECLARE CamperSport : ARRAY[1:40] OF STRING
DECLARE CamperFee : ARRAY[1:40] OF REAL

// Declare variables
DECLARE Index : INTEGER
DECLARE TotalRevenue : REAL
DECLARE TotalAge : INTEGER
DECLARE AverageAge : REAL
DECLARE CountTennis : INTEGER
DECLARE CountSwimming : INTEGER
DECLARE CountAthletics : INTEGER
DECLARE MaxFee : REAL

// Initialise summary variables
TotalRevenue <- 0.0
TotalAge <- 0
CountTennis <- 0
CountSwimming <- 0
CountAthletics <- 0
MaxFee <- 0.0

// 1. Input, validation, fee calculation and array storage
FOR Index <- 1 TO 40
// Input and validate name
REPEAT
OUTPUT "Enter name for camper ", Index, ": "
INPUT CamperName[Index]
UNTIL CamperName[Index] <> ""

// Input and validate age
REPEAT
OUTPUT "Enter age (7-14) for camper ", Index, ": "
INPUT CamperAge[Index]
UNTIL CamperAge[Index] >= 7 AND CamperAge[Index] <= 14

// Input and validate sport code
REPEAT
OUTPUT "Enter sport code (T for Tennis, S for Swimming, A for Athletics): "
INPUT CamperSport[Index]
UNTIL CamperSport[Index] = "T" OR CamperSport[Index] = "S" OR CamperSport[Index] = "A"

// 2. Fee Calculation
CamperFee[Index] <- 120.00
IF CamperAge[Index] < 10 THEN
CamperFee[Index] <- CamperFee[Index] - 15.00
ENDIF
IF CamperSport[Index] = "T" THEN
CamperFee[Index] <- CamperFee[Index] + 20.00
ENDIF

// Accumulate totals and counts
TotalRevenue <- TotalRevenue + CamperFee[Index]
TotalAge <- TotalAge + CamperAge[Index]

IF CamperSport[Index] = "T" THEN
CountTennis <- CountTennis + 1
ELSE
IF CamperSport[Index] = "S" THEN
CountSwimming <- CountSwimming + 1
ELSE
CountAthletics <- CountAthletics + 1
ENDIF
ENDIF

// Track maximum fee
IF CamperFee[Index] > MaxFee THEN
MaxFee <- CamperFee[Index]
ENDIF
NEXT Index

// 3. Display individual camper records
OUTPUT "--- CAMPER DETAILS ---"
FOR Index <- 1 TO 40
OUTPUT "Name: ", CamperName[Index], " | Age: ", CamperAge[Index], " | Sport: ", CamperSport[Index], " | Fee: $", CamperFee[Index]
NEXT Index

// Calculate average age
AverageAge <- TotalAge / 40.0

// Display summary statistics
OUTPUT "--- SUMMARY STATISTICS ---"
OUTPUT "Total revenue collected: $", TotalRevenue
OUTPUT "Average age of campers: ", AverageAge
OUTPUT "Campers in Tennis: ", CountTennis
OUTPUT "Campers in Swimming: ", CountSwimming
OUTPUT "Campers in Athletics: ", CountAthletics

// Display camper(s) with the highest fee
OUTPUT "Camper(s) paying the highest fee of $", MaxFee, ":"
FOR Index <- 1 TO 40
IF CamperFee[Index] = MaxFee THEN
OUTPUT CamperName[Index]
ENDIF
NEXT Index

Marking is split into two assessment objectives: AO2 (Application & Technique - 9 marks) and AO3 (Evaluation, Logic & Structure - 6 marks).

### AO2: Specific Functional Marks (Max 9 marks)
- Input & Validation (3 marks):
- 1 mark: Loop with presence check for non-empty camper name.
- 1 mark: Loop with range check for age (≥ 7 AND ≤ 14).
- 1 mark: Loop validating sport code ("T", "S", or "A").
- Fee Calculation & Storage (2 marks):
- 1 mark: Base fee ($120) adjusted correctly for age < 10 (-$15) and Tennis (+$20).
- 1 mark: Correctly storing name, age, sport code, and calculated fee in parallel arrays.
- Totals & Counting (2 marks):
- 1 mark: Totalling overall revenue and accumulating age/counting per sport.
- 1 mark: Correct calculation of average age (`TotalAge / 40`).
- Output & Highest Fee Search (2 marks):
- 1 mark: Iterating and displaying individual camper details and summary statistics.
- 1 mark: Correct algorithm to identify and output the name(s) of camper(s) paying the maximum fee.

### AO3: Programming Logic & Structure (Max 6 marks)
- Level 3 (5–6 marks):
- The algorithm is fully functional, robust, and well-structured.
- Appropriate control structures (FOR, REPEAT...UNTIL / WHILE, IF/CASE) used effectively.
- Meaningful identifier names throughout, clear comments, and consistent indentation.
- Level 2 (3–4 marks):
- The algorithm addresses most requirements but may have minor logical flaws (e.g., slight off-by-one errors or minor logic omissions in max search).
- Readable code with mostly consistent naming conventions and structure.
- Level 1 (1–2 marks):
- Partial solution addressing only isolated parts of the scenario.
- Weak control structures, syntax inconsistent with standard pseudocode, lack of commenting/indentation.
- 0 marks: No creditable response.