Paper 2 Section B practice: design, write, test and refine

• Input: the patient's temperature
• Process: compare the temperature with 36.1 and 37.2 to decide which category it is in
• Output: Normal, Fever or Too low

temp = float(input("Enter temperature"))
if temp < 36.1 then
   print("Too low")
elseif temp > 37.2 then
   print("Fever")
else
   print("Normal")
endif

• inputs the temperature and converts it to a real number (e.g. float(input(…)))
• outputs Too low when the temperature is below 36.1
• outputs Fever when the temperature is above 37.2
• otherwise outputs Normal
• the selection is structured so that every temperature gets exactly one output, including 36.1 and 37.2 giving Normal

• a value in the normal range, e.g. 36.8, expected output Normal
• a value above the range, e.g. 38.0, expected output Fever
• a value below the range, e.g. 35.0, expected output Too low

• a boundary value, e.g. 36.1 or 37.2 (allow 36.0 or 37.3, just outside the range)
• the correct expected output for the value given: Normal for 36.1 or 37.2 (they are included in the normal range), Too low for 36.0, Fever for 37.3

• a sensible sub-task below Update score, e.g. check whether the answer is correct
• a second, different sub-task below Update score, e.g. add 10 points to the score
• a sensible sub-task below Show final score, e.g. check whether all 10 answers were correct
• a second, different sub-task below Show final score, e.g. add the 20-point bonus / display the final score

score = 0
for q = 1 to 10
   answer = input("Correct? (yes/no)")
   if answer == "yes" then
      score = score + 10
   endif
next q
if score == 100 then
   score = score + 20
endif
print(str(score))

• sets the score to 0 before the loop
• uses a count-controlled loop that repeats 10 times
• inputs yes or no inside the loop
• adds 10 to the score when the input is yes
• after the loop, checks whether all 10 answers were correct (e.g. the score is 100, or a count of correct answers is 10)
• adds 20 to the score only when that check is true
• outputs the final score after the bonus check

• q takes the values 1, 2, 3, 4 in order
• answer takes the values yes, no, yes, yes in order
• score is 10 when q = 1 and is still 10 when q = 2
• score is 20 when q = 3 and 30 when q = 4
• 30 is output once, after the loop has finished

function pointsFor(difficulty)
   switch difficulty:
      case "EASY":
         points = 5
      case "MEDIUM":
         points = 10
      case "HARD":
         points = 20
      default:
         points = 0
   endswitch
   return points
endfunction

• defines a function pointsFor that takes the difficulty as a parameter
• uses a switch/case statement on the difficulty
• EASY gives 5, MEDIUM gives 10 and HARD gives 20
• a default case gives 0 for any other value
• returns the number of points (from each case, or once after the end of the switch)

• any value other than "EASY", "MEDIUM" or "HARD", e.g. "BONUS", "hard" (the comparison is case-sensitive) or an empty string
• 0

• Inputs: the number of runners, and each runner's name and time
• Processes: any one of: check that each time is valid (a whole number from 600 to 3600); store the names and times; compare the times to find the lowest (fastest)
• Output: the name (and time) of the fastest runner
• (ii) range check (allow type check or presence check)
• a description that matches the check named: range check, the time is from 600 to 3600 inclusive / type check, the time is a whole number (integer) / presence check, a time has been entered

count = int(input("Enter number of runners"))
array names[count]
array times[count]
for i = 0 to count - 1
   names[i] = input("Enter name")
   valid = false
   do
      t = int(input("Enter race time in seconds"))
      if t >= 600 AND t <= 3600 then
         valid = true
      else
         print("Invalid time")
      endif
   until valid == true
   times[i] = t
next i
fastest = 0
for i = 1 to count - 1
   if times[i] < times[fastest] then
      fastest = i
   endif
next i
print(names[fastest])
print(str(times[fastest]))

• inputs the number of runners and declares arrays (or equivalent) for the names and the times
• uses a count-controlled loop that runs once for each runner
• inputs each runner's name and stores it, with that runner's time, at the same index in the arrays
• inputs the time inside a condition-controlled loop (e.g. do … until) that repeats until a valid time is entered
• the validation condition accepts only whole numbers from 600 to 3600 inclusive
• compares each stored time with the lowest time found so far
• records the index (or name) of the runner with the lowest time, updating it whenever a lower time is found
• outputs the name and the time of the fastest runner once every runner has been entered

• normal: any whole number from 601 to 3599, e.g. 1500, accepted
• boundary: 600, accepted
• boundary: 3600, accepted
• invalid: a whole number below 600 or above 3600, e.g. 599 or 4000, rejected (the time is asked for again)
• erroneous: data of the wrong type, e.g. "ten" or 1500.5, rejected (the time is asked for again)

function fastestIndex(times, n)
   fastest = 0
   for i = 1 to n - 1
      if times[i] < times[fastest] then
         fastest = i
      endif
   next i
   return fastest
endfunction

f = fastestIndex(times, count)
print(names[f])
print(str(times[f]))

• defines a function fastestIndex with two parameters: the array of times and the number of runners
• loops through the times, comparing each with the fastest found so far and updating the index when a lower time is found
• returns the index of the fastest time (after the loop)
• the main program calls fastestIndex with the times and the number of runners, and uses the returned index to output the fastest runner's name and time

• identifies a benefit: the function can be reused (called again) / it can be tested on its own / the main program is shorter and easier to follow
• explains it in this context, e.g. the club could call it again to find the fastest under-18 runner without rewriting the search / it can be tested with a small set of chosen times, separately from the input and validation code