2026 Cambridge IAS-Level Computer Science (9618) Practice Paper with Answers

A digital graphic designer is creating icons for a mobile operating system.

Define the term colour depth in the context of bitmap images, and describe the effect that increasing colour depth has on the image representation and file storage requirements.

An enterprise local area network (LAN) uses IPv4 addressing across multiple departments.

Explain the purpose of a subnet mask in an IPv4 network, and describe how it is used by a host device to determine whether a destination IP address is on the local network.

A desktop computer is sending print jobs to an external laser printer connected via USB.

Define the term buffer in the context of computer hardware, and explain why a buffer is required when data is transferred between the CPU and the printer.

During the execution of a user application, a hardware sensor raises an interrupt signal.

Describe the role of the Interrupt Service Routine (ISR) and explain how the CPU state is preserved before the ISR executes.

Software developers often link pre-compiled libraries when building desktop applications.

Define what is meant by a Dynamic Link Library (DLL) and state two advantages of using dynamic linking compared to static linking.

A student registration portal requires applicants to submit personal contact details and academic grades.

Distinguish between data validation and data verification, and give one distinct example method for each.

An independent software vendor distributes a photo-editing tool under a shareware licence model.

State what is meant by shareware and describe two typical restrictions or conditions associated with this type of software licence.

A relational database contains two tables: `Course` and `Enrolment`.

Define the term referential integrity, and explain how foreign keys are used to enforce referential integrity between related tables.

A digital archive converts scanned monochrome technical schematics into digital files and uses Run-Length Encoding (RLE) to reduce storage requirements.

(a) Define the term lossless compression. [1]
(b) Explain how Run-Length Encoding (RLE) reduces the file size of consecutive repeating data. [1.5]

A software company distributes an enterprise system that makes use of Dynamic Link Library (DLL) files.

(a) Define what is meant by a Dynamic Link Library (DLL) file. [1]
(b) State one advantage and one disadvantage of using DLL files rather than static libraries. [1.5]

A microprocessor unit in an automated ventilation system monitors environmental variables and processes numeric data in different formats.

(a) Convert the denary integer -77 into an 8-bit two's complement binary number. Show your working. [2]

(b) The system registers a sensor code given as the hexadecimal value 5E.

(i) Convert the hexadecimal value 5E into denary. [1]
(ii) Convert the hexadecimal value 5E into Binary Coded Decimal (BCD). [1]

A high-altitude weather monitoring station records sensor values and transmits status bytes to a ground base.

(a) The processor uses 8-bit two's complement representation for temperature calculations. Perform binary addition on the following two 8-bit signed integers:

01001100
+ 00111010

State whether an arithmetic overflow has occurred and justify your answer. [2]

(b) A diagnostic status byte is received as the binary value 11011011.

(i) Convert 11011011 to hexadecimal. [1]
(ii) Convert 11011011 to an unsigned denary integer. [1]

A wildlife research organisation uses a relational database to store information about field researchers and research expeditions.

The database has the following logical schema:

`RESEARCHER(ResearcherID, FirstName, LastName, Department, ContactNumber)`
`EXPEDITION(ExpeditionID, LocationName, StartDate, Budget, ResearcherID)`

(a) Write an SQL script to create the table `EXPEDITION`. Use appropriate data types for each attribute, and include the primary key and foreign key definitions. [3]

(b) Write an SQL query to display the `LocationName` and `Budget` of all expeditions led by researchers in the `'Marine Biology'` department. The results must be sorted in descending order of `Budget`. [2]

An astronomical observatory maintains a relational database to record information about telescopes and observation sessions.

The database includes the following two tables:

`TELESCOPE(TelescopeID, ModelName, ApertureSize, Location)`
`OBSERVATION(ObservationID, TargetObject, ObservationDate, DurationMinutes, TelescopeID)`

(a) Write an SQL script to alter the `TELESCOPE` table by adding a new attribute named `IsOperational` of data type `BOOLEAN`. [1]

(b) Write an SQL script to update the `DurationMinutes` to `120` for the record where `ObservationID` is `'OBS1042'`. [1]

(c) Write an SQL query to display the `ModelName` of each telescope and the total number of observations recorded for that telescope. Group the results by telescope model. [3]

A laboratory data-logger computer system contains both Static RAM (SRAM) and Dynamic RAM (DRAM).

Describe three differences in the construction or operation of SRAM and DRAM.

An automated laboratory incubator uses a monitoring system with three digital sensor inputs:

* \(T = 1\) if the temperature is above the safe threshold (otherwise \(T = 0\))
* \(H = 1\) if the humidity is below the required level (otherwise \(H = 0\))
* \(P = 1\) if the backup power unit is active (otherwise \(P = 0\))

An alert signal \(X = 1\) is generated when:
* the temperature is above the safe threshold AND the humidity is NOT below the required level
OR
* the humidity is below the required level AND the backup power unit is NOT active.

Write a logic expression for the alert signal output \(X\).

A ventilation control unit produces an output \(X\) based on three sensor inputs \(A\), \(B\), and \(C\).

The logic expression for the system is:

\[X = (A \text{ NAND } B) \text{ XOR } C\]

Complete the truth table for this logic expression.

$$\begin{array}{|c|c|c|c|}
\hline
A & B & C & X \\
\hline
0 & 0 & 0 & \\
\hline
0 & 0 & 1 & \\
\hline
0 & 1 & 0 & \\
\hline
0 & 1 & 1 & \\
\hline
1 & 0 & 0 & \\
\hline
1 & 0 & 1 & \\
\hline
1 & 1 & 0 & \\
\hline
1 & 1 & 1 & \\
\hline
\end{array}$$

A regional parcel distribution centre is planning to deploy an Artificial Intelligence (AI) automated sorting and transport system to replace human forklift operators and manual parcel sorters.

Discuss the social and economic impacts on the workforce and the company of introducing this AI-based system.

A logistics system uses an identification string called `ParcelID`. A valid `ParcelID` must satisfy the following validation rules:

* Rule 1: It must be exactly 7 characters in length.
* Rule 2: The first two characters must be uppercase alphabetic letters (`'A'` to `'Z'`).
* Rule 3: The next four characters (positions 3 to 6) must be numeric digits (`'0'` to `'9'`).
* Rule 4: The final character (position 7) must be an exclamation mark (`'!'`).

The function `ValidateParcelID` takes `ParcelID : STRING` as a parameter and returns `TRUE` if the string is valid, or `FALSE` otherwise.

Complete the following pseudocode by writing the missing lines or expressions corresponding to labels [Line 1], [Line 2], and [Line 3].

```text
FUNCTION ValidateParcelID(ParcelID : STRING) RETURNS BOOLEAN
DECLARE Index : INTEGER
DECLARE NextChar : CHAR

IF LENGTH(ParcelID) <> 7 THEN
RETURN FALSE
ENDIF

// Check characters 1 and 2
FOR Index <- 1 TO 2
NextChar <- MID(ParcelID, Index, 1)
IF NextChar < 'A' OR NextChar > 'Z' THEN
RETURN FALSE
ENDIF
NEXT Index

// Check characters 3 to 6
FOR Index <- 3 TO 6
NextChar <- MID(ParcelID, Index, 1)
[Line 1]
RETURN FALSE
ENDIF
NEXT Index

// Check final character
[Line 2]
RETURN FALSE
ENDIF

[Line 3]
ENDFUNCTION
```

A program reads a customer's loyalty discount rate from user input. The input must satisfy the following validation criteria:
- It must be a real number.
- It must be in the range 0.0 to 35.0 inclusive.

The user must be repeatedly prompted to re-enter the discount rate until a valid value is entered. The procedure must count how many invalid attempts were made and output a warning message `"Multiple invalid attempts"` if more than 2 invalid values were entered before a valid one was supplied.

Complete the following pseudocode for the procedure `InputDiscountRate`.

```text
PROCEDURE InputDiscountRate()
DECLARE Rate : REAL
DECLARE InvalidCount : INTEGER

InvalidCount <- 0

REPEAT
OUTPUT "Enter discount rate (0.0 - 35.0): "
INPUT Rate

IF [Condition 1] THEN
OUTPUT "Error: Value out of range."
[Statement 1]
ENDIF
UNTIL [Condition 2]

IF [Condition 3] THEN
OUTPUT "Multiple invalid attempts"
ENDIF
ENDPROCEDURE
```

A school generates a check code for student registration numbers.

A registration string `RegNum` contains 5 numeric characters (e.g. `"48291"`). The validation function `GenerateCheckDigit` computes a single check digit using the following algorithm:
1. Extract each numeric digit from position 1 to 5.
2. Multiply the digit at position 1 by 1, position 2 by 2, position 3 by 3, position 4 by 4, and position 5 by 5.
3. Sum these products together into `Total`.
4. The check digit is the remainder when `Total` is divided by 10 (`Total MOD 10`).
5. Return the check digit as a single `CHAR`.

Complete the following pseudocode function by filling in the missing expressions or statements for [Gap 1], [Gap 2], and [Gap 3].

```text
FUNCTION GenerateCheckDigit(RegNum : STRING) RETURNS CHAR
DECLARE Index : INTEGER
DECLARE Total : INTEGER
DECLARE Digit : INTEGER

Total <- 0

FOR Index <- 1 TO 5
// Convert extracted character at Index to an integer value
Digit <- [Gap 1]

// Accumulate weighted product
Total <- [Gap 2]
NEXT Index

// Return the single character check digit
RETURN [Gap 3]
ENDFUNCTION
```

A software developer has written a sub-routine `CalculateTax()` to compute sales duty on imported goods.

(a) Describe the difference between white-box testing and black-box testing. [2]
(b) State which of these two testing methods is required to perform code path coverage analysis. [0.5]

A linear queue, `RequestQueue`, is implemented using a 1D array of size 5 with indices from 1 to 5.

Two pointer variables are used:
- `HeadPointer` points to the index of the first item in the queue.
- `TailPointer` points to the index of the last item in the queue.

When the queue is empty, `HeadPointer` is set to 0 and `TailPointer` is set to 0.

(a) The queue is initially empty. The following sequence of operations is executed in order:
1. `Enqueue("PrintDocA")`
2. `Enqueue("ScanDocB")`
3. `Enqueue("EmailDocC")`
4. `Dequeue()`
5. `Enqueue("FaxDocD")`

State the contents of each index (1 to 5) of the `RequestQueue` array, and state the final values of `HeadPointer` and `TailPointer`. [2.5]

(b) Explain why a linear queue implemented in a fixed-size array can report a "queue full" condition when empty spaces still exist in the array. State how this issue can be resolved without shifting elements. [2.0]

A linked list stores student ID codes in alphabetical order. The linked list is implemented using two 1D arrays, `CandidateCode` of type `STRING` and `NextPointer` of type `INTEGER`, both with indices from 1 to 6.

- `StartPointer` stores the index of the first node in the list.
- `FreePointer` stores the index of the first available node in the free list.
- A pointer value of `0` represents a null pointer.

The current contents of the data structure are shown below:

| Index | CandidateCode | NextPointer |
|---|---|---|
| 1 | "C14" | 5 |
| 2 | "B09" | 1 |
| 3 | "E82" | 0 |
| 4 | "" | 6 |
| 5 | "D55" | 3 |
| 6 | "" | 0 |

`StartPointer = 2`
`FreePointer = 4`

(a) State the sequence of candidate codes currently stored in the linked list, in logical order from first to last. [1.5]

(b) A new code, `"C90"`, is inserted into the linked list in its correct alphabetical position.
State:
(i) The index where `"C90"` is stored. [0.5]
(ii) The updated value of `FreePointer`. [0.5]
(iii) The updated values of `NextPointer[1]`, `NextPointer[4]`, and `NextPointer[6]`. (State 'unchanged' if a value does not change). [2.0]

A 1D array SensorReadings contains 200 REAL values representing temperature readings recorded at regular intervals.

An algorithm is required to process the data in SensorReadings to:
- find the highest temperature reading and the lowest temperature reading
- calculate the average (mean) temperature
- count the number of temperature readings that are strictly greater than 35.0
- output the highest reading, lowest reading, average reading, and the count of readings greater than 35.0.

Describe the algorithm using a step-by-step description or structured English.

Do not write pseudocode or program code.

A programmer writes the following pseudocode procedure to sort an array `ReadingValues` of 100 integers into ascending numerical order:

```pseudocode
PROCEDURE BubbleSort(ReadingValues : ARRAY)
DECLARE Outer : INTEGER
DECLARE Inner : INTEGER
DECLARE Temp : INTEGER
FOR Outer <- 1 TO 99
FOR Inner <- 1 TO 99
IF ReadingValues[Inner] > ReadingValues[Inner + 1] THEN
Temp <- ReadingValues[Inner]
ReadingValues[Inner] <- ReadingValues[Inner + 1]
ReadingValues[Inner + 1] <- Temp
ENDIF
NEXT Inner
NEXT Outer
ENDPROCEDURE
```

(a) State two modifications that can be made to this algorithm to improve its efficiency.

(b) Explain the effect of using a swap-tracking boolean flag when the array `ReadingValues` is already in ascending order before the procedure is called.

A linear search function is designed to search for `TargetID` in a 1D array `CustomerID` containing 500 distinct integers. The array `CustomerID` is already sorted in ascending numerical order.

The initial algorithm is written as follows:

```pseudocode
FUNCTION SearchID(TargetID : INTEGER) RETURNS INTEGER
DECLARE Index : INTEGER
DECLARE FoundIndex : INTEGER
FoundIndex <- -1
FOR Index <- 1 TO 500
IF CustomerID[Index] = TargetID THEN
FoundIndex <- Index
ENDIF
NEXT Index
RETURN FoundIndex
ENDFUNCTION
```

(a) Describe how the loop structure can be altered so that the search terminates as soon as `TargetID` is located.

(b) Explain how the fact that `CustomerID` is sorted in ascending order can be used to optimize the search when `TargetID` is not present in the array.

An international shipping company requires a function to validate parcel tracking reference codes.

A tracking code is passed to the function as a string parameter, `TrackingCode`.

A valid tracking code must satisfy the following rules:
1. It must be exactly 8 characters in length.
2. The first two characters must both be uppercase alphabetic letters (`'A'` to `'Z'`).
3. Characters 3 to 7 (inclusive) must all be numeric digits (`'0'` to `'9'`).
4. Character 8 is a check character calculated from characters 3 to 7:
- Calculate the sum of the numerical values of the 5 digits (characters 3 to 7).
- Determine the remainder when this sum is divided by 26.
- The expected check character is the uppercase letter at position `Remainder` in the alphabet, where 0 corresponds to `'A'`, 1 to `'B'`, ..., and 25 to `'Z'`.
- Character 8 must match this calculated letter.

Write pseudocode for the function `ValidateTrackingCode`.

You should assume that the following built-in functions are available:
- `LENGTH(Str : STRING) RETURNS INTEGER` — returns the number of characters in `Str`.
- `MID(Str : STRING, Start : INTEGER, Length : INTEGER) RETURNS STRING` — returns a substring of length `Length` starting at position `Start`.
- `ASC(Char : CHAR) RETURNS INTEGER` — returns the ASCII value of character `Char`.
- `CHR(Code : INTEGER) RETURNS CHAR` — returns the character corresponding to ASCII value `Code`.

A company records employee professional development data in a text file named `CourseLog.txt`.

Each line of the text file contains a single record in the format:
`EmployeeID*DepartmentCode*HoursTrained`

For example:
`"EMP304*IT*14.5"`

- `EmployeeID` is a 6-character string.
- `DepartmentCode` is a 2-character string.
- `HoursTrained` is a real number stored as a string.
- Asterisk characters (`'*'`) are used as delimiters between fields.

A procedure `GenerateTrainingReport` is required to:
- Take a target department code string `TargetDept` as a parameter.
- Open the text file `CourseLog.txt` in read mode.
- Read each record sequentially until the end of the file.
- Extract the three fields (`EmployeeID`, `DepartmentCode`, and `HoursTrained`).
- If `DepartmentCode` matches `TargetDept`:
- Count the matching employee record.
- Add `HoursTrained` to a total training hours accumulator.
- If `HoursTrained` is less than 10.0, output the message: ` & " - Needs Further Training"`.
- Close the file `CourseLog.txt`.
- If one or more matching records were found, calculate and output the average training hours for that department in the format: `"Average hours: " & AverageHours`. Otherwise, output: `"No records found for department: " & TargetDept`.

Write pseudocode for the procedure `GenerateTrainingReport`.

You should assume that the following built-in functions are available:
- `LENGTH(Str : STRING) RETURNS INTEGER`
- `MID(Str : STRING, Start : INTEGER, Length : INTEGER) RETURNS STRING`
- `STR_TO_REAL(Str : STRING) RETURNS REAL` — converts a numeric string to a real number.