Practise: Rules That Turn Inputs Into Outputs

Write $3.001^2=3.001\times 3.001$. Split the product: $3\times 3.001=9.003$ and $0.001\times 3.001=0.003001$. Adding gives $9.006001$. Subtract 9: the residual is $0.006001$. Compare with the tolerance: $0.006001<0.01$, so the call keeps the stated promise. The estimate is not the square root of 9, since its square is 9.006001, and the second line of the contract does not claim that it is. A caller who reads the second line as "the square root" has dropped the qualifier and will treat a promised approximation as an exact answer.

Divide each reading by sixty and keep the whole part: $50/60$ gives 0, $70/60$ gives 1, $130/60$ gives 2, $185/60$ gives 3, and $300/60$ gives 5. Compare row by row. Row 1 disagrees, because the rule says 0 and the notebook says 1. Rows 2, 3, 4 and 5 agree. The total charge is 1 over 5 rows, so the score is $1/5=0.2$. Read that number as "wrong on one row out of five". The table says nothing about a sixth task, and the contract for the scorer promises nothing about one, so the score carries no claim beyond these five rows.

Start from $T(0)=0$ and apply the recurrence six times. $T(1)=2\times 0+1=1$. $T(2)=2\times 1+1=3$. $T(3)=2\times 3+1=7$. $T(4)=2\times 7+1=15$. $T(5)=2\times 15+1=31$. $T(6)=2\times 31+1=63$. The pattern $2^n-1$ predicts 63, and the recurrence agrees. The base case is the empty tower: moving zero disks takes no move at all.

The innermost bracket is $8+0$, which gives 8. The next bracket out is $4+8$, which gives 12. The next is $9+12$, which gives 21. The outermost is $3+21$, which gives 24. The additions therefore produce 8, 12, 21 and 24 in that order, and the third of them is 21. At the moment the innermost addition runs, three further additions wait outside it, and none of the three sits in a variable of the program.

The term slot produces $1,8,27,64,125$ at $k=1,2,3,4,5$. Add them: $1+8=9$, $9+27=36$, $36+64=100$, $100+125=225$. The same template that summed the integers from 1 to 10 to 55 sums the cubes to 225 when the term slot changes. A check that uses no cubes: the integers 1 to 5 sum to 15, and $15^2=225$, which agrees with the total.

The constructor is called with 4 and 11. It returns a procedure whose body tests its argument: when the argument is 0 it returns 4, and otherwise it returns 11. The second selector calls that procedure with 1, so the answer is 11. The first selector would call it with 0 and receive 4. Nothing is stored in a structure that can be indexed; the two numbers live in the returned procedure, and the two selectors are the only way to reach them.

The loop walks the outer pair, so its first value is the whole seconds column $[15,25,35]$. Index 0 of that row is 15 and index 1 is 25. The scorer takes 25 as the recorded answer and hands it to the charging rule beside the candidate's answer on 15. Nothing raises an error at this point, because a list can be indexed twice. The report that follows is a number of the right kind and the wrong value: 25 seconds has been read as 25 minutes. On the second pass the row is the minutes column, the indices still resolve, and the loop finishes without raising an error; the report is wrong for both rows.

Option C is the check. It records the list before the call, runs the procedure, and compares afterwards; a procedure that sorts the list in place or consumes its entries fails this check while the other checks stay silent. Option A tests the first line, the precondition, because an empty list lies outside what the caller may pass. Option B tests the second line, the postcondition, because it compares the returned value with 6. Option D tests neither line: it exercises an input the fourth line excludes, so whatever happens there is not promised. One call returns one number, and a single number cannot say which line of the contract broke.