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

State the minimum number of bits required to represent the denary value \(-58\) in two's complement binary, and explain why this minimum number of bits is needed.

Explain why a resistive touchscreen is often preferred over a capacitive touchscreen in an industrial factory environment where operators wear heavy, non-conductive protective gloves.

During the execution of an assembly language program, an addition instruction results in the accumulator value changing from \(01111111\) (binary) to \(10000000\) (binary). State which status register flag is set by this operation, and explain why.

Define the term 'baud rate' and explain how it is possible for the 'bit rate' of a digital transmission channel to exceed its 'baud rate'.

Describe the difference between a check digit and a checksum in terms of how they are calculated and used to detect errors.

Explain the role of a device driver and why it is necessary when connecting a new external peripheral to a computer system.

In a relational database with a 1-to-many relationship between tables CUSTOMER and ORDER, explain what referential integrity is and how it is enforced when a user attempts to delete a customer.

Describe the difference in how system memory is handled when a large array parameter is passed 'by value' compared to 'by reference' to a subroutine.

In a relational database, explain the term 'composite primary key' and provide a suitable example of attributes that could form a composite primary key in a class enrollment system.

Describe two distinct actions that occur to the Program Counter (PC) register during the Fetch stage of the fetch-decode-execute cycle.

Identify three essential functions performed by a router when managing data transmission across the internet.

Explain the purpose of utility software in a computer system and state one common example of a utility program.

Explain how the transition from standard 7-bit ASCII to variable-width Unicode (such as UTF-8) impacts both the range of characters that can be represented and the storage requirements for a plain text document.

In a shared-medium Ethernet network, collisions can occur. Explain how the Carrier Sense Multiple Access with Collision Detection (CSMA/CD) protocol manages these collisions to ensure successful transmission.

During the Fetch stage of the Fetch-Execute cycle, instructions are retrieved from main memory. Explain how the Program Counter (PC) and the Memory Address Register (MAR) interact during this stage, and explain how the Program Counter is updated.

In a relational database system, explain the purpose of a foreign key and how referential integrity is maintained when a record in a parent table is deleted.

A company wants to secure its internal communications. Compare symmetric encryption and asymmetric encryption, explaining why asymmetric encryption is more secure for key exchange over public channels, but symmetric encryption is preferred for bulk data transfer.

Explain the operational differences between a compiler and an interpreter when translating high-level source code into machine code, specifically focusing on error detection and execution speed.

Compare the physical operation and user capabilities of resistive touch screens and capacitive touch screens.

An independent developer is deciding between licensing their new software utility under an open-source license (e.g., GNU GPL) or as proprietary commercial software. Explain the differences between these licensing models in terms of source code accessibility, modification rights, and distribution.

Explain the role of the Program Counter (PC) and how its value changes during the fetch stage of the Fetch-Execute cycle.

In the context of relational databases, explain the term 'referential integrity' and describe two distinct methods a Database Management System (DBMS) can use to maintain this integrity when a record in a primary key table is deleted.

An industrial process monitoring system controls an alarm output \(X\) using three inputs: \(A\) (high temperature sensor), \(B\) (high pressure sensor), and \(C\) (vibration sensor).

The Boolean expression for the logic circuit is:
\(X = (A \text{ AND } B) \text{ OR } (\text{NOT } B \text{ AND } C)\)

(a) Complete the following truth table by calculating the values for intermediate outputs \(P = A \text{ AND } B\), \(Q = \text{NOT } B \text{ AND } C\), and the final output \(X\). [4 marks]

| 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 | | | |

(b) Identify the name of each logic gate (Gate 1, Gate 2, and Gate 3) described in the circuit diagram configuration below:
- Gate 1 takes inputs \(A\) and \(B\) to produce intermediate output \(P\).
- Gate 2 takes \(NOT \ B\) and \(C\) to produce intermediate output \(Q\).
- Gate 3 takes inputs \(P\) and \(Q\) to produce final output \(X\). [1.5 marks]

A ventilation control system produces an output \(Y\) based on three environmental factors: \(A\) (humidity above limit), \(B\) (CO2 level above limit), and \(C\) (manual override switch active).

The logic circuit is represented by the Boolean expression:
\(Y = (A \text{ NOR } B) \text{ AND } (B \text{ XOR } C)\)

(a) Complete the truth table below by calculating the columns for \(P = A \text{ NOR } B\), \(Q = B \text{ XOR } C\), and the output \(Y\). [4 marks]

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

(b) Identify the names of the logic gates needed to directly implement the expressions for \(P\), \(Q\), and \(Y\) as single hardware components:
- Gate 1: produces \(P\) from inputs \(A\) and \(B\). [0.5 marks]
- Gate 2: produces \(Q\) from inputs \(B\) and \(C\). [0.5 marks]
- Gate 3: produces \(Y\) from inputs \(P\) and \(Q\). [0.5 marks]

A greenhouse control panel has an output signal \(Z\) constructed from three inputs: \(A\) (low soil moisture), \(B\) (low light level), and \(C\) (heater active).

The Boolean expression is:
\(Z = \text{NOT } (A \text{ OR } B) \text{ NAND } C\)

(a) Complete the truth table below by providing the outputs for intermediate term \(P = \text{NOT } (A \text{ OR } B)\) and final output \(Z\). [4 marks]

| A | B | C | P | Z |
|---|---|---|---|---|
| 0 | 0 | 0 | | |
| 0 | 0 | 1 | | |
| 0 | 1 | 0 | | |
| 0 | 1 | 1 | | |
| 1 | 0 | 0 | | |
| 1 | 0 | 1 | | |
| 1 | 1 | 0 | | |
| 1 | 1 | 1 | | |

(b) Write down the logic gate names corresponding to the operations that generate \(P\) and \(Z\):
- Gate 1: produces \(P\) directly from inputs \(A\) and \(B\). [0.75 marks]
- Gate 2: produces \(Z\) directly from inputs \(P\) and \(C\). [0.75 marks]

An automated conveyor belt alarm system uses three inputs to trigger output alarm \(S\): \(A\) (item jam detected), \(B\) (stop button pressed), and \(C\) (power surges detected).

The Boolean expression is:
\(S = (A \text{ AND } \text{NOT } B) \text{ XOR } (B \text{ OR } C)\)

(a) Complete the truth table below by filling in intermediate columns for \(P = A \text{ AND } \text{NOT } B\), \(Q = B \text{ OR } C\), and the output \(S\). [4 marks]

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

(b) Identify the minimum set of standard 2-input logic gates required to construct this system:
- List the basic gates needed to build intermediate term \(P = A \text{ AND } \text{NOT } B\). [0.5 marks]
- State the logic gate used to produce final output \(S\) from intermediate signals \(P\) and \(Q\). [1 mark]

An athletics club measures sprinters' times for a 100-metre race. Write a pseudocode function CalculateAverageSpeed that:
- Takes two parameters: an array Times (a 1D array of REAL values representing race times in seconds) and an integer NumElements representing the number of items in the array.
- Iterates through the array to find all times that are strictly less than 12.0 seconds.
- For each such time, calculates the speed using the formula: speed = 100.0 / time.
- Calculates and returns the average speed of these valid runs.
- If no runs are completed in less than 12.0 seconds, the function must return -1.0.

Write the pseudocode for the function CalculateAverageSpeed.

A software application requires product codes to follow a strict format. Write a pseudocode function ValidateCode(ProductCode : STRING) RETURNS BOOLEAN that returns TRUE if the product code is valid, and FALSE otherwise.

A product code is valid if it meets all of the following rules:
1. It must be exactly 8 characters long.
2. The first three characters must be uppercase alphabetical letters ('A' to 'Z').
3. The fourth character must be a hyphen ('-').
4. The last four characters must be numeric digits ('0' to '9').

You should assume the existence of the following built-in string manipulation functions:
- LENGTH(s : STRING) RETURNS INTEGER (returns the number of characters in the string s)
- MID(s : STRING, start : INTEGER, length : INTEGER) RETURNS STRING (returns a substring of length 'length' starting at index 'start')
- ASC(c : CHAR) RETURNS INTEGER (returns the ASCII value of character c)

A theatre booking system uses a 2D array SeatingPlan of type STRING, dimensioned [1:10, 1:6] (representing 10 rows and 6 seats per row). Empty seats are represented by the string "EMPTY", while reserved seats contain the customer's name.

Write a pseudocode procedure FindAdjacentSeats() that searches the entire array and identifies any occurrences where two adjacent seats in the same row are both empty.

For each such occurrence, the procedure should output a message in the format:
"Row , Seats and are empty"
For example, if seats 3 and 4 in Row 5 are both empty, it outputs:
"Row 5, Seats 3 and 4 are empty"

Note: If seats 2, 3, and 4 are all empty, this counts as two overlapping pairs (2 and 3, and 3 and 4), and both should be output.

A text file Students.txt contains records of students. For each student, three consecutive lines are written:
- First line: Student ID (e.g., "ST101")
- Second line: Class Name (e.g., "12B")
- Third line: Test Score (as a string representing an integer, e.g., "78")

Write a pseudocode procedure FilterPassedStudents(MinScore : INTEGER) that:
- Reads all student records from Students.txt.
- Determines if the student's score is greater than or equal to MinScore. (Note: Convert the string score to an integer before comparison using a built-in conversion function TONUM(s : STRING) RETURNS NUMERIC).
- For each student who meets this criteria, writes their Student ID and Test Score to a new file Passed.txt as a single comma-separated line (e.g., "ST101,78").
- Closes all files when processing is complete.

You must use standard pseudocode file handling commands (such as OPENFILE, READFILE, WRITEFILE, CLOSEFILE, and EOF).

An algorithm is written to process an array of 5 integers. The initial state of the 1-based array Numbers is:
Numbers[1] = 12
Numbers[2] = 5
Numbers[3] = 8
Numbers[4] = 15
Numbers[5] = 3

The pseudocode is as follows:
Count <- 0
FOR Index <- 1 TO 4
IF Numbers[Index] > Numbers[Index + 1] THEN
Temp <- Numbers[Index]
Numbers[Index] <- Numbers[Index + 1]
Numbers[Index + 1] <- Temp
Count <- Count + 1
ENDIF
NEXT Index
Trace the execution of this algorithm by completing the trace table. Note: intermediate values should only be recorded when a variable's value changes.

A function ProcessString is defined as follows:
FUNCTION ProcessString(InString : STRING) RETURNS STRING
DECLARE OutString : STRING
DECLARE Length, i : INTEGER
DECLARE NextChar : CHAR
OutString <- ""
Length <- LENGTH(InString)
i <- 1
WHILE i <= Length
NextChar <- MID(InString, i, 1)
IF NextChar = 'A' OR NextChar = 'E' OR NextChar = 'I' OR NextChar = 'O' OR NextChar = 'U' THEN
OutString <- OutString & "*"
ELSE
OutString <- OutString & NextChar
ENDIF
i <- i + 2
ENDWHILE
RETURN OutString
ENDFUNCTION
Complete the trace table for the function call: ProcessString("CAMBRIDGE"). Note: MID(String, Start, Length) returns a substring starting at the 1-based index 'Start' with the specified 'Length'.

A linked list is implemented using a 2D array List[0..5, 0..1] where column 0 represents Data and column 1 represents Pointer (the integer pointer to the next node). The head of the list is stored in the integer variable Start.

The initial state of the array and Start is:
- Start = 3
- List[0] = ["Fig", 5]
- List[1] = ["Kiwi", -1]
- List[2] = ["Date", 0]
- List[3] = ["Cherry", 2]
- List[4] = ["Grape", 1]
- List[5] = ["Guava", 4]

A programmer designs a flowchart logic to search for a value SearchValue:
1. Initialize CurrentPointer to Start.
2. Check if CurrentPointer is -1. If yes, output 'Not Found' and terminate.
3. Check if List[CurrentPointer, 0] equals SearchValue. If yes, output 'Found at index ' + CurrentPointer and terminate.
4. Set CurrentPointer to List[CurrentPointer, 1].
5. Repeat from Step 2.

Trace the execution of this search algorithm when SearchValue = "Grape". State the values of CurrentPointer, the comparison made, and the final output.

A binary search tree stores the following names:
- Root node: "Mango"
- Left subtree of "Mango": "Cherry" (parent of "Apple" on its left, and "Date" on its right)
- Right child of "Mango": "Peach" (no children)

The tree is represented in three 1D arrays: LeftPtr, Data, and RightPtr with index 0 to 5. The root index is stored in the variable Root which contains the value 3.

The incomplete representation is:
Index | LeftPtr | Data | RightPtr
0 | -1 | "Apple" | -1
1 | [ P ] | "Cherry" | [ Q ]
2 | -1 | "Date" | -1
3 | 1 | "Mango" | 4
4 | -1 | "Peach" | -1
5 | -1 | "" | -1 (Empty)

(a) State the pointer values that should replace [ P ] and [ Q ] to correctly construct the tree.
(b) Describe the step-by-step search path (the indices of the elements visited) to search for "Date" in this binary search tree starting from the root.

A linear queue is implemented as a 1D array of size 10, called QueueList[1:10]. Two pointers, HeadPointer and TailPointer, are used to keep track of the items. Initially, HeadPointer = 0 and TailPointer = 0.

The algorithm for inserting a new item, NewItem, is described below:
- If TailPointer is equal to 10, output 'Queue Full'.
- Otherwise, if TailPointer is 0 (queue is empty), set HeadPointer to 1, TailPointer to 1, and store NewItem in QueueList[TailPointer].
- Otherwise, increment TailPointer by 1 and store NewItem in QueueList[TailPointer].

(a) Identify the condition that prevents an item from being added to this queue when it reaches its physical limit.
(b) Explain the limitation of this linear queue design when items are repeatedly enqueued and dequeued, and describe how a circular queue modification addresses this issue.