MetadataPastPaper.sampleTitle

Which network protocol is primarily used by an email client to send an email to a mail server?

An 8-bit binary register contains the value 00111000. Which binary pattern represents the result of applying a logical right shift of two places to this value?

Utility software is a type of system software. Which one of these is a function of defragmentation utility software?

An individual intercepts transmission data over a wireless network without permission. Which UK legislation is specifically violated by this unauthorised access to computer material?

An uncompressed image has a width of \(W\) pixels, a height of \(H\) pixels, and a colour depth of \(C\) bits. Construct a formula to calculate the total file size of this image in bytes.

A media file of size \(S\) megabytes (MB) is transmitted across a local area network with an average speed of \(R\) megabits per second (Mbps). Construct a mathematical formula to find the theoretical transmission time in seconds. Assume 1 megabyte is exactly equal to 8 megabits.

Convert the denary number 141 into an 8-bit binary number, and then convert that binary sequence into its hexadecimal equivalent. State only the final hexadecimal value as your answer.

A binary search is conducted on the following sorted list of integers to find the target value 33: [3, 8, 12, 15, 21, 28, 33, 47, 50]. Indices range from 0 to 8. Assuming the midpoint index is calculated using integer division (mid = (low + high) // 2), list the sequence of values that are compared with the target until it is found.

Evaluate the arithmetic output of the following programming expression. Show your intermediate working: (23 MOD 5) * (17 DIV 3)

Explain the primary difference between passing an argument to a subprogram by value and passing it by reference.

A two-dimensional array named 'matrix' is defined as follows: matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]. Assuming array indices start at 0, write a syntax expression to access the value 6 from this array.

State the difference between how a compiler and an interpreter handle the translation and execution of high-level programming language code.

A processor performs an arithmetic shift left by 3 places on the 8-bit binary pattern 00010110. State the resulting 8-bit binary pattern.

A 10-second mono audio file is recorded with a sample rate of 44,100 Hz and a bit depth of 16 bits. State the formula, using exact values, to calculate the file size in bytes. Do not calculate the final answer.

State two differences between a Media Access Control (MAC) address and an Internet Protocol (IP) address.

Explain one advantage of using local variables rather than global variables in subprograms.

An outdoor wildlife camera records video onto an SD card (solid-state) rather than a CD-R (optical). Explain one reason why solid-state storage is more suitable for this device.

Describe one benefit of using a compiler instead of an interpreter to translate high-level program code into machine code.

An ordered list contains the following elements: [3, 8, 12, 15, 21, 28, 32]. State the list of elements that will be compared to the search key 28 during a binary search, in the correct order.

Modern data centres consume massive amounts of electricity. Explain one action a data centre company can take to reduce its environmental impact.

Express the denary number -43 as an 8-bit two's complement binary integer. Show your working.

A file of size 6 Megabytes (MB) is transmitted over a network at a speed of 16 Megabits per second (Mbps). Calculate the theoretical minimum transmission time in seconds. Show your working.

State the final value of the variable result after executing the following expression: result = (29 MOD 6) * (14 DIV 3).

An ordered list contains the following 15 elements: [2, 5, 8, 12, 16, 23, 38, 45, 56, 60, 72, 80, 85, 90, 99]. Using a standard binary search algorithm where the midpoint is rounded down (using integer division), state all the elements that will be compared to find the search key 85 in the exact order they are compared.

A magnetic hard disk drive (HDD) has a total storage capacity of 4 TB. An operating system and essential applications take up 800 GB. If each high-definition movie file is 8 GB in size, calculate the maximum number of movies that can be stored on the remaining space of the HDD. (Assume \(1 \text{ TB} = 1000 \text{ GB}\)).

An uncompressed image file has a size of 4.5 MB. After applying a lossless compression algorithm, the size of the file is reduced to 1.8 MB. Calculate the compression ratio achieved, expressed as a simplified ratio of the original size to the compressed size in the format X:Y.

State the output of the final print statement in this pseudocode: SET globalVar TO 15; FUNCTION modifyValue(num) SET num TO num * 2; RETURN num - 5; ENDFUNCTION; SET result TO modifyValue(globalVar); SEND globalVar TO DISPLAY

Under the UK Data Protection Act 2018, state the specific term used to describe the individual or organization that determines the purposes and means of processing personal data.

An uncompressed bitmap image has a width of 1200 pixels and a height of 800 pixels. The image is saved with a colour depth of 16 bits.

Construct an expression to calculate the minimum file size of this image in kibibytes (KiB). You do not need to calculate the final answer.

A small accounting firm is planning to replace all 50 of its old office desktop computers with "thin client" terminals that connect to a cloud-hosted server.

Discuss the ethical and environmental impacts of the firm's decision to move to thin clients and cloud-hosted storage.

In your answer, you should consider:
- the environmental benefits and drawbacks of cloud servers versus local desktop computers
- the ethical implications regarding the disposal of the old hardware and data privacy.

An algorithm is designed to calculate the average of positive numbers. A flowchart for this algorithm has four missing boxes: Box A, Box B, Box C, and Box D.

- Box A is an initialization process box at the start.
- Box B is a decision box checking for the terminating condition (a negative number entered by the user).
- Box C is a process box to update the running total.
- Box D is a process box to update the count of numbers.

State the exact statements or conditions that should be placed inside Box A, Box B, Box C, and Box D to ensure the flowchart operates correctly.

A flowchart controls an automated greenhouse window using two inputs: temperature (stored in variable T) and humidity (stored in variable H).

- If T is greater than 25 and H is greater than 60, the window is opened (outputs 'OPEN').
- Otherwise, if T is less than 18, the window is closed (outputs 'CLOSE').
- In all other cases, the window remains in its current state (no action/outputs 'KEEP').

The flowchart has four blank components:
- Box P (Decision shape)
- Box Q (Output shape if Box P is True)
- Box R (Decision shape if Box P is False)
- Box S (Output shape if Box R is True)

Identify the exact conditions or outputs that must be placed inside Box P, Box Q, Box R, and Box S.

A programmer is writing a Python program to process student exam results.

The function `calculate_passing_average(student_data)` is designed to accept a list of student dictionaries, filter out any students who did not pass, and print the average score of those who did pass.

A passing score is defined as **50 or above**. If no students passed, the program should print `"No students passed."`.

The programmer's initial attempt contains five distinct errors.

Review the buggy code below:

```python
def calculate_passing_average(student_data):
total_score = "0"
count = 0
for student in student_data:
score = student["score"]
if score > 50:
total_score =+ score
count += 1

if count = 0:
print("No students passed.")
else:
average = total_score / count
print("The average passing score is: " + average)
```

Correct the code so that it functions as specified and contains no errors. You must write out the fully corrected code.

An analyst is developing a Python subprogram to encrypt messages using a Caesar cipher. The function `encrypt_caesar(plaintext, shift)` takes a string parameter representing the message to encrypt, and an integer parameter representing the key (shift).

The function must:
1. Loop through each character of the `plaintext` input.
2. If the character is an uppercase letter (A-Z), shift it by the key value, wrapping around the alphabet if necessary.
3. Keep non-uppercase characters (such as spaces or punctuation) unchanged.
4. Build and return the encrypted `ciphertext` string.

Here is the incomplete Python code with five missing segments labeled **GAP 1** to **GAP 5**:

```python
def encrypt_caesar(plaintext, shift):
ciphertext = ""
for char in plaintext:
if char.isupper():
# GAP 1
...
# GAP 2
...
# GAP 3
...
# GAP 4
...
else:
# GAP 5
...
return ciphertext
```

Study the tables below and select the correct option code for each gap.

### **GAP 1 Options (Find ASCII value of the character)**
* **A1**: `char_code = chr(char)`
* **A2**: `char_code = ord(char)`
* **A3**: `char_code = ascii(char)`

### **GAP 2 Options (Subtract base 'A' [ASCII 65] and apply the shift)**
* **B1**: `shifted_code = char_code - 65 + shift`
* **B2**: `shifted_code = char_code + shift`
* **B3**: `shifted_code = (char_code + shift) - 97`

### **GAP 3 Options (Perform modulo 26 to wrap around and add back base 'A')**
* **C1**: `wrapped_code = (shifted_code % 26) + 65`
* **C2**: `wrapped_code = shifted_code % 26`
* **C3**: `wrapped_code = (shifted_code % 26) - 65`

### **GAP 4 Options (Convert ASCII back to character and append to ciphertext)**
* **D1**: `ciphertext = ciphertext + wrapped_code`
* **D2**: `ciphertext = ciphertext + chr(wrapped_code)`
* **D3**: `ciphertext = ciphertext + str(wrapped_code)`

### **GAP 5 Options (Append unmodified non-alphabetic characters)**
* **E1**: `ciphertext = ciphertext + char`
* **E2**: `ciphertext = char`
* **E3**: `ciphertext = ciphertext + ord(char)`

Write down your final choices for GAP 1 to GAP 5 using their corresponding identifiers.

An analyst is designing and testing algorithms that process sequences of numbers.

### Part A (6 marks)

A Python function `generate_sequence` is defined below. It takes two integer parameters, `start` and `limit`, and returns a list containing a generated sequence.

```python
def generate_sequence(start, limit):
seq = []
current = start
while current < limit and len(seq) < 6:
if current % 2 == 0:
current = (current // 2) + 3
else:
current = (current * 3) - 1
seq.append(current)
return seq
```

Complete the trace table for the function call `generate_sequence(4, 50)`.

| Iteration / Step | `current` | `current < limit` | `len(seq) < 6` | `seq` |
| :--- | :--- | :--- | :--- | :--- |
| **Initial state** | 4 | | | [] |
| **Loop Iteration 1** | | | | |
| **Loop Iteration 2** | | | | |
| **Loop Iteration 3** | | | | |
| **Loop Iteration 4** | | | | |
| **Loop Iteration 5** | | | | |
| **Loop Iteration 6** | | | | |
| **Final Loop Check** | | | | |

---

### Part B (4 marks)

Identify the missing code required to complete the functions below.

**(i)** The function `construct_sequence(n)` should generate a sequence containing the first `n` terms of the geometric sequence: \(1, -2, 4, -8, 16, -32, \dots\)

Complete line 6 with an expression to update the value of `term`.

```python
def construct_sequence(n):
seq = []
term = 1
for i in range(n):
seq.append(term)
term = ________(i)________
return seq
```

**(ii)** The function `alternating_sum(numbers)` should sum all elements in a list, but alternate between adding and subtracting elements based on whether their index is even or odd (e.g. `alternating_sum([10, 2, 5, 3])` returns \(10 - 2 + 5 - 3 = 10\)).

Complete line 5 with a logical condition to check if the current index `i` is even.

```python
def alternating_sum(numbers):
total = 0
for i in range(len(numbers)):
if ________(ii)________:
total = total + numbers[i]
else:
total = total - numbers[i]
return total
```

An algorithm is represented by the following flowchart description. Write a Python program that implements this algorithm.

### Flowchart Description
* **Start**
* **Input**: Ask the user to enter their order total. Store this real number in a variable named `order_total`.
* **Input**: Ask the user if they have a loyalty card. Store this string in a variable named `loyalty`.
* **Decision**: Test if `loyalty` is equal to `"Y"` OR `loyalty` is equal to `"N"`.
* **If NO**:
* **Output**: `"Error: Invalid loyalty choice"`
* **Stop** (The program must stop and not perform any further calculations).
* **If YES**:
* **Decision**: Test if `loyalty` is equal to `"Y"`.
* **If YES**:
* **Decision**: Test if `order_total` is greater than or equal to `100.0`.
* **If YES**: Set `discount_rate` to `0.15`.
* **If NO**: Set `discount_rate` to `0.10`.
* **If NO**:
* **Decision**: Test if `order_total` is greater than or equal to `100.0`.
* **If YES**: Set `discount_rate` to `0.05`.
* **If NO**: Set `discount_rate` to `0.0`.
* **Process**: Calculate `discount_amount` as `order_total * discount_rate`.
* **Process**: Calculate `final_price` as `order_total - discount_amount`.
* **Output**: Display `"Final price is: "` followed by the calculated `final_price`.
* **Stop**

### Requirements
1. Use Python to write the program.
2. Ensure you use the exact variable names specified: `order_total`, `loyalty`, `discount_rate`, `discount_amount`, and `final_price`.
3. Your inputs and outputs must match the requirements of the flowchart description exactly.

A programmer is developing a tournament tracking system for a school's annual sports day. They need to manage team names and their respective scores.

Write a Python program that meets the following requirements:
1. Create a 1D list called `houses` containing the strings: "Red", "Blue", "Green", "Yellow".
2. Create a 1D list called `points` containing the integers: 120, 95, 150, 110 (in the same order as the houses).
3. Define a function called `find_highest` that takes two parameters (representing the lists of houses and points). The function must:
- Use a loop to find the house with the highest score.
- Return both the name of the house and its score.
4. Define a procedure called `add_points` that takes four parameters: the list of houses, the list of points, a target house name (string), and additional points (integer). The procedure must:
- Perform a linear search to find the target house name in the houses list.
- If the house is found, add the additional points to its score in the points list.
- If the house is not found, print the message "House not found".
5. In the main part of the program:
- Call the `add_points` procedure to add 25 points to "Green".
- Call the `find_highest` function to get the winning house and its points.
- Print the winning house and its score in the exact format: "Winner: [House] with [Points] points."

A school sports department has a text file named results.txt containing student athletic performances. Each line of the file contains the following data fields separated by commas:

Name, Event, Time

For example:
Alice,100m,12.5
Bob,200m,24.1

Write a Python program to process this file. Your program must perform the following actions:
1. Read the records from results.txt.
2. Validate each record according to these rules:
- Name must not be blank.
- Event must be exactly '100m', '200m', or '400m'.
- Time must be a positive float value greater than 0.0.
3. Keep a count of all invalid records encountered.
4. Write all valid records to a new file named clean_results.txt in the same format (comma-separated).
5. Identify the student with the fastest (lowest) time in the '100m' event from the valid records.
6. Display the total number of invalid records discarded.
7. Display the name and time of the fastest '100m' runner.