MetadataPastPaper.sampleTitle

A sound engineer is digitising an analogue audio signal.

(a) Explain the process of sampling an analogue sound wave to convert it into a digital format. [3]

(b) Describe how increasing the sampling rate and the sampling resolution (bit depth) affects both the representation of the sound wave and the resulting file size. [3]

(c) A monophonic audio track is recorded with a sampling rate of 44,000 Hz and a sampling resolution of 16 bits. The duration of the recording is 20 seconds.

Calculate the file size of this recording in kilobytes (KB). Show your working. Assume 1 KB = 1,000 bytes. [2]

Data is transmitted across the internet using packet switching.

(a) Describe the structure of a standard packet of data. [3]

(b) Explain how packets are transmitted from a sender to a receiver across a packet-switched network, and how they are reassembled at the destination. [5]

In assembly language, different addressing modes are used to access data.

(a) Describe the differences between the following addressing modes:
(i) Immediate addressing [1]
(ii) Direct addressing [1]
(iii) Indirect addressing [2]
(iv) Indexed addressing [2]

(b) Explain how the Program Counter (PC) and the Memory Address Register (MAR) change during the Fetch stage of the Fetch-Decode-Execute (FDE) cycle. [2]

A training company maintains a relational database table to store records of training courses attended by employees.

`EmployeeTraining(EmployeeID, EmployeeName, CourseCode, CourseTitle, DateCompleted, Fee)`

- Assume an employee can attend multiple courses, and each course has a fixed title and fee.
- The primary key is the composite key: `(EmployeeID, CourseCode)`.

(a) Explain why this table is in First Normal Form (1NF). [1]

(b) Identify the functional dependencies that exist in this table, and explain why the table is NOT in Second Normal Form (2NF). [3]

(c) Normalize the database design into Third Normal Form (3NF). Write down the names of the tables, their attributes, and underline the primary keys. Identify any foreign keys. [4]

An Integrated Development Environment (IDE) contains translation software and utility programs.

(a) State three differences between a compiler and an interpreter. [3]

(b) Describe the functions of the following utility software:
(i) Disk defragmenter [2]
(ii) File compression utility [3]

A specialized scientific sensor array records underwater acoustic telemetry data using a custom multi-channel audio system. The recording parameters are specified as follows:
- Sampling rate: \(32,768\text{ Hz}\)
- Resolution / Bit depth: \(16\text{ bits}\)
- Number of channels: \(8\text{ channels}\)
- Recording duration: \(128\text{ seconds}\)

Answer the following questions. Show all your working.

(a) Calculate the raw uncompressed file size of the recording in Mebibytes (MiB). Use powers of 2 in your working to demonstrate how you arrive at the final integer value. (6 marks)

(b) The resulting audio file must be transmitted from a remote buoy to a research vessel over a radio link with an effective bandwidth of \(8\text{ Mibps}\) (mebibits per second). Due to network protocol overheads (such as packet headers and error correction), there is a \(25\%\) data overhead, meaning the total transmitted data is \(1.25\) times the actual file size. Calculate the total transmission time in seconds. (5 marks)

(c) The researcher considers using compression to reduce the storage space on the buoy's local card. Explain why a lossy compression algorithm is entirely unsuitable for scientific telemetry data, and why a lossless algorithm must be used instead. (4 marks)

(d) Represent the decimal value \(-103\) as an 8-bit two's complement signed integer. Show your working. (2.5 marks)

A digital safety interlock system in an industrial plant monitors two sensors: \(A\) (Over-temperature) and \(B\) (Over-pressure).
The safety output warning signal, \(X\), is determined by the following Boolean expression:
\(X = \overline{A \cdot B} \cdot (A + \overline{B}) \cdot (\overline{A} + B)\)

(a) Produce a complete truth table for the original unsimplified expression. Your truth table must include intermediate columns for \(\overline{A \cdot B}\), \((A + \overline{B})\), and \((\overline{A} + B)\) to show your work clearly. (6 marks)

(b) Simplify the Boolean expression for \(X\) to its simplest form containing the minimum number of literals and operators. Show every algebraic step and explicitly state the Boolean law/identity used at each step. (6.5 marks)

(c) Draw a logic circuit diagram for your simplified expression from part (b) using ONLY 2-input NOR gates. Explain your reasoning using De Morgan's Law. (5 marks)

An algorithm is designed to perform run-length encoding on a string of uppercase characters. Below is the pseudocode of the algorithm:

FUNCTION ProcessString(InputStr : STRING) RETURNS STRING
DECLARE OutputStr : STRING
DECLARE Length : INTEGER
DECLARE i : INTEGER
DECLARE Count : INTEGER
DECLARE CurrentChar : CHAR

OutputStr <- ""
Length <- LENGTH(InputStr)
i <- 1
WHILE i <= Length
CurrentChar <- MID(InputStr, i, 1)
Count <- 1
WHILE (i + 1 <= Length) AND (MID(InputStr, i + 1, 1) = CurrentChar)
Count <- Count + 1
i <- i + 1
ENDWHILE
IF Count > 1 THEN
OutputStr <- OutputStr + NUM_TO_STR(Count) + CurrentChar
ELSE
OutputStr <- OutputStr + CurrentChar
ENDIF
i <- i + 1
ENDWHILE
RETURN OutputStr
ENDFUNCTION

Complete a dry-run trace table for the function call ProcessString("AABCCCDEE") and state the final returned value.

A recursive function is designed to search for a local peak index in a 1D array of integers. A peak is defined as an element that is strictly greater than its immediate successor. Below is the pseudocode for the algorithm:

FUNCTION FindPeak(Arr : ARRAY[1..8] OF INTEGER, Low : INTEGER, High : INTEGER) RETURNS INTEGER
DECLARE Mid : INTEGER
IF Low = High THEN
RETURN Low
ENDIF
Mid <- (Low + High) DIV 2
IF Arr[Mid] > Arr[Mid + 1] THEN
RETURN FindPeak(Arr, Low, Mid)
ELSE
RETURN FindPeak(Arr, Mid + 1, High)
ENDIF
ENDFUNCTION

An array TestArr contains the following values: [2, 5, 8, 12, 10, 7, 4, 1].

Dry-run the execution of the call FindPeak(TestArr, 1, 8) by completing a trace table to track each function call, low/high bounds, mid value, condition check, and returning values.

A procedure is designed to analyze a 2D grid of size 3x3 and calculate the sum of horizontal and vertical neighbors for each cell. Below is the pseudocode of the algorithm:

PROCEDURE ProcessGrid(Grid : ARRAY[1..3, 1..3] OF INTEGER)
DECLARE Result : ARRAY[1..3, 1..3] OF INTEGER
DECLARE Row, Col : INTEGER
DECLARE Neighbors : INTEGER

FOR Row <- 1 TO 3
FOR Col <- 1 TO 3
Neighbors <- 0
IF Row > 1 THEN
Neighbors <- Neighbors + Grid[Row - 1, Col]
ENDIF
IF Row < 3 THEN
Neighbors <- Neighbors + Grid[Row + 1, Col]
ENDIF
IF Col > 1 THEN
Neighbors <- Neighbors + Grid[Row, Col - 1]
ENDIF
IF Col < 3 THEN
Neighbors <- Neighbors + Grid[Row, Col + 1]
ENDIF
Result[Row, Col] <- Neighbors
ENDFOR
ENDFOR

FOR Row <- 1 TO 3
OUTPUT Result[Row, 1], Result[Row, 2], Result[Row, 3]
ENDFOR
ENDPROCEDURE

The array Grid contains the following initial state:
Row 1: [1, 0, 1]
Row 2: [0, 1, 0]
Row 3: [1, 1, 0]

Dry-run the procedure and write the final printed grid output.

An array `Grades` contains 50 integer values representing exam scores of students. The indices of the array range from 1 to 50.

Write pseudocode for a procedure `ProcessGrades` that takes the `Grades` array as a parameter. The procedure must perform the following tasks:
1. Find the maximum and minimum grades in the array.
2. Calculate the average of all grades *excluding* the single maximum grade and the single minimum grade (i.e. calculate the sum of the remaining 48 grades and divide by 48).
3. Count how many grades in the entire array (including maximum and minimum) are strictly below this calculated average.
4. Output the maximum grade, the minimum grade, the calculated average, and the count of grades below the average, with appropriate descriptive messages.

You must declare all local variables used. Ensure your pseudocode follows the standard Cambridge International A Level Computer Science syllabus conventions.

A software application requires user passwords to be validated before registration.

Write pseudocode for a function `ValidatePassword` that takes a string `Password` as a parameter and returns a boolean value (`TRUE` if the password is valid, and `FALSE` otherwise).

To be valid, the password must satisfy the following criteria:
- It must be between 8 and 15 characters long (inclusive).
- It must contain at least one uppercase alphabetical character (`'A'` to `'Z'`).
- It must contain at least one lowercase alphabetical character (`'a'` to `'z'`).
- It must contain at least one numeric digit character (`'0'` to `'9'`).
- It must not contain any space characters (`' '`).

You must use standard built-in functions:
- `LENGTH(String1 : STRING) RETURNS INTEGER`
- `MID(String1 : STRING, Start : INTEGER, Length : INTEGER) RETURNS STRING`

You must declare all local variables used. Ensure your pseudocode follows standard Cambridge International syllabus conventions.

A 2D array `Grid` has dimensions 10 rows by 10 columns, indexed from 1 to 10 for both row and column. Each cell of the array contains a single character: `'X'`, `'O'`, or `'.'`.

Write pseudocode for a procedure `FindSequences` that takes the array `Grid` as a parameter. The procedure must search the entire array to find all occurrences of exactly three consecutive `'X'` characters in a straight line.
The consecutive characters can be:
1. Horizontal (from left to right in the same row).
2. Vertical (from top to bottom in the same column).

The procedure must output the starting row and column coordinates, along with the direction of the sequence (either `"Horizontal"` or `"Vertical"`), for every such sequence found.

Do not worry about overlapping sequences (e.g., if there are four `'X'`s in a row, it is acceptable to report a sequence starting at column 1 and another starting at column 2). Make sure your checks do not attempt to access array indices out of bounds.

You must declare all local variables used.

A text file named `"Sales.txt"` contains transaction records. Each line of the file contains information about a single sale in a comma-separated format:
`,,`

An example of a line from the file is:
`"CUST4022,Electronics,125.50"`

Write pseudocode for a procedure `SummarizeSales`. The procedure must read the contents of `"Sales.txt"` line by line and perform the following tasks:
1. Calculate and output the total sales amount for the `"Electronics"` category.
2. Find the Customer ID that made the single transaction with the highest sales amount across all categories.
3. Output the customer ID and the amount of this highest transaction.

Assume:
- The file exists, contains at least one line, and is not empty.
- There are no spaces around the commas.
- You can use the standard built-in function `STR_TO_NUM(String1 : STRING) RETURNS REAL` to convert numeric strings to real values.
- Other available string functions:
- `LENGTH(String1 : STRING) RETURNS INTEGER`
- `MID(String1 : STRING, Start : INTEGER, Length : INTEGER) RETURNS STRING`

You must declare all local variables. Show the file operations clearly (opening, reading, closing) using standard Cambridge pseudocode.

Using Boolean algebra theorems and laws, simplify the following expression to show that: \( \overline{(A + \overline{B})} \cdot \overline{(\overline{A} \cdot C)} + A \cdot B = B \cdot (A + \overline{C}) \) where the dot represents AND and the bar represents NOT. State the name of the law or theorem used at each step.

A real number is to be stored using a normalized floating-point representation with an 8-bit mantissa and a 4-bit exponent. Both mantissa and exponent are stored in two's complement form. Convert the denary value \( -6.75 \) into this normalized floating-point format. Show all your working, including how you derived the mantissa and exponent.

A logic system has four inputs: \( A, B, C, \) and \( D \). The system output is active (1) for the following minterms: \( \sum(1, 3, 5, 7, 8, 9, 12, 13) \). (a) Construct a Karnaugh Map (K-map) for this system. (b) Use the K-map to derive a simplified Sum-of-Products (SOP) expression for the output. Show your grouping clearly.

Perform the addition of the following two normalized floating-point numbers: \( X = \text{Mantissa: } 0.1011000, \text{ Exponent: } 0010 \) and \( Y = \text{Mantissa: } 0.1100000, \text{ Exponent: } 0000 \). Both numbers use a normalized 8-bit mantissa and a 4-bit exponent, both in two's complement form. Show all your working. Your final answer must be in the same normalized floating-point format.

A transport logistics company manages various vehicles. An existing superclass `Vehicle` has the private attributes `Registration` (String) and `DailyRate` (Real).

A new class `ElectricCar` is created which inherits from the `Vehicle` class. It has an additional private attribute `BatteryCapacity` (Integer).

Write a pseudocode class definition for `ElectricCar`, including its constructor.

A library software system stores records of type `BookRecord` in a random-access file named `BookFile.dat`.

1. Define the record structure `BookRecord` in pseudocode. It contains the following fields: `ISBN` (string), `Title` (string), and `Available` (boolean).
2. Write a pseudocode procedure `WriteRecord(Address : INTEGER, RecordData : BookRecord)` that opens `BookFile.dat` for random access, writes the given record data at the position specified by `Address`, and closes the file.

A flight booking system has two classes: `Passenger` and `Flight`.

1. A `Flight` object contains an array of 150 `Passenger` objects. Explain whether this relationship represents aggregation or composition, justifying your answer.
2. Write the pseudocode class definition for `Flight`, including only the private attribute `PassengerList` (an array of 150 `Passenger` objects) and its constructor which instantiates the array.

A structured text file `Students.txt` contains student names and test scores. Every student entry takes up exactly two lines:
- Line 1: Student Name (e.g. \"Alice\")
- Line 2: Student Score (e.g. \"85\")

Write a pseudocode procedure `FilterPasses(MinScore : INTEGER)` that reads data from `Students.txt`, and writes the names of all students who achieved a score greater than or equal to `MinScore` to a new text file named `Passed.txt`.

An inheritance hierarchy includes a superclass `Employee` with a method `CalculatePay() : REAL`. A subclass `CommissionEmployee` inherits from `Employee` and has private attributes `BaseSalary` (Real) and `SalesCount` (Integer).

1. Explain the concept of polymorphism within object-oriented programming.
2. Write the pseudocode implementation of the subclass method `CalculatePay()` for `CommissionEmployee`. The method overrides the superclass method, calculating pay as the `BaseSalary` plus an additional $45 for each sale made (`SalesCount`).

An interactive map system contains a variety of interactive nodes. An abstract class `MapNode` is created as the parent of all nodes.

1. State two differences between an abstract class and an interface.
2. Write the pseudocode class definition for the abstract class `MapNode`. It has a private attribute `NodeID` (String), an abstract method `OnTrigger()` that returns a boolean value, and a constructor that sets `NodeID`.

A direct-access/random file `Stock.dat` stores product details of type `StockRecord` at addresses determined by a hash function. The product ID is a 4-digit integer from 1000 to 9999.

The hash function is defined as:
\(Hash(ProductID) = (ProductID \pmod{500}) + 1\)

Write a pseudocode function `FindProduct(TargetID : INTEGER) RETURNS StockRecord` that calculates the file address using the hash function, opens `Stock.dat` for random access, retrieves the record, and returns the record if its product ID matches `TargetID`. If it does not match, it returns an empty/dummy record.

1. Explain why exception handling is necessary when implementing file access operations in an application.
2. Write a pseudocode block to open a binary file `Scores.dat` and read numeric integers until the end of the file is reached, summing the values. The code must implement exception handling using `TRY ... EXCEPT ... ENDTRY` block syntax to catch any file error (e.g., file not found or corrupted file) and display a user-friendly error message.

A computer game uses an object-oriented approach to manage players currently waiting in a lobby.

The class `GameCharacter` has private attributes `CharacterID` (STRING), `Score` (INTEGER), and `Level` (INTEGER). It contains public getter methods: `GetCharacterID()`, `GetScore()`, and `GetLevel()` which return their respective attributes.

A global array `Lobby` is declared as:
`DECLARE Lobby : ARRAY[1:100] OF GameCharacter`

Write pseudocode for a procedure `ArchiveLobby(FileName : STRING)` that:
1. Opens the text file specified by `FileName` for writing.
2. Loops through the entire `Lobby` array.
3. Checks if a character is active (a character is active if their `CharacterID` is not equal to `""`).
4. For each active character, writes their `CharacterID`, `Score`, and `Level` on three separate lines to the file.
5. Closes the file when complete.

A binary tree is to be implemented as an array of nodes. Each node is represented as an instance of a class `Node`.

The class `Node` has three private attributes:
- `Data` (String)
- `LeftPointer` (Integer)
- `RightPointer` (Integer)

1. Write program code to declare the class `Node`. Include:
- A constructor that initializes `Data` to an empty string, and the pointers to `-1`.
- Public getter and setter methods for all three attributes. [5 marks]

2. Declaring global variables:
- Declare a 1D array `Tree` of 15 elements of type `Node`.
- Declare an integer `RootPointer` initialized to `-1`.
- Declare an integer `FreePointer` initialized to `0`.
Write code to initialize the `Tree` array such that each element's `LeftPointer` points to the next free element (creating a free list), with the last element's `LeftPointer` set to `-1`. The `RightPointer` and `Data` should remain initialized as per the constructor. [4 marks]

3. Write a procedure `InsertNode(NewData)` that:
- Checks if the tree is full (i.e., `FreePointer` is `-1`). If full, outputs an error message.
- If not full, retrieves the node at `FreePointer`, sets its `Data` to `NewData`, and updates `FreePointer` to the next free node.
- If `RootPointer` is `-1`, sets `RootPointer` to point to this new node.
- Otherwise, traverses the tree from `RootPointer` to find the correct insertion position (as a binary search tree), and updates the appropriate parent pointer. [8 marks]

4. Write a recursive procedure `InOrder(Pointer)` that performs an in-order traversal of the tree, printing the `Data` of each node. [4 marks]

5. Write a main program that:
- Initializes the tree.
- Inserts the following strings in this order: "Mango", "Apple", "Banana", "Peach", "Plum", "Cherry".
- Calls `InOrder(RootPointer)` to display the elements.
Take a screenshot of the output. [4 marks]

Save your program code and screenshot in your evidence document.

An object-oriented tracking system is being designed for a shipping company. The system tracks standard and express parcels.

1. Define a base class `Parcel` with the following: [8 marks]
- Private attributes:
- `TrackingID` (String)
- `Weight` (Real)
- `BaseCost` (Real)
- A constructor that takes three parameters to initialize these attributes.
- Getter methods for all attributes.
- A method `CalculateCost()` that returns the total delivery cost, calculated as `Weight * BaseCost`.

2. Define a subclass `ExpressParcel` that inherits from `Parcel` and adds the following: [7 marks]
- Private attribute:
- `DaysToDeliver` (Integer)
- A constructor that takes four parameters to initialize both standard and express attributes.
- A getter method for `DaysToDeliver`.
- Overrides the `CalculateCost()` method:
- If `DaysToDeliver` is 1, the total delivery cost is the base parcel cost multiplied by `1.5`.
- If `DaysToDeliver` is 2, the total delivery cost is the base parcel cost multiplied by `1.2`.
- Otherwise, it returns the base parcel cost.

3. Write a main program to: [10 marks]
- Declare a 1D array/list of 5 elements of type `Parcel`.
- Instantiate the following 5 objects into the array:
- A standard parcel with tracking ID "P101", weight 2.5 kg, and base cost $10.00.
- An express parcel with tracking ID "E201", weight 1.5 kg, base cost $12.00, and 1 day to deliver.
- An express parcel with tracking ID "E202", weight 3.0 kg, base cost $8.50, and 2 days to deliver.
- A standard parcel with tracking ID "P102", weight 5.0 kg, and base cost $9.00.
- An express parcel with tracking ID "E203", weight 2.0 kg, base cost $11.00, and 3 days to deliver.
- Loop through the array to display each parcel's `TrackingID` and its total calculated cost.
- Test your program and capture a screenshot of the output.

A text file named `Items.txt` contains stock data. Each line of the file contains an item code and its stock count, separated by a comma. There are exactly 10 lines of data in the file.

Example file content:
```text
C12,24
A05,45
B19,12
D02,88
E15,5
F09,63
G21,30
H11,41
I04,95
J06,17
```

1. Define a class `Item` with public fields `ItemCode` (String) and `StockCount` (Integer). Declare a global 1D array named `Inventory` of 10 elements of type `Item`. [3 marks]

2. Write a function `LoadData()` that reads the data from `Items.txt` and stores each record into the `Inventory` array. [6 marks]

3. Write a procedure `BubbleSort()` that sorts the `Inventory` array in descending order of `StockCount` using a standard bubble sort algorithm. [7 marks]

4. Write a recursive function `RecursiveSearch(Low, High, TargetStock)` that performs a binary search to find an item with the `TargetStock` count. Because the array is sorted in descending order, the search logic must account for this. The function must return the index of the item if found, and `-1` if not. [6 marks]

5. Write a main program that:
- Calls `LoadData()`
- Sorts the array using `BubbleSort()`
- Outputs the sorted inventory (ItemCode and StockCount)
- Prompts the user to search for a stock count, calls `RecursiveSearch`, and outputs the matching `ItemCode` if found, or an appropriate message if not found. [3 marks]

Save your program code and screenshot of the output in your evidence document.