MetadataPastPaper.sampleTitle

To convert Gigabytes to Megabytes, multiply the value by either 1000 or 1024.

Using 1000:
\(3.5 \times 1000 = 3500\text{ MB}\)

Using 1024:
\(3.5 \times 1024 = 3584\text{ MB}\)

1 mark for showing correct method (multiplying 3.5 by 1000 or 1024).
1 mark for the correct numerical calculation (3500 or 3584).
0.5 marks for including the correct unit (MB).

During the Fetch stage, the Program Counter (PC) passes the address of the next instruction to the MAR. The CPU then sends a signal to RAM to fetch the instruction stored at that address. The fetched instruction is copied from memory (RAM) into the MDR.

1 mark for stating that the MAR holds the memory location/address of the instruction/data to be fetched.
1 mark for stating that the MDR holds the actual data/instruction that has been retrieved from memory.
0.5 marks for explaining the relationship (e.g., data from the address in MAR is copied into the MDR).

1. Sampling frequency: Increasing this means more samples of the sound wave are taken per second, leading to a more accurate representation (higher quality) and more data stored (larger file size).
2. Bit depth: Increasing this means more bits are allocated per sample, allowing a wider dynamic range and finer volume steps (higher quality) but requiring more bits per sample (larger file size).

1 mark for explaining the effect of increasing sampling frequency on both quality and file size.
1 mark for explaining the effect of increasing bit depth on both quality and file size.
0.5 marks for providing a coherent concluding summary of why more data is captured.

TCP is responsible for breaking the data down into packets, numbering them to ensure they can be reassembled in the correct order, and performing error checking to detect lost packets. IP is responsible for adding source and destination IP addresses to packets and routing them across the network.

1 mark for explaining TCP's role (packetization, sequencing, error correction/retransmission).
1 mark for explaining IP's role (addressing, routing packets across networks).
0.5 marks for identifying how they work in tandem to guarantee delivery.

Solid State storage (such as an SD card) is ideal because:
1. It has no moving parts, making it highly durable and shock-resistant if dropped during outdoor sports photography.
2. It has fast read/write speeds, allowing rapid saving of high-resolution image bursts.

0.5 marks for identifying 'Solid State' (or SSD / Flash memory).
1 mark for explaining durability/shock-resistance (due to no moving parts).
1 mark for explaining speed (fast write speed for high-res photos) OR portability (small size, lightweight for carrying outdoors).

The OS manages memory by allocating blocks of RAM to active processes. If the RAM is filled, the OS sets up Virtual Memory, allocating partition space on secondary storage (like an HDD/SSD). Inactive data from RAM is swapped (paged) out to Virtual Memory, freeing up space in RAM for active tasks. When the swapped data is needed again, it is loaded back into RAM.

1 mark for explaining RAM allocation (storing active programs/data for fast access).
1 mark for explaining the role of Virtual Memory (using secondary storage to extend RAM when full).
0.5 marks for explaining the concept of 'swapping' or 'paging' data between RAM and Virtual Memory.

Positive impact: Thin clients require far less electrical energy than full desktops, which reduces the school's daily energy usage and lowers its carbon footprint.
Negative impact: Disposing of 200 old desktop computers creates a massive amount of electronic waste (e-waste), which may end up in landfills, releasing toxic chemicals if not recycled properly.

1 mark for a clearly explained positive environmental impact (e.g., lower electricity consumption/fewer raw materials to manufacture thin clients).
1 mark for a clearly explained negative environmental impact (e.g., e-waste disposal, carbon footprint of manufacturing and shipping 200 new devices).
0.5 marks for indicating a long-term consequence (e.g., toxic chemicals in landfill, reduction in coal/fossil fuel demand).

An embedded system is a dedicated computer system built within a larger mechanical or electrical system. The washing machine's microcontroller has a single, specific function (controlling the wash programs) rather than being general-purpose. It is typically stored on a single microprocessor chip with software permanently burned into ROM.

1 mark for identifying the first characteristic (e.g., dedicated single-purpose system / built into a larger device).
1 mark for identifying the second characteristic (e.g., limited/no user programming / low power / ROM-based firmware).
0.5 marks for directly linking these characteristics to the washing machine's context (e.g., controlling temperature/spin cycle).

To calculate the file size of an audio file, we use the formula:
\(\text{File size (bits)} = \text{duration (seconds)} \times \text{sample rate (Hz)} \times \text{bit depth}\)

Substituting the given values:
\(\text{File size (bits)} = 10 \times 100 \times 16 = 16,000\text{ bits}\)

To convert the size from bits to bytes, divide by 8:
\(\text{File size (bytes)} = 16,000 / 8 = 2,000\text{ bytes}\)

Award up to 2 marks:
- 1 mark for showing correct working, multiplying duration, sample rate, and bit depth, then dividing by 8 (e.g., \(10 \times 100 \times 16 / 8\) or \(16,000 / 8\)).
- 1 mark for the correct final answer of 2,000 bytes (accept 2000 or 2000B without units if working is shown).

During the fetch stage of the cycle, the CPU performs the following steps:
1. The memory address of the instruction is copied from the Program Counter (PC) into the Memory Address Register (MAR).
2. The CPU sends a request to RAM using the address specified in the MAR.
3. The actual instruction/data stored at that address in RAM is then copied into the Memory Data Register (MDR).

Award up to 3 marks:
- 1 mark for explaining that the MAR stores/holds the memory address of the instruction or data to be fetched.
- 1 mark for explaining that the address in the MAR is used to locate/access the data in the main memory (RAM).
- 1 mark for explaining that the MDR receives and holds the actual instruction or data that has been fetched from memory.

During the Fetch stage:
1. The Memory Address Register (MAR) is loaded with the memory address of the instruction currently pointed to by the Program Counter (PC).
2. The CPU sends a request along the address bus to physical RAM using this address.
3. The actual instruction or data stored at that address is retrieved from RAM and sent back via the data bus.
4. This fetched instruction/data is then received and stored in the Memory Data Register (MDR) before being sent to the Instruction Register for decoding.

Award up to 4 marks.
- 1 mark for stating that the MAR holds/stores the address of the instruction/data to be fetched.
- 1 mark for explaining that this address is sent to main memory (RAM) via the address bus.
- 1 mark for stating that the MDR holds the actual data or instruction once it has been fetched from RAM.
- 1 mark for explaining that this data travels from RAM to the MDR via the data bus.

Embedded systems are specialized computers built into larger physical systems.
- Characteristic 1: Dedicated/Single Purpose. Unlike a general-purpose PC, the software is written for one job. In a microwave, this means controlling magnetron power, the turntable motor, and timer sensors.
- Characteristic 2: Resource Constraints / Real-time response. The system must respond instantly to safety triggers (like opening the door during cooking) and runs on low-power, low-memory hardware to minimize manufacturing cost.

Award up to 4 marks.
- 1 mark for identifying a valid characteristic of an embedded system (e.g., dedicated/single-purpose, real-time response, limited UI, program stored in ROM).
- 1 mark for applying this characteristic to the smart microwave scenario.
- 1 mark for identifying a second valid characteristic.
- 1 mark for applying this second characteristic to the smart microwave scenario.

RAM (Random Access Memory) and ROM (Read Only Memory) serve distinct roles in a gaming console:
- RAM is volatile primary storage. When the console is on, the active OS processes and currently running game data are copied here from the slower secondary storage so the CPU can access them quickly. Once the power is cut, this data is lost.
- ROM is non-volatile primary storage. It cannot be easily written to. It contains the essential boot instructions (BIOS/firmware) that initialize the console's screen, controllers, and memory cards upon startup.

Award up to 4 marks.
- 1 mark for stating RAM is volatile AND ROM is non-volatile.
- 1 mark for explaining RAM can be read from and written to, whereas ROM is read-only.
- 1 mark for explaining what RAM stores in this context (e.g., current game code, temporary player position, active graphics data).
- 1 mark for explaining what ROM stores in this context (e.g., the bootloader, BIOS, or initial startup instructions).

In a vehicular environment:
- Physical Durability: Solid State storage uses electronic flash memory, making it highly shock-resistant. Optical drives require a laser to precisely read/write on a physical spinning disc, which would fail immediately due to vehicular vibrations.
- Form Factor & Capacity: Dashcams must be compact. A microSD card (SSD technology) easily fits inside a tiny camera housing and can hold hundreds of gigabytes, whereas optical discs are physically large and hold very limited data.

Award up to 4 marks.
- 1 mark for explaining that SSD has no moving parts making it shock-resistant/durable, whereas optical drives are fragile and prone to skipping due to physical movements/vibrations.
- 1 mark for comparing write speeds (SSD is much faster at writing HD video streams continuously than optical).
- 1 mark for comparing capacity/size (SSD can store much more data in a tiny form factor suitable for a dashcam).
- 1 mark for a clear concluding statement justifying why SSD is appropriate for this specific vehicle environment.

- Star Topology Advantage: Lower cost and ease of setup. Each node only needs a single cable connecting to the central switch. Adding a new computer to the clinic's reception requires running only one new cable.
- Mesh Topology Advantage: Redundancy. Since every node is connected to every other node, there is no single point of failure. If one path fails, critical patient monitoring data can take alternative paths to reach the server.

Award up to 4 marks.
- 1 mark for identifying an advantage of a star topology (e.g., cheaper to install, easier to add new devices, less cabling).
- 1 mark for explaining this star advantage in contrast to mesh (e.g., mesh requires a high number of redundant connections making it expensive).
- 1 mark for identifying an advantage of a mesh topology (e.g., high redundancy, no single point of failure, high reliability for critical systems).
- 1 mark for explaining this mesh advantage in contrast to star (e.g., if the central switch in a star topology fails, the whole network is offline).

IP and MAC addresses operate at different levels of network communication:
- IP Address (Logical, Layer 3): Used for routing packets across networks globally. It can change depending on where the device connects to the internet.
- MAC Address (Physical, Layer 2): Used to deliver the frame to the specific physical device within the current local network segment. It is permanent and never changes.

Award up to 4 marks.
- 1 mark for stating that IP addresses are logical/dynamic and MAC addresses are physical/static (hardcoded into hardware).
- 1 mark for explaining that the IP address is used to route packets between different networks / across the internet.
- 1 mark for explaining that the MAC address is used to direct data to the specific device on the local network (LAN).
- 1 mark for identifying that IP addresses are assigned by software/routers, whereas MAC addresses are unique and assigned by the manufacturer.

- How it is conducted: Attackers use dictionary tools or scripts that enter combinations of letters, numbers, and symbols continuously at high speed.
- Defensive Measure 1: Lockout threshold. If an account is locked for 30 minutes after 3 failed attempts, it stops rapid automated attempts.
- Defensive Measure 2: CAPTCHA. This forces a user to prove they are human, preventing automated bots from making rapid password requests.
- Defensive Measure 3: Multi-Factor Authentication (MFA). Even if the password is successfully guessed, access is denied without the second physical token/code.

Award up to 4 marks.
- 1 mark for describing a brute-force attack (automated/systematic trial-and-error guessing of credentials).
- 1 mark for identifying a valid defensive measure (e.g., account lockout, CAPTCHA, MFA, strong password complexity rule).
- 1 mark for explaining how that first measure mitigates the attack (e.g., lockout prevents continuous automated guesses; CAPTCHA stops scripts from interacting with the page).
- 1 mark for identifying and explaining a second valid defensive measure.

Virtual memory process:
1. The OS identifies pages of data in RAM that have not been used recently.
2. It writes these pages to a dedicated file on the hard drive or SSD (swap file/virtual memory).
3. It frees up that physical RAM for the active process.
4. When the swapped-out page is needed again, it must be loaded back into RAM, swapping out something else.

Disadvantage:
- High read/write latency of secondary storage compared to RAM leads to disk thrashing, reducing overall computer performance.

Award up to 4 marks.
- 1 mark for explaining that the OS sets aside space on secondary storage (HDD/SSD) to act as temporary memory extension when RAM is full.
- 1 mark for explaining that inactive pages/blocks of data are moved (swapped) from RAM to secondary storage.
- 1 mark for explaining that these pages are swapped back into physical RAM when they are required by the CPU.
- 1 mark for explaining a valid disadvantage (e.g., secondary storage has slower read/write speeds than RAM, causing system lag/disk thrashing if heavily used).

To achieve Level 3 (7-8 marks), the candidate must present a well-structured, balanced, and detailed discussion covering all four aspects (ethical, legal, cultural, and environmental). The response should use appropriate technical terminology (e.g., Data Protection Act, carbon emissions, automation, liability) and show a clear understanding of the broader impacts of automated systems.

**Example response points:**
- **Ethical issues**: Removing human delivery drivers will lead to significant job losses, which can negatively affect families and local economies. Additionally, there are major safety concerns if a drone experiences hardware or battery failure over crowded residential streets.
- **Legal issues**: Drones rely on cameras and sensors to navigate, meaning they will inevitably capture images of people and private properties. This poses serious privacy concerns under the Data Protection Act (2018). Furthermore, companies must comply with strict aviation laws regarding commercial flight paths and restricted airspace.
- **Cultural issues**: For many vulnerable or lonely individuals, the delivery driver is their only regular human contact; replacing them with drones increases social isolation. Public perception must also be managed, as many people may feel anxious about drones constantly flying overhead.
- **Environmental issues**: On the positive side, drones run on electric batteries, reducing the carbon footprint compared to diesel delivery vans. However, the mass manufacturing of lithium-ion batteries has a harsh environmental impact, and noise pollution from drone propellers could disturb local ecosystems and urban peace.

**Level 3 (7-8 marks):**
- Consistently detailed and balanced discussion covering ethical, legal, cultural, and environmental aspects.
- Excellent understanding of the transition to autonomous drone delivery.
- The answer is logical, well-structured, and consistently uses appropriate specialist terminology (e.g., Data Protection Act, carbon footprint, redundancy, automation).
- Subject-specific terminology is used correctly throughout.

**Level 2 (4-6 marks):**
- Clear discussion covering at least two or three of the aspects (ethical, legal, cultural, environmental) with some detail.
- Shows a reasonable understanding of the impacts of drone deliveries.
- The answer has a structured approach, and some technical terms are used appropriately.
- Errors in spelling, punctuation, and grammar do not obscure meaning.

**Level 1 (1-3 marks):**
- A basic response that covers only one or two aspects in a limited or superficial way.
- Demonstrates a limited understanding of the impacts, with little or no technical detail.
- The structure of the answer may be weak, with little or no specialist terminology used.

**0 marks:**
- No response worthy of credit.

We trace the while-loop step-by-step:
- Initially, x = 3, y = 12. Since 3 < 12 is True, we enter the loop.
- Iteration 1: x becomes 3 + 2 = 5, y becomes 12 - 1 = 11.
- Loop check: 5 < 11 is True, we enter the loop.
- Iteration 2: x becomes 5 + 2 = 7, y becomes 11 - 1 = 10.
- Loop check: 7 < 10 is True, we enter the loop.
- Iteration 3: x becomes 7 + 2 = 9, y becomes 10 - 1 = 9.
- Loop check: 9 < 9 is False. The loop terminates.
- The algorithm prints the value of x, which is 9.

1 mark: Correctly trace the loop conditions and determine that the loop repeats exactly 3 times.
1 mark: State the correct final value of x (9).

1. 23 DIV 5 calculates how many times 5 fits fully into 23, which is 4 (since 5 * 4 = 20, with 3 left over).
2. 23 MOD 4 calculates the remainder when 23 is divided by 4, which is 3 (since 4 * 5 = 20, remainder is 3).
3. Adding these two results together: 4 + 3 = 7.

1 mark: Correctly evaluate the components (23 DIV 5 = 4 and 23 MOD 4 = 3).
1 mark: Correct final sum of the values (7).

1. The array indices are 0 to 8. Initial bounds: low = 0, high = 8.
2. Midpoint 1: (0 + 8) DIV 2 = 4. The value at index 4 is 16. Since 16 < 23, the target is in the right half: low = 5, high = 8.
3. Midpoint 2: (5 + 8) DIV 2 = 6. The value at index 6 is 38. Since 38 > 23, the target is in the left half: low = 5, high = 5.
4. Midpoint 3: (5 + 5) DIV 2 = 5. The value at index 5 is 23. This is our target.
Therefore, the values checked are: 16, then 38, then 23.

1 mark: Correctly identify the initial midpoint element (16).
1 mark: Trace the remaining indices accurately to identify the full sequence (16, 38, 23).

1. board[2, 0] accesses the third row (index 2) and the first column (index 0). The value is 70.
2. board[0, 1] accesses the first row (index 0) and the second column (index 1). The value is 20.
3. Adding these values together gives: 70 + 20 = 90.

1 mark: Correct identification of both array elements (board[2,0] = 70 and board[0,1] = 20).
1 mark: Correct calculation of the sum (90).

1. Evaluate the first sub-expression: (A AND B) = (True AND False) = False.
2. Apply NOT: NOT (False) = True.
3. Evaluate the second sub-expression: (B OR C) = (False OR True) = True.
4. Combine with the final AND operator: True AND True = True.

1 mark: Correct evaluation of the constituent clauses (NOT (A AND B) resolves to True, and (B OR C) resolves to True).
1 mark: Correct overall final evaluation of True.

Boundary values check the edges of the valid range (0 and 100). Normal values check typical valid inputs inside the boundaries (e.g. 50). Erroneous values check invalid inputs outside the range (e.g. 101 or -1). In option A, 0 is a Boundary value, 50 is a Normal value, and 101 is an Erroneous value.

1 mark: Clearly define the role of Boundary, Normal, and Erroneous data in this context.
1 mark: Select the option containing exactly one of each class (0, 50, 101).

A validation check that tests the length of a string (such as ensuring it contains at least 6 characters) is a Length check. A check that ensures a string matches a specific format or does not contain forbidden characters (such as space characters) is best implemented as a Format check.

1 mark: Identify the rule for minimum character length as requiring a Length check.
1 mark: Identify the rule against spaces as requiring a Format check.

The function stringToInt(num1) converts the string "24" to the integer 24. This integer is divided by the integer 3 using standard division (/), which outputs a Real (floating-point) number rather than an integer. Therefore, the result is 8.0, and its data type is Real/Float.

1 mark: Correctly identify that standard division (/) results in a Real/Float data type.
1 mark: Correctly state the final numerical value of 8.0.

To represent 'humidity is low' we use \(\text{NOT } H\). This is combined with 'temperature is high' (\(T\)) using an AND gate, yielding \(T \text{ AND } \text{NOT } H\). This expression is combined with 'manual override' (\(M\)) using an OR gate. Thus, the Boolean expression is \(W = (T \text{ AND } \text{NOT } H) \text{ OR } M\).
In drawing the circuit:
1. Input \(H\) passes through a NOT gate.
2. The output of the NOT gate and input \(T\) are connected to an AND gate.
3. The output of the AND gate and input \(M\) are connected to an OR gate, which outputs \(W\).

(a) [1.5 marks total]:
- 0.5 marks for correctly applying NOT to H: \(\text{NOT } H\).
- 0.5 marks for combining T and the negated H with an AND gate: \(T \text{ AND } \text{NOT } H\).
- 0.5 marks for completing the OR relation with M and equating to W: \(W = ... \text{ OR } M\).

(b) [2 marks total]:
- 1 mark for stating that \(H\) goes through a NOT gate and is then input to an AND gate with \(T\).
- 1 mark for stating that the final gate is an OR gate with inputs from the AND gate and \(M\).

In OCR Exam Reference Language, input from the console is treated as a string type. To add it mathematically, it must be cast to an integer or real using `strToInt()`. To selectively add only positive numbers, an nested `if` statement is used inside the loop to check if `num > 0` before adding to the running total.

(a) [1.5 marks total]:
- 1 mark for identifying that the input must be converted/cast to an integer or real.
- 0.5 marks for correct syntax, e.g., `num = strToInt(...)` or `cast(...)`.

(b) [2 marks total]:
- 1 mark for correct `if` condition checking `num > 0` (or greater than or equal to 0, though positive strictly means > 0).
- 1 mark for enclosing the addition statement inside the `if` and concluding with `endif`.

The algorithm first takes input from the user and casts it to an integer. It then uses structured branching (`if`, `elseif`, `else`, `endif`) to assign the correct discount based on the age range. Finally, it outputs the discount with a clear message.

- 1 mark: Prompting and inputting the age, casting it to an integer.
- 1 mark: Correct conditions for the boundaries (checking age >= 65 and age < 16).
- 1 mark: Use of a nested/alternative selection structure (`if ... elseif ... else ... endif`).
- 0.5 marks: Correct output statement displaying the determined discount.

(a) The `SELECT` clause retrieves the required columns (`FirstName` and `LastName`). The `FROM` clause specifies the database table (`Students`). The `WHERE` clause applies the filters with the logical operator `AND` to select students in year group 11 with attendance less than 90.
(b) A primary key must uniquely identify every record. Since students can share names or other attributes, a unique identifier like `StudentID` is essential.

(a) [2 marks total]:
- 1 mark for correct `SELECT` and `FROM` clauses: `SELECT FirstName, LastName FROM Students`.
- 1 mark for correct `WHERE` clause with logical `AND`: `WHERE YearGroup = 11 AND Attendance < 90`.

(b) [1.5 marks total]:
- 0.5 marks for stating that `StudentID` is unique / `LastName` is not unique.
- 1 mark for explaining that duplicate last names would cause ambiguity/violate primary key rules as a primary key must uniquely identify each record.

Boundary test cases check the extreme limits of the valid ranges (on or immediately adjacent to the boundaries). For `score >= 80`, the boundary values are 79 and 80. For `score >= 50`, the boundaries are 49 and 50.
Iterative testing finds bugs early in development, whereas final testing ensures the fully integrated system meets all overall requirements.

(a) [2 marks total]:
- 1 mark for identifying a correct boundary score (e.g., 50, 80, 49, 79).
- 1 mark for stating the correct corresponding expected output.

(b) [1.5 marks total]:
- 1 mark for describing iterative testing as ongoing during development of code parts.
- 0.5 marks for describing final testing as occurring at the end/on the complete product before rollout.

The algorithm uses a defensive design pattern. It uses a `while` loop that keeps prompting the user as long as the inputs fail validation. The input is converted to an integer and checked against the inclusive range bounds (13 and 120) using logical `AND`. If it passes, the loop terminates and a confirmation is printed.

- 1 mark: Initializing a loop variable or using a correct conditional loop structure (e.g. `while age < 13 OR age > 120` or equivalent).
- 1 mark: Taking and casting input to integer inside the loop.
- 1 mark: Correct logical conditions using logical operator `AND` / `OR` to restrict the age to the 13-120 range inclusive.
- 0.5 marks: Printing a confirmation message outside the loop once valid input is entered.

# OCR Exam Reference Language / Pseudocode
totalFine = 0.0
for i = 0 to overdueBooks.length - 1
days = overdueBooks[i][1]
if days > 7 then
fine = days * 0.50
else
fine = days * 0.20
endif
totalFine = totalFine + fine
next i
print("Total fine: " + totalFine)

Award up to 5.5 marks as follows:
- 1 mark: Initialising a total fine variable (e.g., totalFine = 0) before the loop.
- 1 mark: Correctly looping through each element of the overdueBooks array (e.g. from index 0 to length-1).
- 1 mark: Accessing the number of days overdue correctly using index [i][1] or equivalent.
- 1 mark: Using an if-else structure to check if days are greater than 7.
- 1 mark: Correctly calculating the fines (\(0.50 \times \text{days}\) for > 7, and \(0.20 \times \text{days}\) for \(\le 7\)) and adding them to the total.
- 0.5 marks: Printing/outputting the final total fine outside the loop with an appropriate label.

# OCR Exam Reference Language / Pseudocode
username = input("Enter username: ")
length = username.length
hasSpace = false

# Check for spaces
for i = 0 to length - 1
if username[i] == " " then
hasSpace = true
endif
next i

if length >= 6 and length <= 12 and hasSpace == false then
print("VALID")
else
print("INVALID")
endif

Award up to 5.5 marks as follows:
- 1 mark: Obtaining user input or taking username as an input/parameter.
- 1 mark: Correctly checking that the length of username is between 6 and 12 inclusive.
- 1.5 marks: Checking for space characters (1 mark for loop/search through string, 0.5 marks for flagging if " " is detected).
- 1 mark: Using logical operators (AND/NOT) to combine all validation rules correctly.
- 1 mark: Outputting "VALID" if all criteria are satisfied, and "INVALID" otherwise.

# OCR Exam Reference Language / Pseudocode
total = 0
count = 0
myFile = open("scores.txt")
while NOT myFile.endOfFile()
line = myFile.readLine()
score = stringToInt(line)
total = total + score
count = count + 1
endwhile
myFile.close()

if count > 0 then
average = total / count
print("Average: " + average)
else
print("No scores")
endif

Award up to 5.5 marks as follows:
- 1 mark: Correctly opening and closing the file "scores.txt".
- 1 mark: Using a correct loop structure (e.g. while NOT endOfFile) to read all lines from the file.
- 1 mark: Reading the value, casting it to an integer, and adding it to a total variable.
- 1 mark: Incrementing a score counter inside the reading loop.
- 1 mark: Using a conditional check to ensure count > 0 before performing the division calculation.
- 0.5 marks: Printing the calculated average when count > 0, and "No scores" otherwise.

# OCR Exam Reference Language / Pseudocode
found = false
index = -1
for i = 0 to numbers.length - 1
if numbers[i] == target then
found = true
index = i
# Optional: exit loop early
endif
next i

if found == true then
print("Found at index " + index)
else
print("Not found")
endif

Award up to 5.5 marks as follows:
- 1 mark: Using a loop (for or while) to iterate through the array elements.
- 1 mark: Indexing the array correctly (e.g., numbers[i]) within the loop.
- 1.5 marks: Conditional statement comparing the current array element to target (e.g., if numbers[i] == target).
- 1 mark: Setting a flag (found = true) or updating index variables to record search success.
- 1 mark: Correctly outputting the index if found, and "Not found" if the search completes with no match.

# OCR Exam Reference Language / Pseudocode
print("Please enter your age: ")
age = stringToInt(input())

while age < 11 or age > 18
print("Error: Age must be between 11 and 18.")
print("Please enter your age again: ")
age = stringToInt(input())
endwhile

print("Age accepted")

Award up to 5.5 marks as follows:
- 1 mark: Prompting the user and taking input for age (converting it to an integer).
- 1.5 marks: Creating a while loop with a correct range checking condition (e.g., age < 11 OR age > 18).
- 1 mark: Outputting an error message within the loop body.
- 1 mark: Prompting the user again and updating the age variable inside the loop (to prevent infinite looping).
- 1 mark: Printing "Age accepted" outside/after the loop terminates.

# OCR Exam Reference Language / Pseudocode
maxTemp = temps[0]
minTemp = temps[0]

for i = 1 to temps.length - 1
if temps[i] > maxTemp then
maxTemp = temps[i]
endif
if temps[i] < minTemp then
minTemp = temps[i]
endif
next i

print("Maximum temperature: " + maxTemp)
print("Minimum temperature: " + minTemp)

Award up to 5.5 marks as follows:
- 1 mark: Initialising both maxTemp and minTemp to the first item in the array (temps[0]) or appropriate extreme boundaries.
- 1 mark: Creating a loop that iterates through the remaining indices of the array (e.g., from index 1 to length-1).
- 1 mark: Correct conditional comparison and assignment for finding the maximum temperature.
- 1 mark: Correct conditional comparison and assignment for finding the minimum temperature.
- 1.5 marks: Outputting both maximum and minimum temperatures with labels (0.75 marks per distinct output).