MetadataPastPaper.sampleTitle

(a) Sampling Rate: The frequency with which samples are taken per unit of time (typically per second, measured in Hz). Sampling Resolution: The number of bits used to represent/encode each sampled amplitude value (also called bit depth). (b) (i) Quality: Increases/improves because the digital signal is a closer approximation of the original continuous analog sound wave, reducing distortion (quantisation noise). (ii) File size: Increases because more data points are stored per second, and each data point requires more bits. (c) (i) Sampling, (ii) DAC (Digital-to-Analog Converter), (iii) Quantisation.

Total: 10.7 Marks. (a) 4 marks: 2 marks for clear definition of Sampling Rate (1 mark for number of samples, 1 mark for per second/Hertz); 2 marks for Sampling Resolution (1 mark for number of bits, 1 mark for representing amplitude/levels). (b) 3.7 marks: 1.85 marks for explaining quality improvement (closer approximation/less noise), 1.85 marks for explaining file size increase (more bytes/bits required per second of audio). (c) 3 marks: 1 mark each for correctly matching (i) Sampling, (ii) DAC, and (iii) Quantisation.

(a) Operation of CSMA/CD: 1. A node listens to the transmission channel (carrier sensing) to check if it is idle. 2. If the channel is idle, the node begins transmitting data. 3. During transmission, the node continuously monitors the channel for a collision (collision detection). 4. If a collision is detected, transmitting nodes immediately halt current transmission and send a 'jam signal' to alert all other devices on the segment. 5. Each node waits for a random period of time (backoff algorithm) before attempting to retransmit, preventing them from colliding again immediately. (b) Matches: (i) Router (connects different networks, routes packets via IP addresses). (ii) Bridge (connects LAN segments at Data Link layer). (iii) Switch (directs frames to specific ports using MAC addresses). (iv) NIC (network interface, MAC address hardware representation).

Total: 10.7 Marks. (a) 6.7 marks: 1.34 marks for each of the key steps up to 5 steps (listening before sending, sending when free, detecting collision, sending jam signal, waiting random time/backoff). (b) 4 marks: 1 mark for each correct device match ((i) Router, (ii) Bridge, (iii) Switch, (iv) NIC).

(a) (i) PC - Program Counter stores the memory address of the next instruction to be executed. (ii) MDR - Memory Data Register holds the instruction/data fetched from memory. (iii) MAR - Memory Address Register holds the address of the memory location currently being read from or written to. (iv) CIR - Current Instruction Register holds the instruction currently being decoded and executed. (b) Functions of the Control Unit (CU) during execution: 1. Instruction decoding: The CU decodes the opcode stored in the CIR to determine what operation needs to be performed. 2. Generating control signals: The CU sends synchronization and control signals (such as read/write control, bus grant, clock pulses) to coordinate the flow of data within the CPU (e.g., ALU, registers) and external devices (RAM, I/O).

Total: 10.7 Marks. (a) 6.7 marks: 1.675 marks per correct match ((i) PC, (ii) MDR, (iii) MAR, (iv) CIR). (b) 4 marks: 2 marks for each well-described function of the Control Unit during execution (e.g., decoding opcode, issuing control signals to coordinate components, managing clock synchronization).

(a) (i) Primary Key: An attribute or collection of attributes that uniquely identifies each record/tuple in a table. (ii) Foreign Key: An attribute in one table that refers to/matches the primary key in another table, establishing a link/relationship between the tables. (iii) Composite Key: A primary key consisting of two or more attributes that together uniquely identify a record, used when single attributes cannot guarantee uniqueness. (b) (i) First Normal Form (1NF) - no repeating groups and all values are atomic. (ii) Third Normal Form (3NF) - in 2NF and no transitive dependencies. (iii) Second Normal Form (2NF) - in 1NF and no partial key dependencies.

Total: 10.7 Marks. (a) 6 marks: 2 marks for each clear definition (Primary, Foreign, Composite). (b) 4.7 marks: 1.57 marks each for correct matching of normalisation levels ((i) 1NF, (ii) 3NF, (iii) 2NF).

(a) Parameter passing mechanisms: - By Value (BYVAL): A local copy of the parameter's value is created for the subroutine. Any modifications within the subroutine affect only this local copy, leaving the original calling variable unchanged. - By Reference (BYREF): The memory address of the actual parameter is passed to the subroutine. Any changes made inside the subroutine are made directly to the original variable in the calling scope. (b) Trace of execution: - Initially, a is 10 and b is 10. - a is passed by value (BYVAL), so x becomes 10 (copy). x is multiplied by 2 to become 20, but the original a remains 10. - b is passed by reference (BYREF), so y refers directly to b. y is multiplied by 3, making y (and hence b) equal to 30. - Therefore, the output is: a = 10, b = 30. (c) Benefits of local variables over global variables: 1. Encapsulation/Modularity: Local variables exist only within the scope of the subroutine, preventing accidental side-effects where other parts of the program overwrite data. 2. Reusability: Subroutines with local variables are self-contained and can be copied/moved to other projects easily. 3. Memory efficiency: Local variables are destroyed when the subroutine finishes, freeing up memory, whereas global variables persist throughout the program execution.

Total: 10.7 Marks. (a) 4 marks: 2 marks for clear explanation of BYVAL (passing a copy, no effect on original); 2 marks for BYREF (passing memory address, directly affects original). (b) 2.7 marks: 1.35 marks for stating a remains 10; 1.35 marks for stating b becomes 30. (c) 4 marks: 2 marks each for two distinct reasons (e.g., avoiding side-effects/easier debugging, self-containment for reusability, efficient memory management).

(a) Comparison: - Data Validation: An automated system check performed by software to verify that the entered data meets specific, pre-defined rules/criteria (sensible, reasonable, and valid) before processing. Example: Range check (e.g., checking that a percentage is between 0 and 100). - Data Verification: A process of checking that data has been entered or transferred accurately from the source document without corruption or errors. Example: Double data entry (entering data twice and comparing) or visual check (comparing screen output with original paper source). (b) Matches: (i) Presence check - ensures required field is not empty. (ii) Length check - checks number of characters. (iii) Format check - checks structure/pattern. (iv) Range check - checks numerical upper/lower limits.

Total: 10.7 Marks. (a) 6.7 marks: 2 marks for defining Validation, 1.35 marks for a valid Validation example; 2 marks for defining Verification, 1.35 marks for a valid Verification example. (b) 4 marks: 1 mark for each correct match ((i) Presence check, (ii) Length check, (iii) Format check, (iv) Range check).

(a) Matches: (i) File management (handles directory structure, access permissions, compression). (ii) Process management (allocates processor time, handles execution states, scheduling). (iii) Memory management (handles RAM allocation, virtual memory, paging). (iv) Device management (handles peripheral communication, device drivers). (b) Key differences between Compiler and Interpreter: 1. Translation process: A compiler translates the complete source code of a program into an independent executable machine code file (object code) before run-time. An interpreter translates and executes the source code line-by-line (or statement-by-statement) at run-time without creating an independent executable file. 2. Error reporting: A compiler produces an error report for the entire program only after scanning the whole source code, meaning code cannot run until all syntax errors are fixed. An interpreter stops execution immediately at the line where an error is found, making it easier to pinpoint/debug errors on the fly.

Total: 10.7 Marks. (a) 6.7 marks: 1.675 marks per correct match ((i) File management, (ii) Process management, (iii) Memory management, (iv) Device management). (b) 4 marks: 2 marks for each well-formulated, contrasting difference (1 mark for Compiler aspect, 1 mark for corresponding Interpreter aspect).

The function first checks if the string length is exactly 8. It then validates characters 1 to 3 to verify they are within the uppercase ASCII range (65-90). Character 4 is checked for a hyphen. Characters 5 to 8 are verified to be digit characters (48-57). Finally, the numeric values of digits 5, 6, and 7 are extracted, summed, and modulo-10 checked against the 8th digit.

The 9.375 total marks are split across 5 criteria (1.875 marks each):
- Criterion 1: Correct function header and return type definition along with checking if Code is exactly 8 characters.
- Criterion 2: Correctly loop and validate characters 1-3 are uppercase (ASCII 65 to 90).
- Criterion 3: Correctly check character 4 is a hyphen and characters 5-8 are digits (ASCII 48 to 57).
- Criterion 4: Correctly convert characters 5, 6, and 7 to numbers and calculate the sum MOD 10 check digit.
- Criterion 5: Correctly compare the calculated check digit with the 8th character and return TRUE if valid, otherwise FALSE.

The procedure opens the specified file in write mode, iterates through indices 1 to 100 of the 2D array, converts each score from string to numeric form, checks if it is strictly greater than the pass mark, writes matching records to the file, and finally closes the file.

The 9.375 total marks are split across 5 criteria (1.875 marks each):
- Criterion 1: Correct procedure header definition and local variables declaration.
- Criterion 2: Correct file opening operation for WRITE and closing operation at the end.
- Criterion 3: Correct loop structure to iterate from 1 to 100.
- Criterion 4: Correct logic to extract, convert, and compare the score with the pass mark.
- Criterion 5: Correct writing of student name and score to the file using correct format and concatenation.

The function checks if NumItems is 12 (the maximum capacity of the array). If so, it returns FALSE. Otherwise, it updates TailPointer in a circular fashion (resetting to 1 if it is currently 12, or incrementing by 1). The item is inserted at the updated TailPointer position, NumItems is incremented, and TRUE is returned.

The 9.375 total marks are split across 5 criteria (1.875 marks each):
- Criterion 1: Correct function header and BOOLEAN return type statement.
- Criterion 2: Correctly checking if the queue is full and returning FALSE immediately.
- Criterion 3: Correctly updating TailPointer to handle circular movement (wrap around from 12 to 1).
- Criterion 4: Correctly writing NewItem into the Queue array at the index specified by TailPointer.
- Criterion 5: Correctly incrementing NumItems and returning TRUE.

The base case is an empty string, which returns 0. If the string is not empty, the first character is extracted using MID(Text, 1, 1) and compared with Target. If they match, the result is 1 plus the recursive call on the rest of the string. If they do not match, the result is simply the recursive call on the rest of the string.

The 9.375 total marks are split across 5 criteria (1.875 marks each):
- Criterion 1: Correct function header, parameter definitions, and INTEGER return type statement.
- Criterion 2: Correct base case condition (checking if length is 0) returning 0.
- Criterion 3: Correctly extracting and checking the first character of the string.
- Criterion 4: Correctly generating the remaining substring using MID(Text, 2, LENGTH(Text) - 1).
- Criterion 5: Correct recursive calls made within both branches of the conditional logic (no loops used).

First, the record definition for Course is declared with CourseCode, Title, and MaxStudents. The function FindCourse loops through each element of the CourseList array from 1 to 50, checking if the current element's CourseCode matches the argument Code. If a match is found, the index is immediately returned. If the loop completes without a match, -1 is returned.

The 9.375 total marks are split across 5 criteria (1.875 marks each):
- Criterion 1: Correct definition of the composite type Course using TYPE ... ENDTYPE with correct fields and data types.
- Criterion 2: Correct function header FindCourse with parameter and return type declaration.
- Criterion 3: Correct loop structure to traverse index 1 to 50 of CourseList.
- Criterion 4: Correct dot-notation syntax to reference record field CourseList[i].CourseCode.
- Criterion 5: Correct return values for both conditions (index on match, -1 on search failure).

The procedure opens the file, and checks if it is empty using EOF(). If empty, it outputs a warning. Otherwise, it uses a WHILE NOT EOF() loop to read wind speeds line-by-line, updating count, total speed, and tracking the maximum speed. After closing the file, it outputs the statistics.

The 9.375 total marks are split across 5 criteria (1.875 marks each):
- Criterion 1: Correct procedure header definition and initialization of variables (Count, Total, MaxSpeed).
- Criterion 2: Correct file opening operation and checking for empty file using EOF() before processing.
- Criterion 3: Correct loop structure reading line-by-line until EOF() is reached.
- Criterion 4: Correct data conversion from string to real and updating count, total speed, and tracking the maximum speed.
- Criterion 5: Correct closure of the file and outputting of the statistics (maximum, average, total) with appropriate text prompts.

The procedure implements bubble sort using a REPEAT-UNTIL loop controlled by a Swapped boolean flag and a Limit variable. In each pass, adjacent elements are compared and swapped if they are in ascending order (which sorts the array descending). Limit is decreased by 1 after each pass because the smallest element bubbles to the end. The loop stops if no elements were swapped during a pass.

The 9.375 total marks are split across 5 criteria (1.875 marks each):
- Criterion 1: Correct procedure header and local variable declarations (i, Temp, Limit, Swapped).
- Criterion 2: Correct outer loop (REPEAT...UNTIL or WHILE) controlled by the Swapped flag.
- Criterion 3: Correct inner loop structure iterating up to Limit to avoid redundant comparisons.
- Criterion 4: Correct comparison condition for sorting in descending order (InventoryCount[i] < InventoryCount[i + 1]).
- Criterion 5: Correct swapping of array elements using a temporary variable and correctly managing the Swapped state.

The function initializes variables to track total baggage weight and priority counts. It loops through all 150 elements in the Manifest array. Inside the loop, it checks if a passenger's BaggageWeight exceeds the specified Limit. If it does, their baggage weight is added to the running total, and if they are also priority passengers, the count is incremented. The count is outputted at the end, and the total weight is returned.

The 9.375 total marks are split across 5 criteria (1.875 marks each):
- Criterion 1: Correct function header and return type definition (RETURNS REAL) with correct variable initialization.
- Criterion 2: Correct loop structure from 1 to 150 to iterate through Manifest.
- Criterion 3: Correct record field access syntax (Manifest[i].BaggageWeight) and comparison with Limit.
- Criterion 4: Correct logic to accumulate total weight and count priority passengers under the criteria conditions.
- Criterion 5: Correct screen output format of the priority count and return statement for TotalWeight.