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

Explain the differences between immediate addressing and direct addressing in assembly language. Provide an example of a typical instruction for each addressing mode to illustrate your answer.

An operating system (OS) typically includes utility software. Identify two utility programs and describe how each helps maintain the computer system.

Computer networks use both Media Access Control (MAC) addresses and Internet Protocol (IP) addresses. Describe two key differences between a MAC address and an IP address.

Sound must be converted into digital format before it can be processed by a computer. Describe how sound is sampled and digitized, referencing the terms 'sampling rate' and 'sampling resolution' in your answer.

Describe the differences between Open Source software and Shareware software licensing models.

Convert the negative denary number \(-22.625\) into a 12-bit fixed-point binary representation using two's complement. You must use 8 bits for the integer part and 4 bits for the fractional part. Show your working.

A logic circuit has three inputs \(A\), \(B\), and \(C\), and an output \(X\). The Boolean expression for the output of this circuit is:

\(X = (A \text{ AND } B) \text{ OR } (\text{NOT } B \text{ AND } \text{NOT } C)\)

Complete the truth table below by determining the value of \(X\) for each row. Show your intermediate working for the terms \(P = A \text{ AND } B\) and \(Q = \text{NOT } B \text{ AND } \text{NOT } C\).

| A | B | C | P | Q | X |
|---|---|---|---|---|---|
| 0 | 0 | 0 | | | |
| 0 | 0 | 1 | | | |
| 0 | 1 | 0 | | | |
| 0 | 1 | 1 | | | |
| 1 | 0 | 0 | | | |
| 1 | 0 | 1 | | | |
| 1 | 1 | 0 | | | |
| 1 | 1 | 1 | | | |

A library database uses two tables: MEMBER and LOAN.

The MEMBER table contains: MemberID, FirstName, LastName, DateOfBirth.
The LOAN table needs to store: LoanID, MemberID, BookTitle, LoanDate.

(a) Write a Data Definition Language (DDL) SQL script to create the LOAN table.
Ensure that:
- LoanID is the primary key (integer).
- MemberID is a foreign key referencing the MEMBER table.
- BookTitle is a text field of maximum 100 characters.
- LoanDate is a date field. [3]

(b) Write a Data Manipulation Language (DML) SQL query to retrieve the FirstName and LastName of all members who have borrowed books, along with the BookTitle and LoanDate of their loans.
The results must only show loans made from '2023-01-01' onwards and must be sorted in alphabetical order by the member's LastName. [3]

A school's sports club database contains details of students and clubs.
- A student can join many clubs.
- A club can have many students.

(a) (i) Explain why this relationship cannot be directly implemented in a relational database. [1]
(a) (ii) State how this relationship is resolved. Write down the design schema for the third table (name it STUDENT_CLUB) using the format: TableName(Attribute1, Attribute2, ...) with primary keys underlined. [2]

(b) Write an SQL script to insert a new student record into an existing table named STUDENT.
The table has columns: StudentID (text), StudentName (text), and DateOfBirth (date).
The details to insert are:
- StudentID: 'S908'
- StudentName: 'Alice Green'
- DateOfBirth: '2008-05-14' [3]

An algorithm is designed to perform a run-length compression on an input string. Below is the pseudocode of the function `CompressString`:

```pseudocode
FUNCTION CompressString(Str : STRING) RETURNS STRING
DECLARE OutStr : STRING
DECLARE i, Count : INTEGER
DECLARE CurrentChar : CHAR

OutStr <-- ""
IF LENGTH(Str) > 0 THEN
CurrentChar <-- MID(Str, 1, 1)
Count <-- 1
FOR i <-- 2 TO LENGTH(Str)
IF MID(Str, i, 1) = CurrentChar THEN
Count <-- Count + 1
ELSE
OutStr <-- OutStr + CurrentChar + NUM_TO_STR(Count)
CurrentChar <-- MID(Str, i, 1)
Count <-- 1
ENDIF
NEXT i
OutStr <-- OutStr + CurrentChar + NUM_TO_STR(Count)
ENDIF
RETURN OutStr
ENDFUNCTION
```

Complete the trace table below for the function call `CompressString("XXYZZZ")`.

The procedure `CompactArray` is designed to process an array of integers `DataList` containing `NumElements` elements. It moves all non-negative elements to the beginning of the array while preserving their original order, and sets all remaining trailing elements to `0`.

Complete the following pseudocode by writing the correct expressions for **Gap A**, **Gap B**, **Gap C**, and **Gap D**.

```pseudocode
PROCEDURE CompactArray(BYREF DataList : ARRAY OF INTEGER, NumElements : INTEGER)
DECLARE WritePos, i : INTEGER
WritePos <-- 1
FOR i <-- 1 TO NumElements
IF DataList[i] >= 0 THEN
IF i <> WritePos THEN
DataList[WritePos] <-- [ Gap A ]
ENDIF
WritePos <-- [ Gap B ]
ENDIF
NEXT i

FOR i <-- [ Gap C ] TO NumElements
DataList[i] <-- [ Gap D ]
NEXT i
ENDPROCEDURE
```

The function `CountPattern` checks how many times a two-character `Pattern` appears in a given string `Text`. The character `'?'` in `Pattern` serves as a wildcard that matches any character.

```pseudocode
FUNCTION CountPattern(Text : STRING, Pattern : STRING) RETURNS INTEGER
DECLARE Count, i, TextLen : INTEGER
DECLARE Match : BOOLEAN
DECLARE Char1, Char2, P1, P2 : CHAR

Count <-- 0
TextLen <-- LENGTH(Text)
IF TextLen < 2 THEN
RETURN 0
ENDIF

P1 <-- MID(Pattern, 1, 1)
P2 <-- MID(Pattern, 2, 1)

FOR i <-- 1 TO TextLen - 1
Char1 <-- MID(Text, i, 1)
Char2 <-- MID(Text, i + 1, 1)
Match <-- FALSE

IF (P1 = "?" OR P1 = Char1) AND (P2 = "?" OR P2 = Char2) THEN
Match <-- TRUE
ENDIF

IF Match = TRUE THEN
Count <-- Count + 1
ENDIF
NEXT i

RETURN Count
ENDFUNCTION
```

Complete a dry run trace table for the function call: `CountPattern("ANANA", "?A")`.

A software developer is designing a temperature-monitoring algorithm for a greenhouse. The program processes hourly temperature measurements stored in a 1D array.

The developer has defined the following high-level design:
1. Initialize variables.
2. Input 24 temperature readings into a 1D array TempReadings (indices 1 to 24).
3. Count how many separate 'anomalous periods' occur. An anomalous period is defined as a continuous sequence of 3 or more hourly readings that are strictly greater than a defined threshold value.
4. Output the total number of anomalous periods.

Refine Step 3 of this algorithm by writing structured pseudocode. You must use the following variables:
- TempReadings : 1D array [1:24] of REAL
- Threshold : REAL (already contains the threshold value)
- AnomalyCount : INTEGER (to store the total count of anomalous periods)
- ConsecutiveCount : INTEGER (to count the current consecutive readings exceeding the threshold)

A system validates product serial codes. A valid serial code must follow the exact pattern LL-NNN-LL, where L represents an uppercase letter ('A' to 'Z') and N represents a single digit ('0' to '9').

The programmer has written the outer structure of the validation logic below:

```
IsValid <- TRUE
IF LENGTH(SerialCode) <> 9 THEN
IsValid <- FALSE
ELSE
IF MID(SerialCode, 3, 1) <> "-" OR MID(SerialCode, 7, 1) <> "-" THEN
IsValid <- FALSE
ELSE
// Write refined logic for steps 4 and 5 here
ENDIF
ENDIF
```

Write the refined pseudocode for the inner block to complete steps 4 and 5 of the validation design:
- Step 4: Validate that characters at positions 1, 2, 8, and 9 are uppercase letters.
- Step 5: Validate that characters at positions 4, 5, and 6 are digits.

A text file, `DeviceLogs.txt`, contains structured communication logs from multiple remote sensors. Each line in the file is exactly 16 characters long and formatted according to a strict system protocol:
- Characters 1 to 6: Sensor ID (e.g., `SENS01`)
- Character 7: A comma (`,`)
- Characters 8 to 10: Status code (`ERR` or `OK ` with a trailing space)
- Character 11: A colon (`:`)
- Characters 12 to 16: Numerical data reading as a decimal string (e.g., `045.5`)

Write a pseudocode procedure `ExtractErrors` that processes `DeviceLogs.txt` and performs the following tasks:
1. Reads each line from `DeviceLogs.txt` until the end of the file is reached.
2. Extracts the Sensor ID, Status code, and Numerical reading using standard pseudocode string functions.
3. Checks if the Status code is `"ERR"` and the Numerical reading is strictly greater than `50.0`.
4. For each matching entry, writes a line to a new text file, `CriticalErrors.txt`, in the format:
`[Sensor ID] VALUE [Numerical reading]` (for example: `SENS01 VALUE 062.4`)
5. Ensures both files are properly opened and closed.

An embedded telemetry logger processes individual data packets before saving them to external storage.

1. Define a user-defined composite record structure named `Packet` with the following field attributes:
- `DeviceID` (String)
- `Timestamp` (Integer)
- `Reading` (Real)

2. Write a pseudocode function `SerializePacket(Data : Packet) RETURNS String` that formats a `Packet` record into a single string formatted with a custom protocol separator hash (`#`). For example, a packet with `DeviceID` "DEV01", `Timestamp` 1609459200, and `Reading` 12.8 should be converted to: `"DEV01#1609459200#12.8"`.

3. Write a pseudocode procedure `SavePackets(Filename : String, PacketArray : ARRAY[1:100] OF Packet, Total : Integer)` that opens the specified file in `WRITE` mode, serializes and writes all valid packets from index 1 up to `Total` (inclusive) to the file, and then closes the file.

A banking validation system updates temporary balances in-memory from daily transactional log files.
An existing text file, `Balances.txt`, contains active bank balances. Each line has a fixed layout: a 5-character account number, followed by a space, followed by a real balance stored as a string.

Another file, `Transactions.txt`, contains operations to process. Each line represents a record in this format:
- Character 1: Operation type (`'D'` for Deposit, `'W'` for Withdrawal)
- Character 2: Space
- Characters 3 to 7: Account number (5 characters)
- Character 8: Space
- Characters 9 onwards: Transaction amount as a decimal string

There are exactly 50 balances in `Balances.txt`. Write a pseudocode procedure `ProcessTransactions` to:
1. Initialize a 1D array of records named `AccountList` size `[1:50]` where each index holds an `AccountRecord` (containing fields `AccNum : STRING` and `Balance : REAL`).
2. Read `Balances.txt` to load these 50 entries into the array, and close the file.
3. Read through all transaction logs in `Transactions.txt` line by line until EOF. For each log, search `AccountList` for the matching account number. If found, update the balance by adding (for `'D'`) or subtracting (for `'W'`) the transaction amount.
4. Write the finalized data from `AccountList` back to a new file named `UpdatedBalances.txt` in the same structure as `Balances.txt`, and close all files.