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

Explain why the UTF-8 encoding scheme is often preferred over standard ASCII, and how UTF-8 remains backward compatible with standard ASCII.

In the context of web technologies, state the primary difference between client-side scripting and server-side scripting. Provide one typical example of a task performed by each.

During the fetch stage of the Fetch-Execute cycle, instructions are retrieved from main memory. Write the Register Transfer Notation (RTN) steps for the fetch stage, starting from the point where the address of the next instruction is ready in the Program Counter (PC).

An operating system can link library routines to an executable program either statically or dynamically. Explain one benefit and one drawback of using Dynamic Link Libraries (DLLs) instead of static linking.

Computer systems must maintain both data integrity and data privacy. Describe the difference between data integrity and data privacy, and identify one threat to each.

In a relational database, explain the concept of referential integrity and describe how it is enforced using foreign keys.

Structure charts are used in top-down design to show the decomposition of a problem. Describe the purpose of: 1. A parameter passing indicator (couple) with an open circle. 2. A parameter passing indicator (couple) with a filled circle.

Software can be distributed under various licensing models. Explain the difference between Open Source software and Shareware in terms of source code availability and usage rights.

Describe how a resistive touchscreen detects the position of a user's touch.

State two functions performed by a router when managing data transmission across networks.

A school library database stores data using two tables:
`Book(BookID, Title, Author, Genre, YearPublished)`
`Loan(LoanID, BookID, MemberID, DateBorrowed, Returned)`

(a) Write a SQL query to display the `Title` and `Author` of all books where the `Genre` is 'Sci-Fi' and the `YearPublished` is after 2015. The results must be sorted alphabetically by `Title`. [4 marks]

(b) Write a SQL query to count and display the total number of loans that have not yet been returned (the field `Returned` contains the boolean value `FALSE` for outstanding loans). Change the header of the resulting count column to `OutstandingLoans`. [4.3 marks]

Consider the following pseudocode algorithm that operates on a 1D array of integers:

```
DECLARE Values : ARRAY[1..6] OF INTEGER
DECLARE i, Temp, Count : INTEGER
Values[1] <-- 12
Values[2] <-- 5
Values[3] <-- 18
Values[4] <-- 9
Values[5] <-- 15
Values[6] <-- 3
Count <-- 0
FOR i <-- 1 TO 5
IF Values[i] > Values[i+1] THEN
Temp <-- Values[i]
Values[i] <-- Values[i+1]
Values[i+1] <-- Temp
Count <-- Count + 1
ENDIF
NEXT i
```

Complete the trace table below to show how variables change during the execution of this algorithm. Draw a line in a cell to indicate no change in value.

A relational database table `Flight` is to be created. It contains information about scheduled airline flights. The details of the fields are:
- `FlightID`: alphanumeric string of exactly 6 characters, uniquely identifies each flight.
- `Origin`: alphabetic string of exactly 3 characters, representing the departure airport. This cannot be null.
- `Destination`: alphabetic string of exactly 3 characters, representing the arrival airport. This cannot be null.
- `DepartureTime`: time of departure.
- `Capacity`: integer representing total available seats.
- `AircraftID`: integer linking each flight to an aircraft.

(a) Write a SQL script to define and create the `Flight` table. Ensure that all primary key and foreign key constraints are correctly defined, assuming the parent table `Aircraft` already exists with a primary key `AircraftID`. [5.3 marks]

(b) State the role of:
(i) A Primary Key. [1.5 marks]
(ii) A Foreign Key. [1.5 marks]

An online shopping platform applies loyalty discounts based on the following rules:
- Premium Members (P) receive a base 10% discount.
- Orders over $150 (O) receive a base 10% discount.
- If a customer is a Premium Member AND their order is over $150, they receive a 20% discount instead of 10%.
- Customers with a Special Coupon (C) receive an extra 5% discount added to their base discount (e.g. 10% base discount becomes 15%, and 20% becomes 25%). If no other criteria are met, the coupon gives a 5% discount.
- Non-premium members with orders of $150 or less and no coupon receive 0% discount.

(a) Complete a decision table representing this policy. Identify the 3 conditions (C1: Premium Member, C2: Order > $150, C3: Special Coupon), show all 8 possible rule combinations, and select the correct action (0%, 5%, 10%, 15%, 20%, 25% discount) for each. [6 marks]

(b) State one reason why a developer would choose to use a decision table rather than pseudocode to specify complex business rules. [2.3 marks]

A structure chart represents the modular design of a library system. The module `ManageReturns` calls two sub-modules: `CheckOverdue` and `CalculateFine`.
- `ManageReturns` passes `BookID` and `MemberID` to `CheckOverdue`.
- `CheckOverdue` returns a control flag `IsOverdue` and an integer `DaysLate`.
- If `IsOverdue` is true, `ManageReturns` passes `DaysLate` to `CalculateFine`.
- `CalculateFine` returns the decimal value `FineAmount` to `ManageReturns`.

(a) Identify the names of:
(i) the modules in this structure chart. [1.5 marks]
(ii) the data couples passed between modules and their directions. [2.5 marks]
(iii) the control couple(s) and their directions. [1.3 marks]

(b) Explain:
(i) What is meant by 'high cohesion' in modular program design. [1.5 marks]
(ii) Why 'loose coupling' is desirable. [1.5 marks]

The following pseudocode algorithm implements a search on an array of integers:

```
DECLARE List : ARRAY[1..8] OF INTEGER
DECLARE Left, Right, SearchVal, Mid, Found : INTEGER
List[1] <-- 3
List[2] <-- 8
List[3] <-- 12
List[4] <-- 19
List[5] <-- 21
List[6] <-- 27
List[7] <-- 35
List[8] <-- 43

SearchVal <-- 27
Left <-- 1
Right <-- 8
Found <-- -1

WHILE Left <= Right AND Found = -1
Mid <-- (Left + Right) DIV 2
IF List[Mid] = SearchVal THEN
Found <-- Mid
ELSE
IF List[Mid] < SearchVal THEN
Left <-- Mid + 1
ELSE
Right <-- Mid - 1
ENDIF
ENDIF
ENDWHILE
```

(a) Complete the trace table to show the values of the variables as the algorithm executes. Draw a line in a cell to indicate no change in value. [5.3 marks]

(b) State the name of this search algorithm and explain one essential requirement for the array `List` for this algorithm to work correctly. [3 marks]

Consider the following pseudocode algorithm:

```pseudocode
DECLARE x, y, z : INTEGER
x <-- 12
y <-- 5
z <-- 0
WHILE x > 0 DO
IF x MOD 2 <> 0 THEN
z <-- z + y
ENDIF
x <-- x DIV 2
y <-- y * 2
ENDWHILE
```

Complete the tracing of this algorithm. State:
1. The final values of x, y, and z when the loop terminates.
2. The number of times the WHILE loop condition evaluates to TRUE.

A programmer designs the following pseudocode function to evaluate permissions:

```pseudocode
FUNCTION CheckAccess(Age : INTEGER, HasParent : BOOLEAN, VIP : BOOLEAN) RETURNS BOOLEAN
DECLARE Allowed : BOOLEAN
Allowed <-- (Age >= 18 OR (Age >= 12 AND HasParent)) AND NOT (VIP = FALSE AND Age < 15)
RETURN Allowed
ENDFUNCTION
```

Evaluate the function call outputs for the following five test cases. State whether each call returns TRUE or FALSE:

1. CheckAccess(15, TRUE, FALSE)
2. CheckAccess(12, TRUE, FALSE)
3. CheckAccess(17, FALSE, TRUE)
4. CheckAccess(18, FALSE, FALSE)
5. CheckAccess(14, TRUE, TRUE)

The following pseudocode algorithm performs a sequence of operations on a 1-dimensional array, Arr:

```pseudocode
DECLARE Arr : ARRAY[1..6] OF INTEGER
DECLARE i, temp : INTEGER
Arr[1] <-- 8
Arr[2] <-- 3
Arr[3] <-- 5
Arr[4] <-- 8
Arr[5] <-- 2
Arr[6] <-- 7

FOR i <-- 1 TO 5
IF Arr[i] > Arr[i+1] THEN
temp <-- Arr[i]
Arr[i] <-- Arr[i+1]
Arr[i+1] <-- temp
ENDIF
NEXT i
```

Trace the execution of this algorithm and determine:
1. The final values contained in the array Arr from index 1 to 6.
2. The total number of times a swap (the block inside the IF statement) is executed.

The following pseudocode function processes a string character by character:

```pseudocode
FUNCTION ProcessString(InStr : STRING) RETURNS STRING
DECLARE OutStr : STRING
DECLARE i : INTEGER
DECLARE Ch : CHAR
OutStr <-- \"\"
FOR i <-- 1 TO LENGTH(InStr)
Ch <-- MID(InStr, i, 1)
IF Ch >= 'A' AND Ch <= 'Z' THEN
OutStr <-- OutStr & LCASE(Ch)
ELSEIF Ch >= 'a' AND Ch <= 'z' THEN
OutStr <-- UCASE(Ch) & OutStr
ELSE
OutStr <-- OutStr & \"*\"
ENDIF
NEXT i
RETURN OutStr
ENDFUNCTION
```

Notes on built-in functions:
- `MID(InStr, i, 1)` returns the character at position `i` (1-based index).
- `LCASE` / `UCASE` convert characters to lowercase/uppercase.
- `&` is the string concatenation operator.

Dry run the function with the input string `InStr = "mD8e"`. Show:
1. The value of `OutStr` at the end of each of the 4 loop iterations.
2. The final returned string.

A school library stores book reservation requests in a global 2D array, `ReservationList`, of type `STRING` with dimensions `[1:100, 1:3]`. The columns are:
- `[i, 1]`: Student ID
- `[i, 2]`: Book ID
- `[i, 3]`: Reservation Status (can be "PENDING", "APPROVED", or "REJECTED")

Another global 2D array, `BookStock`, of type `STRING` with dimensions `[1:50, 1:2]` stores the actual book inventory. The columns are:
- `[j, 1]`: Book ID
- `[j, 2]`: Current Available Quantity (stored as a string, e.g., "3")

Write a pseudocode function `ProcessReservations(BYREF ReservationList : ARRAY, BYREF BookStock : ARRAY) RETURNS INTEGER` that updates pending reservations:
1. It must iterate through all 100 entries in `ReservationList`.
2. For each reservation with a status of "PENDING", it must locate the corresponding `Book ID` in the `BookStock` array.
3. If the book is found in `BookStock` and its available quantity is greater than 0, decrease the quantity by 1, update the reservation status to "APPROVED", and count it.
4. If the book is found but the quantity is 0, update the reservation status to "REJECTED".
5. Finally, the function must return the total number of approved reservations during this process.

You should assume that the built-in functions `STR_TO_NUM(s : STRING) RETURNS INTEGER` and `NUM_TO_STR(n : INTEGER) RETURNS STRING` are available.

A text file `transactions.txt` contains transaction records on each line in the format: `CustomerID,Amount,Currency` (e.g., "C104,120.50,USD").

Write a pseudocode procedure `ValidateTransactions(FileName : STRING)` that processes this file. The procedure must perform the following:
1. Open `transactions.txt` for reading.
2. Open `valid.txt` and `errors.txt` for writing.
3. Read each record from `transactions.txt` line by line until the end of the file is reached.
4. Validate each transaction line:
- **Customer ID**: Must be exactly 4 characters long, must start with 'C', and the remaining 3 characters must be numeric digits ('0'-'9').
- **Currency**: Must be exactly "USD", "EUR", or "GBP".
- **Amount**: Must be a positive real number (> 0).
5. If a transaction is valid, write the original line exactly as it is to `valid.txt`.
6. If a transaction is invalid, write the original line to `errors.txt` appended with a comma and its corresponding line number in the source file (e.g., "C104,120.50,USD,4" for an error on line 4).
7. Close all opened files.

Assume the helper function `GetField(RecordStr : STRING, FieldNum : INTEGER) RETURNS STRING` exists to extract a field index (1, 2, or 3) from the comma-separated string, and `STR_TO_REAL(s : STRING) RETURNS REAL` converts a string to a decimal value.

Write a pseudocode function `CompressString(InputStr : STRING) RETURNS STRING` that performs basic run-length encoding.

The function takes a string of uppercase alphabetic characters and returns a compressed string where consecutive duplicate characters are replaced with the count of duplicates followed by the character itself.

For example:
- `"AAAABBC"` compresses to `"4A2B1C"`
- `"X"` compresses to `"1X"`
- An empty input string `""` returns an empty string `""`.

You should assume that the built-in functions `LENGTH(s : STRING) RETURNS INTEGER`, `SUBSTRING(s : STRING, start : INTEGER, length : INTEGER) RETURNS STRING`, and `NUM_TO_STR(n : INTEGER) RETURNS STRING` are available.

A logistics system uses a custom Record type `Package` to hold shipment details:
```
TYPE Package
DECLARE PackageID : STRING
DECLARE Weight : REAL
DECLARE Destination : STRING
DECLARE Delivered : BOOLEAN
ENDTYPE
```

Write a pseudocode procedure `GenerateManifest(Manifest : ARRAY[1:200] OF Package, TargetDest : STRING)` that parses an array of package records and performs the following tasks:
1. Search through the entire 200 elements of the array.
2. For every package that matches the `TargetDest` and is **not** delivered (`Delivered = FALSE`):
- Output the `PackageID` and `Weight` fields.
- Accumulate the weight of these matching packages to compute the total weight of outstanding deliveries for that destination.
- Keep track of the ID of the heaviest matching package.
3. After searching through all elements, if matches were found, output:
- The total accumulated weight of undelivered packages.
- The `PackageID` of the heaviest undelivered package.
4. If no matching packages were found, output "No undelivered packages for destination: [TargetDest]".