2025 OCR GCSE Computer Science - J277 Practice Paper with Answers

Split the 8 bits into two nibbles: 1011 and 0101. 1011 = 8 + 2 + 1 = 11 = B. 0101 = 4 + 1 = 5. So the hexadecimal value is B5.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| (a) | Splits into nibbles 1011 and 0101 // shows 11 and 5 as denary values (1) | 1 | Accept correct working via denary (181) only if converted correctly to hex. |
| | B5 (1) | 1 | Allow b5. Do not accept 11 5 or 115. Award both marks for B5 with no working. |

(a) Moving every bit two places left and filling the right with zeros gives 00110100. (b) 00001101 is 13 and 00110100 is 52, so the value has been multiplied by 4 (each place left multiplies by 2).

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| (a) | 00110100 (1) | 1 | Must be 8 bits. Do not accept 110100 . |
| (b) | Multiplied by 4 (1) | 1 | Accept multiplied by 2 twice // doubled twice. Do not accept 'multiplied by 2' alone or 'increases'. |

File size in bits = sample rate x duration x bit depth = 8000 x 30 x 16 = 3 840 000 bits. Divide by 8 to convert to bytes: 3 840 000 / 8 = 480 000 bytes (480 KB).

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| (a) | 8000 x 30 x 16 = 3 840 000 (bits) (1) | 1 | Method mark. |
| | 3 840 000 / 8 = 480 000 bytes (1) | 1 | Accept 480 KB // 480 000 B. Allow follow-through from one arithmetic slip in the first step for the division mark only. Award both marks for 480 000 with no working. |

(a) File size in bits = sample rate x duration x bit depth = 8000 x 15 x 16 = 120 000 x 16 = 1 920 000 bits.
Convert to bytes: 1 920 000 / 8 = 240 000 bytes.
Convert to kilobytes: 240 000 / 1000 = 240 KB.
(b) Halving the bit depth halves each sample's storage, so the file becomes 120 KB (half the size), but each sample is recorded less precisely so the quality is lower.

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| (a) | Multiplies 8000 x 15 x 16 // correct calculation of 1 920 000 (bits) | 1 | Allow 1 mark for correct method with an arithmetic slip. |
| (a) | Divides by 8 to convert bits to bytes (240 000 bytes) | 1 | Follow through from the candidate's bit value. |
| (a) | Divides by 1000 to give 240 KB | 1 | Accept 234.375 KB if 1024 is used consistently. Answer only: 240 KB gets 3 marks; do not accept an answer with no units. |
| (b) | File size is smaller/halved AND quality is lower/less accurate | 1 | Both points are required for the mark. Do not accept 'quality is worse' alone without the size effect. Ignore any reference to sample rate. |

Total: 4 marks

Row A: 52 = 32 + 16 + 4, so binary 00110100. Split into nibbles 0011 and 0100 = 3 and 4, so hex 34.
Row B: 10011110 = 128 + 16 + 8 + 4 + 2 = 158. Nibbles 1001 = 9 and 1110 = E, so hex 9E.
Row C: C = 12 and 5, so denary = 12 x 16 + 5 = 197. Nibbles C = 1100 and 5 = 0101, so binary 11000101.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| Row A, binary | 00110100 | 1 | Accept 110100 (leading zeros may be omitted). |
| Row A, hexadecimal | 34 | 1 | Accept follow-through from an incorrect binary answer in Row A only if the conversion from that binary is correct. |
| Row B, denary | 158 | 1 | |
| Row B, hexadecimal | 9E | 1 | Accept 9e. |
| Row C, denary | 197 | 1 | |
| Row C, binary | 11000101 | 1 | |
| Total | | 6 | One mark per correct completed box. Ignore working. Do not accept answers placed in the wrong box. |

File size in bits = sample rate x duration x bit depth = 8,000 x 40 x 16 = 320,000 x 16 = 5,120,000 bits.
Convert to bytes: 5,120,000 / 8 = 640,000 bytes.
Convert to kilobytes: 640,000 / 1,000 = 640 KB (or 625 KB if 1,024 is used).

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 1 | Multiplies sample rate x duration x bit depth // 8,000 x 40 x 16 // to get 5,120,000 (bits) | 1 | Allow 320,000 as an intermediate value if later multiplied by 16. |
| | Divides bits by 8 to get bytes // 640,000 (bytes) | 1 | Follow through from an incorrect bit total. |
| | Divides bytes by 1,000 to give 640 (KB) | 1 | Accept 625 (KB) if bytes are divided by 1,024 // accept 625 or 640 with correct working. Do not accept the answer without units unless working is clearly in KB. Correct answer with no working: max 1 mark... award 3 only if working is shown. |

The URL is sent to a domain name server. The DNS looks up the domain name in its records and returns the matching IP address (asking another domain name server if it does not hold the record). The browser then uses the IP address to send a request to the web server that hosts the site, which returns the page.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 2 | The URL / domain name is sent to a (domain name) server // DNS server | 1 | Do not accept the browser 'knowing' the address without a lookup. |
| | The DNS finds / looks up the matching IP address // converts the URL / domain name into an IP address | 1 | Accept the request is passed to another DNS server if the record is not held. |
| | The IP address is returned and used to contact / request the page from the web server | 1 | Allow 'the browser connects to the website'. Ignore references to MAC addresses. max 3 |

(a) Size in bits = sample rate x duration x bit depth = 8 000 x 5 x 16 = 40 000 x 16 = 640 000 bits. Divide by 8 to convert to bytes: 640 000 / 8 = 80 000 bytes (80 KB).
(b) With twice as many samples per second, the file size doubles and the stored sound is closer to the original.

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| (a) | Multiplies 8 000 x 5 x 16 // correct method for bits | 1 | Accept 640 000 for the mark below as evidence of this mark. |
| (a) | 640 000 (bits) | 1 | |
| (a) | Divides by 8 to give 80 000 bytes | 1 | Accept 80 KB // 80 000 B. Accept 78.125 KB if 1 024 is used. Allow follow-through for the division by 8 if the bits value is wrong, provided the method was correct. |
| (b) | File size doubles // better quality / more accurate / closer to the original sound | 1 | Do not accept 'louder' or 'sounds longer'. max 1 |

Advantage 1: If one cable fails, only the computer using that cable loses its connection, so the other nine computers continue to work.
Advantage 2: The switch sends data only to the computer it is addressed to, so there are fewer data collisions and performance is consistent when many computers are in use.
Other valid advantage: a new computer can be added by connecting one cable to the switch without stopping the network.

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| | Award 1 mark for each advantage identified and 1 mark for a linked development, up to 2 advantages. | 4 | max 4 |
| | Failure of one cable / device does not affect the others... so the rest of the network keeps working | 2 | |
| | Data is sent only to the intended device by the switch... so fewer collisions // better / more consistent performance | 2 | |
| | Easy to add / remove devices... without disrupting the network | 2 | |
| | Easy to locate faults... because each device has its own cable to the centre | 2 | |
| | Guidance | | The development mark depends on the advantage being given. Do not accept 'faster' or 'cheaper' alone. Do not accept advantages of mesh topology. Do not accept a disadvantage.

function checkTag(tag)
if tag.length == 5 AND tag.left(1) == "Z" then
return True
else
return False
endif
endfunction

The length is tested with .length, the first character with .left(1) (or .substring(0,1)), and both conditions are joined with AND so both must be true.

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| | Function header with name checkTag and one parameter, and closed correctly (endfunction) | 1 | Allow a high-level language equivalent. |
| | Checks the length is 5 | 1 | tag.length == 5 // len(tag) == 5 in a high-level language. |
| | Checks the first character is "Z" | 1 | Accept .left(1) // .substring(0,1) // tag[0] // equivalent. Do not accept comparing the whole string to "Z". |
| | Both conditions combined correctly (AND) and True returned when both are met and False otherwise | 1 | Accept a single return of the condition itself, e.g. return tag.length == 5 AND tag.left(1) == "Z". Accept nested if statements. Do not accept OR. Minor syntax errors are not penalised. Pseudocode in natural English or bullet points earns no marks. |

Normal: a value inside the range, such as 7.
Boundary: a value at the edge of the valid range, such as 20 (or 1).
Invalid: the correct data type but outside the range, such as 35.
Erroneous: the wrong data type, such as "ten" or 4.5.

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| | Normal: whole number from 2 to 19 | 1 | |
| | Boundary: 1 or 20 | 1 | Allow 0 or 21 as boundary values on the edge of the invalid range. |
| | Invalid: whole number below 0 or above 21 (e.g. 35, -3) | 1 | Do not accept a number already used for another row. Accept 0 or 21 only if not used as the boundary value. |
| | Erroneous: a value that is not a whole number, e.g. "ten", 4.5, a letter | 1 | Accept a symbol or blank entry. |

(a) Number of pixels = 400 × 250 = 100,000. Size in bits = colour depth × height × width = 8 × 100,000 = 800,000 bits. Divide by 8 to get bytes: 100,000 bytes. Divide by 1,000 to get kilobytes: 100 KB.
(b) Each pixel now uses 4 bits instead of 8, so the file size is halved (50 KB). With 4 bits only 16 colours can be represented instead of 256, so colours are less accurate and the image quality is reduced.

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| (a) | Calculates total bits as 400 × 250 × 8 // 800,000 (bits) | 1 | Allow 100,000 pixels × 8 as working. |
| (a) | Converts to 100 KB (100,000 bytes ÷ 1,000) | 1 | Allow 97.65... KB // 97.66 KB if 1,024 is used and working shown. Allow follow-through for the conversion mark from an incorrect bit total only if the bits-to-bytes and bytes-to-KB steps are correct. Answer of 100 with no working scores 2. |
| (b) | File size decreases // is halved // is 50 KB // fewer bits per pixel | 1 | Do not accept 'smaller image' or 'fewer pixels'. |
| (b) | Fewer colours can be represented // lower image quality // less accurate colours | 1 | Accept 16 colours instead of 256. Ignore 'resolution is reduced'. |

Max 4 marks.

(a) The central device in a star network is a switch, which receives data from each computer and forwards it only to the device it is addressed to.

(b) In a star network every device has one cable to the switch. In a mesh network each device is connected to several or all of the others. For eight computers a full mesh needs 28 cables, whereas a star needs 8. So a star is cheaper and quicker to install. A new computer can be added by running a single cable to the switch without altering other connections. If one cable fails, only the device on that cable loses its connection, so the rest of the clinic can carry on working, and the fault is easy to find.

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| 1(a) | Switch | 1 | Accept hub // central switch. Do not accept router, server or WAP. |
| 1(b) | Reason 1 identified: fewer cables are needed (1) // Development: so it is cheaper / quicker / simpler to install (1) | max 4 | Each reason must be a different point. Award the second mark of a pair only if it develops the stated reason (linked points). Max 2 per reason. |
| | Reason 2 identified: a new device can be added easily (1) // Development: only one cable to the central switch is needed and the rest of the network is not affected (1) | | Other valid reasons: a cable failure affects only one device (1) so the other computers keep working (1); easier to locate faults because each device has its own cable (1) because the problem can be traced to one connection (1); less data collision because the switch sends data only to its destination (1) so performance is maintained (1). |
| | | | Do not accept 'cheaper' alone without a reason for it being cheaper in the development mark. Do not accept 'faster' alone. Ignore statements that a star has no single point of failure. Benefit of the doubt: allow 'less wire' for 'fewer cables'. Max 4 for (b). |
| | Total | 5 | |

A good answer weighs both sides in the context of a school canteen.

Ethical: students and parents may not want to give biometric data; a fair alternative (e.g. PIN or card) should be offered so no one is disadvantaged; children may become used to being monitored. Benefits: cards cannot be lost or borrowed, queues are quicker, and students receiving free meals are not identifiable by a different card.

Privacy: a fingerprint cannot be changed if stolen, so a breach has lasting effects. The data is personal and sensitive, so it should be stored securely (encryption, access levels, firewall) and only used for payment.

Legal: under the Data Protection Act 2018 the school must have a lawful reason and permission, keep the data secure and accurate, collect only what is needed, delete it when a student leaves, and let people see the data held about them. If a hacker accessed the server, they would break the Computer Misuse Act 1990.

Conclusion: the system can be justified if consent, an opt-out, strong security and deletion rules are in place.

Question 6* | Marks: 8 | Marked holistically using three bands. Indicative content is illustrative, not exhaustive.

Band 3 (6-8 marks): Detailed, accurate discussion covering at least two of ethical, legal and privacy issues, with both advantages and disadvantages. Points are clearly applied to the school/canteen scenario and linked with reasoning (e.g. fingerprint cannot be changed, so a breach is serious, so encryption and deletion are needed). A balanced, coherent conclusion or judgement is reached. Technical terms are used correctly. Top of band for all three areas with a developed judgement.

Band 2 (3-5 marks): Some accurate discussion of at least two issues, with some application to the scenario. Reasoning may be partial, one-sided or limited in development. Some use of terminology. A conclusion may be missing or weak.

Band 1 (1-2 marks): Basic, mostly generic statements about one or two issues (e.g. 'it is an invasion of privacy', 'the data could be hacked') with little or no application or reasoning.

Band 0 (0 marks): No creditable response.

Indicative content:
- Ethical: consent from students/parents; alternative for those who object; fairness; surveillance of children; avoids stigma for free-meal students; no cards to lose or share.
- Privacy: biometric data is personal/sensitive; cannot be changed if stolen; who can access it; how long it is stored; risk of data theft or interception over the network; security measures such as encryption, firewall, user access levels, physical security of the server.
- Legal: Data Protection Act 2018 - data used lawfully and fairly, only for stated purpose, adequate and not excessive, accurate, not kept longer than necessary, kept secure, not shared without permission, individuals can see their data; Computer Misuse Act 1990 - unauthorised access to the server is illegal.

Guidance:
Accept: any valid, relevant point worded differently.
Allow: reference to Data Protection principles without naming the exact wording.
Do not accept: Acts named but with incorrect purpose (e.g. Copyright, Designs and Patents Act 1988 applied to fingerprints).
Ignore: discussion of how the fingerprint scanner hardware works.
Max 5 marks if only one of ethical/legal/privacy is covered, or if no scenario application is shown.

Split the 8 bits into two nibbles: 1011 and 0100. 1011 = 8 + 2 + 1 = 11 = B. 0100 = 4. So the hexadecimal value is B4.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 1 | B (B4) | 1 | Do not award the mark if more than one box is ticked. Accept the answer written as B4 instead of a tick. |

SMTP (Simple Mail Transfer Protocol) is used to send email to a server. POP retrieves email, FTP transfers files and HTTPS is used for secure web pages.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 2 | B (SMTP) | 1 | Do not award the mark if more than one box is ticked. Accept the answer written as SMTP instead of a tick. |

A is true: more samples per second means more data. B is false: lower colour depth means fewer bits per pixel, so a smaller file. C is true: \(2^8 = 256\). D is true: width and height are stored as metadata. E is false: lossy compression permanently removes data. F is false: doubling the pixels doubles the file size. G is true: Unicode uses more bits per character, so has a larger character set. H is false: a nibble is 4 bits. The four true statements are A, C, D and G.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 1 | A ticked | 1 | |
| | C ticked | 1 | |
| | D ticked | 1 | |
| | G ticked | 1 | Max 4. If more than four boxes are ticked, remove one mark for each tick beyond four (minimum 0 marks). Accept any clear unambiguous indication of selection, e.g. a cross, if the candidate's intention is clear. Ignore a box that is ticked and then clearly crossed out.

(a) 00101100 = 32 + 8 + 4 = 44.
(b) Split into nibbles: 1011 = B, 1001 = 9, giving B9.
(c) J is 4 letters after F (G, H, I, J), so the code is 70 + 4 = 74, because character codes are in logical order.
(d) File size = sample rate x duration x bit depth, so a higher sample rate makes the file larger. A higher bit depth gives more possible values per sample, so each sample is more precise. The other statements are false: lower bit depth reduces size, doubling duration doubles size, and sample rate is samples per second (Hz), not bits per sample.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 1(a) | 44 | 1 | Only one box ticked. |
| 1(b) | B9 | 1 | Only one box ticked. |
| 1(c) | 74 | 1 | Only one box ticked. |
| 1(d) | Increasing the sample rate increases the file size // A higher bit depth lets each sample be stored more precisely | 2 | 1 mark for each correct box ticked. max 2 marks: if more than two boxes are ticked, award 1 mark for each correct tick minus 1 for each incorrect tick, to a minimum of 0. |
| | Total | 5 | |

Place values: 128 64 32 16 8 4 2 1. Bits set: 32 + 8 + 4 + 1 = 45.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 1 | 45 | 1 | Do not accept 0101101 or any answer with a base subscript that contradicts denary. Ignore a base subscript such as 45(10). |

In a star network each device connects only to a central switch, so far fewer cables are needed than in a mesh where devices are connected to several others. It is also easier to add a new device.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 2 | Any one from: cheaper (to install) // less cabling needed; easier to add a new device / to set up; easier to manage / to find a fault; a failed cable only affects one device | 1 | Allow simpler to install. Do not accept 'faster' or 'more secure' without justification. Do not accept 'cheap' with no comparison. max 1 |

Boundary data lies at the edge of the valid range. The edges are 11 and 18; values immediately outside (10 and 19) are also accepted as boundary tests.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 3 | Any one from: 11; 18; 10; 19 | 1 | Do not accept values such as 15 (normal data) or 'twelve' / 'abc' (erroneous data). max 1 |

The loop runs for i = 1, 2, 3, 4 (inclusive). total becomes 1, 3, 6, 10. Then 10 is printed.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 4 | 10 | 1 | Do not accept 1, 3, 6 or a list of values. |

Place values: 128 64 32 16 8 4 2 1. Bits set: 64 + 32 + 8 + 1 = 105.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 1 | Identifies the correct place values / bits set (64, 32, 8, 1) (1) ; Answer 105 (1) | 2 | Allow 1 mark for correct working with an arithmetic slip. Answer 105 with no working gets 2. |

A star needs only one cable per device to the switch, whereas a mesh needs many links between devices. Devices can be added without disturbing others, and one failed cable only disconnects one device.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 2 | Cheaper / less cabling / fewer connections needed (1) ; Easy to add or remove a device without disrupting the network (1) ; A cable failure affects only one device (1) ; Easier to set up / manage / locate faults (1) | max 2 | Do not accept 'faster' or 'more secure' without a reason. Ignore 'reliable' on its own. |

i=1: total=2; i=2: total=6; i=3: total=12; i=4: total=20. Output 20.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 3 | Evidence of loop running 4 times adding 2, 4, 6, 8 / correct running totals (1) ; 20 (1) | 2 | Output mark can be awarded for 20 without working. Allow 1 mark for 20 - 2*? slips only if working shows correct method; allow follow-through of the final total from a single arithmetic slip in working. |

Boundary data is at the edge of the valid range, e.g. 7 or 11, and is accepted. Invalid data is of the correct type but outside the range, e.g. 12, and is rejected.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 4 | Boundary: 7 / 11 with outcome accepted (1) ; Invalid: a whole number below 7 or above 11 (e.g. 3, 12) with outcome rejected / error message (1) | 2 | Each mark needs the data and the matching outcome. Allow 6 or 12 as the boundary only if described as just outside and rejected. Do not accept text such as 'abc' for invalid (this is erroneous). |

(a) 00001101: 8 + 4 + 1 = 13.
(b) Shifting left by two places moves every bit two places left and fills the right with zeros: 00001101 becomes 00110100 (which is 52, i.e. 13 x 4).

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| (a) | 13 | 1 | Accept 13 only as the final denary value. |
| (b) | 00110100 | 1 | Accept 110100 (leading zeros optional). Do not accept answers with the wrong number of shifted places. Allow follow-through only if the candidate's own part (a) is irrelevant: the shift is marked from the printed binary number. |
| Total | | 2 | |

Initialise total and heavy to 0. Use a count-controlled loop for the ten parcels. Inside it, use a DO UNTIL loop to input the weight until it is between 0.1 and 30 inclusive. Add each accepted weight to total. If the weight is greater than 20, add 1 to heavy. After the loop, output total and heavy.

Example answer (OCR Exam Reference Language):

total = 0
heavy = 0
for i = 1 to 10
do
weight = real(input("Enter weight in kg"))
until weight >= 0.1 AND weight <= 30
total = total + weight
if weight > 20 then
heavy = heavy + 1
endif
next i
print("Total weight: " + str(total))
print("Heavy parcels: " + str(heavy))

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| Construction | 1. Count-controlled loop (or equivalent) that repeats the weight entry ten times. | 1 | Allow a WHILE loop with a counter that is initialised and incremented. Do not accept a loop that runs 9 or 11 times. |
| | 2. Input of a weight inside the loop, stored in a variable. | 1 | Allow casting or no casting. |
| | 3. Validation loop that repeats the input while the weight is invalid. | 1 | Allow a WHILE loop with an initial input before it, or a DO UNTIL loop. Must re-ask for the weight rather than skip it. |
| | 4. Correct condition: rejects below 0.1 and above 30, and accepts 0.1 and 30. | 1 | Allow equivalent forms, for example weight < 0.1 OR weight > 30. Do not accept AND in the reject condition. Do not accept a condition that rejects 0.1 or 30. |
| | 5. Total initialised to 0 before the loop and each accepted weight added to it. | 1 | Both parts are needed. The weight must be added once per accepted parcel, not for rejected inputs. |
| | 6. Heavy-parcel counter initialised to 0, incremented when weight > 20, and both total and count output after the loop. | 1 | Condition must be strictly greater than 20. Outputs must be outside the loop. Allow output of the values without text. Allow only one output if the other has been awarded elsewhere. Do not award if the counter is not initialised. |

Max 6 marks. Allow appropriate equivalent syntax in a high-level language, pseudocode or a flowchart, provided the logic is clear. Minor syntax errors are not penalised. Ignore the names chosen for variables.

Start: 7 3 9 2 5.
Pass 1: swap 7,3 -> 3 7 9 2 5; 7,9 no swap; swap 9,2 -> 3 7 2 9 5; swap 9,5 -> 3 7 2 5 9.
Pass 2: 3,7 no swap; swap 7,2 -> 3 2 7 5 9; swap 7,5 -> 3 2 5 7 9; 7,9 no swap.
Pass 3: swap 3,2 -> 2 3 5 7 9; no other swaps. The list is now sorted, but a swap was made in this pass so the algorithm cannot yet stop.
Pass 4: no swaps are made, so the algorithm stops. Total passes = 4.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| (a) | Pass 1 row: 3, 7, 2, 5, 9 | 1 | All five values must be correct and in the correct positions. |
| (a) | Pass 2 row: 3, 2, 5, 7, 9 | 1 | Allow follow-through from an incorrect Pass 1 row only if the pass has been applied correctly to that row. |
| (a) | Pass 3 row: 2, 3, 5, 7, 9 | 1 | Allow follow-through from an incorrect Pass 2 row only if the pass has been applied correctly to that row. |
| (b) | 4 (passes) | 1 | Do not accept 3. Allow follow-through only if the candidate's Pass 3 row is still unsorted (answer 1 more than the number of passes needed to reach a sorted list in their working). |

Total: 4 marks

Start with score = 0.
i = 1: odd, so score = 0 - 1 = -1 (given).
i = 2: even, so score = -1 + 2 = 1.
i = 3: odd, so score = 1 - 1 = 0.
i = 4: even, so score = 0 + 4 = 4.
i = 5: odd, so score = 4 - 1 = 3.
The loop ends and print(score) outputs 3.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 1 | Trace table rows i=2 to i=5 show score as 1, 0, 4, 3 | 1 | Award 1 mark for at least three of the four values correct (1, 0, 4, 3). Allow follow-through of a wrong value into later rows if the rule is applied correctly. |
| 1 | Printed value is 3 | 1 | Award only if the last row of the table is 3, or if the printed value follows through from the candidate's last row. Do not accept more than one printed value. Ignore a table that is incomplete if the final output is 3. |

Total: 2 marks. Max 1 if the table is fully correct but no printed value is given, or the printed value is given with an incorrect table that does not follow through.

The loop must run once for each of the 7 days, so the upper bound is 7 (the bounds of a FOR loop are inclusive, and it starts at 1). A day is wet only if the rainfall is MORE than 10 mm, so the comparison operator is >. Each wet day adds 1 to the counter, so wetDays is assigned wetDays + 1.

A: 7
B: >
C: wetDays + 1

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| A | 7 | 1 | Do not accept 6 or 8. |
| B | > | 1 | Do not accept >=. Do not accept the word 'greater than' written without the symbol. |
| C | wetDays + 1 | 1 | Accept 1 + wetDays. Allow wetDays = wetDays + 1 if the whole statement is rewritten. Do not accept wetDays + i. |

Total: 3 marks. Each gap is marked independently. Ignore minor differences in spacing.

(a) The array has 7 elements, so the loop must run for day = 0 to 6 (A = 6). A value is invalid if it is below 0 OR above 500; AND could never be true for both at once (B = OR). The running total adds the new count to the existing total (C = total).

(b) A counter is needed. Initialise it before the loop and add 1 whenever count is greater than 300, inside the loop. Output it after the loop has finished.

Example:
After line 03: busyDays = 0
After line 13 (inside the loop, before next day):
if count > 300 then
busyDays = busyDays + 1
endif
After line 16: print(busyDays)

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 1(a) | A = 6 | 1 | Accept 7 - 1. Do not accept 7. |
| 1(a) | B = OR | 1 | Accept || if a high-level language is used. Do not accept AND. |
| 1(a) | C = total | 1 | Do not accept count or highest. |
| 1(b) | Counter initialised to 0 before the loop AND output after the loop (after line 14 / 15 / 16, outside the loop) | 1 | Both parts are needed for the mark. Accept any valid identifier. Accept the output placed before or after existing print statements provided it is outside the loop. |
| 1(b) | Selection with condition count > 300 inside the loop AND counter incremented by 1 inside that selection | 1 | Placed within lines 05-13 after count has been validated. Accept visitors[day] > 300 as the condition. Accept busyDays += 1 or equivalent. Do not accept >= 300. |

Total: 5 marks. Benefit of doubt: minor syntax slips (for example a missing endif) are ignored in 1(b) provided the structure is clear. Follow-through: if the counter variable is named differently in the initialisation and the output, award the mark for the part that is consistent.

(a) File size in bits = sample rate x duration x bit depth = 8 000 x 10 x 16 = 1 280 000 bits.
Divide by 8 to convert to bytes: 1 280 000 / 8 = 160 000 bytes.
(b) Halving the sample rate halves the number of samples stored, so the file size is halved (80 000 bytes). Fewer samples means the digital wave is a less accurate copy of the original analogue sound, so quality is reduced.

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| 1(a) | Multiplies 8 000 x 10 x 16 (to get 1 280 000 bits) | 1 | Allow correct method shown even if arithmetic is wrong. |
| 1(a) | Divides by 8 to give 160 000 bytes | 1 | Accept 160 KB // 156.25 KB (if 1 024 used). Correct answer with no working: 2 marks. Follow-through allowed from an arithmetic slip in the first mark for the division mark only. |
| 1(b) | File size is halved // smaller | 1 | Do not accept 'smaller' with no indication of why if contradicted. Accept 80 000 bytes. |
| 1(b) | Quality is lower // less accurate representation of the original sound because fewer samples per second | 1 | Allow 'less detail'/'less clear'. Ignore 'distorted' alone. |

The code is input once, then a condition-controlled WHILE loop checks the length. While invalid, an error message is output and the code is requested again. When the loop ends the code must be valid, so "Code accepted" is output.

code = input("Enter locker code")
while code.length != 4
print("Code must be 4 characters")
code = input("Enter locker code")
endwhile
print("Code accepted")

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| 2 | Input of the code stored in a variable (before and within the loop) | 1 | Allow input prompt omitted. |
| 2 | Suitable condition-controlled loop (while/do until) | 1 | Condition must be correct for the chosen loop type, e.g. DO UNTIL with length == 4. |
| 2 | Correct length check of exactly 4 characters (length != 4 // == 4) | 1 | Do not accept < 4 or > 4 alone. Accept len(code) in Python. |
| 2 | Error message output inside the loop AND "Code accepted" output after the loop, with the code re-requested inside the loop | 1 | Both outputs needed with re-input inside the loop. Minor syntax errors not penalised. Natural English, bullet points or pseudocode: 0 marks. |

The NOT gate inverts R. S = D AND (NOT R).
Row 1: D=0, NOT R=1, so S=0.
Row 2: D=0, NOT R=0, so S=0.
Row 3: D=1, NOT R=1, so S=1.
Row 4: D=1, NOT R=0, so S=0.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 1 | S column: 0, 0, 1, 0 (top to bottom) | 2 | All four values correct = 2 marks. Any three correct = 1 mark. Two or fewer correct = 0 marks. Accept T/F or True/False for 1/0. Do not accept ticks or crosses or other symbols. |

The circuit gives P = T AND (NOT W) and S = P OR M.

P is 1 only when T = 1 and W = 0, which is rows 5 and 6.

S is 1 when P = 1 or M = 1.

| T | W | M | P | S |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 0 | 1 | 0 | 1 |
| 0 | 1 | 0 | 0 | 0 |
| 0 | 1 | 1 | 0 | 1 |
| 1 | 0 | 0 | 1 | 1 |
| 1 | 0 | 1 | 1 | 1 |
| 1 | 1 | 0 | 0 | 0 |
| 1 | 1 | 1 | 0 | 1 |

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 1 | P column correct for all eight rows (0,0,0,0,1,1,0,0) | 1 | All eight must be correct. |
| 1 | S column: 2 marks for all eight rows correct (0,1,0,1,1,1,0,1); 1 mark for six or seven rows correct | 2 | Follow-through: S may be marked from the candidate's own P column, as S = P OR M. Accept T/F for 1/0. Do not accept blank cells as correct. |

T1 is a file transfer, so FTP. T2 needs a secure web connection, so HTTPS. T3 is sending email to a server, so SMTP. POP and IMAP are used to retrieve email, not to send it.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 1 | T1 matched to FTP | 1 | Only one line from each task. |
| 1 | T2 matched to HTTPS | 1 | |
| 1 | T3 matched to SMTP | 1 | |

Guidance: If a task has more than one line drawn, do not award the mark for that task. Max 3 marks.

Sound file size = sample rate × duration × bit depth, so a higher sample rate gives a larger file (A is true). Sample rate is measured in Hertz, not bits (B false). Bit depth is the number of bits per sample (C true). Doubling the duration doubles the file size (D false). More bits per sample gives more possible values, so each sample is stored more accurately (E true). Analogue sound must be sampled and converted to binary before storage (F false). The three true statements are A, C and E.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 1 | A - increasing the sample rate increases the file size | 1 | One mark for each correct box ticked (AO1). |
| 1 | C - bit depth is the number of bits used to store each sample | 1 | |
| 1 | E - a higher bit depth allows each sample to be stored more accurately | 1 | |

Guidance: Maximum 3 marks. If more than three boxes are ticked, award one mark for each correct tick but deduct one mark for each incorrect tick beyond three (the total cannot be below 0). Do not award a mark for B, D or F.

A: 0010 = 2 and 1101 = D, so 2D. True.
B: FF = 15 x 16 + 15 = 255, not 256. False.
C: Shifting right halves the value. False.
D: 128 + 64 + 8 = 200, which is 11001000. True.
E: 10000000 = 128, not 64. False.
F: 192 + 64 = 256, which needs 9 bits, so the result does not fit in 8 bits: overflow. True.
G: Unicode uses more bits per character than 8-bit ASCII so it can represent more characters. False.
H: Each left shift multiplies by 2, so two shifts multiply by 4. True.

Correct statements: A, D, F, H.

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| 1 | A ticked | 1 | |
| 1 | D ticked | 1 | |
| 1 | F ticked | 1 | |
| 1 | H ticked | 1 | max 4 |

Guidance: Award one mark for each correct statement ticked. If more than four boxes are ticked, deduct one mark for each tick beyond four (minimum 0). Do not accept ticks for B, C, E or G.

Place values: 128 64 32 16 8 4 2 1. The bits set to 1 are 32, 8, 4 and 1. 32 + 8 + 4 + 1 = 45.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 1 | 45 | 1 | Accept 0045 / 45 with working. Do not accept an answer given in binary. |

A switch is the central connection point of a star network. It reads the destination address of incoming data and sends it only to the device it is intended for.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 2 | Sends/forwards data (packets) to the correct/intended device // connects the devices (on the LAN) together and directs data between them | 1 | Allow 'central point/hub that the devices connect to' only if linked to passing data between devices. Do not accept 'connects the network to the Internet' (router). Do not accept 'broadcasts data to every device'. |

Authentication is a defensive design technique that checks the identity of a user, for example by checking a username and password, before access is allowed.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 3 | Checking/confirming/verifying the identity of a user // checking that the user is who they say they are | 1 | Allow 'checking login details are correct'. Do not accept 'checking that data entered is sensible' (validation). Do not accept 'stopping hackers' without reference to identity. |

MOD gives the remainder after division. 23 divided by 6 is 3 remainder 5 (6 x 3 = 18; 23 - 18 = 5). The output is 5.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 4 | 5 | 1 | Do not accept 3 (the DIV result) or 3.83. |

The variable can hold only two values, True or False. The data type designed for exactly two values is Boolean.

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 1 | Boolean | 1 | Accept bool. Allow minor spelling errors where the intended word is clear, e.g. Boolian. Do not accept string, integer, character or real. |

Split the 8-bit number into two nibbles: 0110 and 1011.
0110 = 4 + 2 = 6.
1011 = 8 + 2 + 1 = 11, which is B in hexadecimal.
Join the two digits: 6B.

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| 1 | Left nibble 0110 converted to 6 (1 mark) | 1 | Accept 6 shown as the first digit of the answer. Accept working showing the split 0110 / 1011 only if the digit 6 is also given. |
| 1 | Right nibble 1011 converted to B (1 mark) | 1 | Accept b. Do not accept 11 as the final digit. Allow the mark if the digits are given in the wrong order, e.g. B6, provided each nibble was converted correctly (max 1 in that case). |
| 1 | Total | 2 | Award 2 marks for the correct answer 6B with no working. Allow 0x6B or 6B16. Ignore leading or trailing spaces. |

The code must be read at least once and re-read while its length is not 4. A WHILE loop with a first input before it (or a DO UNTIL loop) does this. When the loop ends, the code is valid, so the message is printed once.

Example (Exam Reference Language):
code = input("Enter locker code")
while code.length != 4
code = input("Enter locker code")
endwhile
print("Locker open")

Alternative using DO UNTIL:
do
code = input("Enter locker code")
until code.length == 4
print("Locker open")

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| 1 | Input of the code stored in a variable, and a condition-controlled loop that repeats the input while the length is not 4 (until the length is 4) | 1 | Allow any suitable loop that repeats the input, including DO UNTIL or WHILE with a first input before the loop. Allow len(code) or equivalent length syntax. Do not accept a loop that does not re-input inside it. Do not accept IF used instead of a loop. |
| 1 | Correct length comparison (!= 4 for while, == 4 for until) and "Locker open" output once, after the loop | 1 | Do not award if the print is inside the loop. Output text must match, ignore case and quote style. Minor syntax errors are not penalised. Answers in pseudocode, natural English or bullet points earn no marks. Max 2. |

Set a counter to 0 before the loop. Use a count-controlled loop that runs exactly six times, taking an input each time. Inside the loop, use selection to test whether the reading is greater than 30 and, if so, add 1 to the counter. After the loop has finished, output the counter.

OCR Exam Reference Language:
count = 0
for i = 0 to 5
reading = float(input("Enter temperature"))
if reading > 30 then
count = count + 1
endif
next i
print(count)

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| 1 | Initialises a counter variable to 0 before the loop and increments it by 1 inside the loop (when the condition is met) | 1 | Allow any valid identifier. Allow count += 1 or equivalent. Do not accept the counter being reset to 0 inside the loop. |
| 1 | Loop that repeats six times (and an input is taken on each iteration) | 1 | Allow for i = 1 to 6 // while loop with a correct counter // six separate input statements (max 1 for this point). Do not accept a loop that runs 5 or 7 times. Ignore whether the input is cast to int/float. |
| 1 | Selection that compares the reading with 30 using > (or equivalent) AND outputs the count after the loop | 1 | Both parts are needed for the mark. Allow reading >= 31 for integer input. Do not accept the output inside the loop if it is printed at every iteration. Ignore minor syntax errors, for example a missing endif or next. Answers in pseudocode, natural English or bullet points earn no marks. |

A counter (hotDays) is set to 0 before the loop. A count-controlled FOR loop runs exactly 7 times; on each pass a temperature is input and cast to a number. An IF statement tests whether it is greater than 30 and, if so, adds 1 to the counter. After the loop ends, the message and the count are output once.

OCR Exam Reference Language:

hotDays = 0
for i = 1 to 7
temp = real(input("Enter temperature"))
if temp > 30 then
hotDays = hotDays + 1
endif
next i
print("Hot days: " + str(hotDays))

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| 1 | Counter variable initialised to 0 before the loop // before it is incremented | 1 | Allow any suitable identifier. Do not award if initialised inside the loop. |
| | Count-controlled loop that repeats exactly 7 times (with an input inside the loop) | 1 | Allow for i = 0 to 6 // for i = 1 to 7 // equivalent while/do until loop with its own counter, correctly controlled. Do not award if the input is outside the loop. |
| | Selection that compares the temperature with 30 using > (and increments the counter by 1 when true) | 1 | Allow temp >= 31 for integer-only input. Do not accept >= 30 or temp > 30 compared to the wrong variable. Allow the increment to be shown as count = count + 1 // count += 1. |
| | Outputs the message and the final count once, after the loop | 1 | Allow + or comma for joining text and the count. Ignore missing str() / casting. Do not award if the output is inside the loop. |

Overall guidance: answers must be in OCR Exam Reference Language or a high-level language; pseudocode, natural English or bullet points earn no marks. Minor syntax errors are not penalised (e.g. missing next i, endif, or casting). Allow equivalent language syntax provided the constructs are valid. Max 3 if the count is not made by comparing each temperature with 30 (e.g. totals the temperatures instead).

Declare an array of 7 elements and initialise total, highest and a dry-day counter to 0. Use a count-controlled loop from 0 to 6. Inside it, input a reading, then use a condition-controlled loop to repeat the input while the reading is below 0. Store the valid reading in the array, add it to the total, update highest if it is larger, and add 1 to the counter if it equals 0. After the loop, output the three results.

Example (OCR Exam Reference Language):

array rain[7]
total = 0
highest = 0
dryDays = 0
for i = 0 to 6
reading = float(input("Enter rainfall for day " + str(i + 1)))
while reading < 0
reading = float(input("Invalid. Enter rainfall again"))
endwhile
rain[i] = reading
total = total + reading
if reading > highest then
highest = reading
endif
if reading == 0 then
dryDays = dryDays + 1
endif
next i
print(total)
print(highest)
print(dryDays)

Starting highest at 0 is safe because all valid readings are 0 or more.

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| 1 | Creates an array of size 7 (or equivalent) AND initialises the total and the dry-day counter to 0 before the loop | 1 | Allow the array to be created or filled using any valid syntax. Allow highest being initialised here or set to the first reading. |
| | Count-controlled loop that repeats exactly 7 times (e.g. for i = 0 to 6) | 1 | Allow 1 to 7 if the array indexing is consistent. Allow a while loop with a counter. |
| | Inputs a reading (as a real/float) inside the loop | 1 | Ignore missing casting if the language does not need it. Do not accept the prompt only without input. |
| | Validation: repeats the input while / until the reading is < 0 (correct condition and a re-prompt) | 1 | Allow reading <= -0.1 or equivalent. Do not accept an if with no repetition. Do not accept validation that rejects 0. |
| | Valid reading stored in the array at the correct index AND added to a running total | 1 | Both are needed for the mark. Allow the total to be calculated by a separate loop over the array. |
| | Correct comparison to find the highest reading (reading > highest with assignment) AND correct counting of readings equal to 0 AND all three results output after the loop | 1 | All three elements are needed. Allow follow through for highest if initialised to a value other than 0 that is valid. Do not accept outputs inside the loop. max 5 if any element is missing. |

General: minor syntax errors are not penalised (e.g. missing endwhile, = instead of == in the comparison). Answers written in pseudocode, natural English or bullet points score 0. Allow equivalent syntax in a high-level language, but identifiers must be consistent and constructs valid. Ignore capitalisation of keywords.

Initially i = 0 and total = 0.
Iteration 1: total = 0 + 5 = 5; 5 is not > 7, so no subtraction; i = 1.
Check: 1 < 5 and 5 < 20, so continue.
Iteration 2: total = 5 + 12 = 17; 12 > 7 so total = 17 - 2 = 15; i = 2.
Check: 2 < 5 and 15 < 20, so continue.
Iteration 3: total = 15 + 8 = 23; 8 > 7 so total = 23 - 2 = 21; i = 3.
Check: 21 < 20 is false, so the loop ends.
Output: 21 then 3.

| i | total | Output |
|---|-------|--------|
| 0 | 0 | |
| 1 | 5 | |
| 2 | 15 | |
| 3 | 21 | |
| | | 21 |
| | | 3 |

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| 1 | Initial values i = 0 and total = 0 shown | 1 | Allow if shown as the first row or implied by the first iteration row being correct. |
| 1 | First iteration row: i = 1, total = 5 | 1 | Do not accept if total is shown as 3 or any value other than 5. |
| 1 | Second and third iteration rows: i = 2, total = 15 and i = 3, total = 21 (no further iterations) | 1 | Allow intermediate values 17 and 23 if shown in addition to the final values for the iteration, provided the end-of-iteration values are correct. Do not accept extra iterations. Award for a consistent second row of i = 2 and total = 15 and third row of i = 3 and total = 21 only. |
| 1 | Outputs 21 then 3 in the correct order | 1 | Do not accept 3 before 21. Allow follow-through for the output marks from the candidate's own final total and i values only if the trace is otherwise consistent with the code (max 1 mark follow-through). |

Total: 4 marks. No blanket error carried forward; only the output mark may follow through as stated.

The loop runs five times (i = 0 to 4). Each time, the value just entered (lengths) must be added to the existing value of total, then stored back in total. Line 04 is therefore: total = total + lengths

Question 1 | Answer: total = total + lengths | Marks: 1 | Guidance: Accept total += lengths. Accept lengths + total. Allow equivalent syntax in a studied high-level language. Do not accept answers that omit total from the right-hand side (e.g. total = lengths) or that add a different variable (e.g. i). Ignore minor syntax errors such as capitalisation of the variable names if consistent.

Line 03 must test whether the order is 10 or more loaves, so the condition is loaves >= 10 (loaves > 9 is also correct for whole numbers). Line 04 applies a 20% discount, which leaves 80% of the cost, so cost = cost * 0.8 (or cost - cost * 0.2).

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| Line 03 | loaves >= 10 // loaves > 9 | 1 | Accept 10 <= loaves. Do not accept loaves > 10 or loaves = 10 (or a single = sign). Ignore capitalisation of the variable only if it is used consistently. |
| Line 04 | cost * 0.8 // cost - (cost * 0.2) // cost - cost / 5 // cost * 80 / 100 | 1 | Accept cost * (1 - 0.2). Do not accept cost * 0.2 or cost - 0.2. Minor syntax slips are not penalised. |

Total: 2 marks. The two marks are independent; no follow-through is needed.

(a) input() returns a string, so it must be cast to an integer before it is compared with numbers: line 01 uses int. In line 10 the number total must be cast to a string so it can be joined to the text with +: line 10 uses str.

(b) A DO UNTIL loop always runs once, so the input can be placed inside it once and the separate first input is not needed. The loop must stop when the value is valid, so the condition is the opposite of the invalid test.

do
tickets = int(input("How many tickets (1-10)?"))
until tickets >= 1 AND tickets <= 10

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| (a) | Line 01: int | 1 | Accept integer. Allow real/float only if not penalised elsewhere: do not accept float for this mark. Do not accept str. |
| (a) | Line 10: str | 1 | Accept string. Do not accept int. |
| (b) | Uses do ... until structure with the input statement (cast to int) inside the loop, and no separate input before the loop | 1 | Minor syntax errors are not penalised. Allow equivalent syntax in a high-level language, e.g. do { ... } while (...) with the correct condition. Ignore whether the error message print is included. Do not accept a while loop. |
| (b) | Correct stopping condition: tickets >= 1 AND tickets <= 10 // NOT (tickets < 1 OR tickets > 10) | 1 | Accept 1 <= tickets <= 10 in a high-level language that allows it. Do not accept OR in place of AND for the 'until' form. Do not accept a condition that repeats while the value is valid. A condition that matches the loop type used may be credited (e.g. while-form continuing condition tickets < 1 OR tickets > 10 in a high-level do-while). |

Total: 4 marks

Boundary data is of the correct data type and lies at the edge of the valid range. The valid range is 1 to 6, so 6 is a boundary value that is accepted. 3 is normal data, 10 is invalid data (rejected) and "six" is erroneous data (wrong data type, rejected).

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 1 | B (6) | 1 | Only one box ticked. Do not award the mark if more than one box is ticked. |

The cost contains pounds and pence, so it includes a decimal point and fractional part. A whole-number type cannot store 3.45, so the suitable type is real (also called float).

| Question | Answer | Marks | Guidance |
|---|---|---|---|
| 1(a) | Real // float | 1 (AO2) | Accept decimal / double / currency. Do not accept integer, string, Boolean or character. Ignore spelling errors if the type is clear. |

Boundary data is of the correct type and at the edge of the valid range. The valid range is 1 to 8, so 1 and 8 are the accepted boundary values. Erroneous data is of an incorrect type, so the program rejects it (int() cannot cast it). Examples are a word such as "six" or a real number such as 4.5.

| Question | Answer points | Marks | Guidance |
|---|---|---|---|
| (a) | Boundary test data: 1 // 8 | 1 | Do not accept 0 or 9 (these are boundary values for invalid data, and are rejected). Do not accept a value from the middle of the range, e.g. 4. |
| | Erroneous test data: a value of the wrong data type, e.g. a word / letters / symbols / a real number such as 4.5 / blank entry | 1 | Do not accept a number outside the range, e.g. 12 or -3 (this is invalid, not erroneous). Allow a text example given in quotation marks. |

Max 2. Each mark is independent.