03 Simple numerical programs (Chapter 3)

Ask what the condition being false actually tells you, rather than what you hoped it would tell you.

The loop leaves when the cube of the candidate is not below x. That covers two cases, equal and above, and only one of them is a found answer.

With x equal to 10 the candidates are 0, 1, 2 and 3, and the loop leaves holding 3, whose cube is 27. Nothing about 27 is 10.

The claim is false; the candidate is the smallest one whose cube reaches x, so an equality test after the loop is what decides.

Work out what has to be true for the search to succeed at all, and then ask which change could break that.

Success means one candidate lands inside the window that epsilon opens. The window has a width, and the candidates have a spacing.

With a target of 2 and epsilon 0.01 the window on the candidate runs from about 1.4107 to 1.4177, which is 0.0071 wide. A step of 0.1 produces candidates at 1.4 and 1.5, and neither is inside.

The failing change is the step going up to 0.1.

Separate two questions: what is stored, and what is shown. The claim uses the second to settle the first.

Printing chooses the shortest text that would read back as the same stored value, which for a value very near a tenth is the text 0.1.

Ask for twenty places instead and the same value shows as 0.10000000000000000555, so the stored value is above a tenth.

The claim is false, and format(0.1, '.20f') is how you see it.

Two things are being asked at once: the right arithmetic, and the right type. Check both for each call.

int cuts towards zero, round goes to the nearest whole number, and format produces characters.

On 8.999999999999998 cutting gives 8 and rounding gives 9. Formatting to no places gives the two characters 9, which is text.

round(value) is the one that gives the number 9.

Two things are printed from two different places: one line per candidate from inside the loop, and one line from after it.

The break fires on the first candidate that divides the number, and the loop variable keeps that candidate. With no divisor at all the range simply runs out and the variable holds its last value.

For 45: 45 divided by 2 leaves a remainder, so trying 2 prints and the loop carries on; 45 divided by 3 is exact, so trying 3 prints and then the break fires.

It prints two trying lines and then d = 3 divides? True.

The three printed values are all built from the same two operations, so keep three columns: the place, the number with the low digits removed, and that value's last digit.

Whole division by a power of ten shifts the number rightwards, and % 10 picks off the rightmost digit of the shifted value. The loop ends when the shift has emptied the number.

With 4236: at place 1 the shifted value is 4236 and its last digit is 6; at place 10 it is 423 and 3; at place 100 it is 42 and 2; at place 1000 it is 4 and 4.

It prints four lines, one per digit from the right, then place = 10000.

Two exits means two things to watch, so decide first which one can fire earlier for this target.

The first exit needs the square to come within 0.05 of 3; the second fires as soon as the square goes above 3. The square root of 3 is about 1.732.

Stepping by 0.1 from 0.0 the candidates near the answer are 1.7, whose square is 2.89, and 1.8, whose square is 3.24. The distance at 1.7 is 0.11, still too big, and at 1.8 the square has passed 3.

It prints 18 1.8 and then False.

The printing happens after the update this time, so each line shows the interval the next pass will start from.

The midpoint is the average of the ends. If its square is below the target the answer is above it, so the low end moves up; otherwise the high end moves down.

From 1 and 4 the midpoint is 2.5, whose square is 6.25, above 5, so high becomes 2.5. Then the midpoint is 1.75, whose square is 3.0625, below 5, so low becomes 1.75.

It prints 1 1.0000 2.5000, then 2 1.7500 2.5000, then 3 2.1250 2.5000.

This is the guess-and-check shape with one extra report, so start by writing the loop and the test after it, and only then think about the neighbours.

The loop while ans 4 < x: ans = ans + 1 leaves holding the smallest candidate whose fourth power reaches x. After it, ans 4 == x decides between the two reports.

For 1300 the candidates are 0 to 7, because 6 to the fourth is 1296 and 7 to the fourth is 2401. So the loop leaves holding 7 and the neighbours are 7 minus 1 and 7.

The failing run prints the prompt line, then 1300 is not a perfect fourth power, then The two whole neighbours are 6 and 7.

The shape is a while loop whose condition measures how far the square of the guess is from the target, so write that condition before anything else.

The condition is while abs(guess * guess - k) >= epsilon, and the body is one assignment: guess = guess - ((guess ** 2 - k) / (2 * guess)).

Starting from 25.0 with a target of 50: the height is 625 minus 50, and twice the guess is 50, so the correction is 11.5 and the first printed step is 13.500000.

Five step lines in total, then Square root of 50.0 is about 7.071068 and Steps used: 5.

Start from the wrong output rather than from the code: the program printed 96 for a prime, so ask what the name held at that moment and why.

A counted loop leaves in two ways, by breaking out or by running out of candidates, and the loop variable holds the last candidate either way. Only a test outside the loop can tell the two apart.

For 97 nothing divides it, so the range runs out and the variable holds 96, the last value range(2, 97) produces. The report then prints that number as though a break had happened.

Line 4 is the culprit, and it has to be guarded by a test such as if n % d == 0: or by a flag set inside the loop.

The method has one precondition, so check that first rather than reading the loop body again.

Bisection needs the answer to lie between low and high before the loop starts. Nothing in the code checks that, and a bracket that misses the answer produces a loop that cannot succeed.

For x equal to 0.25 the bracket is 0.0 to 0.25, and the answer is 0.5, which is outside it. Every pass finds the midpoint too small, so low creeps upwards towards 0.25 for ever.

The fix is to widen the upper end to 1.0 when x is below 1.

Two unknowns means two loops, so decide which one is the outer and what each of them is allowed to run over before writing any code.

The outer loop tries bases from 2 upwards; the inner one tries powers from 2 upwards while the base raised to that power is still at most the number. A hit is recorded in two names kept outside both loops.

For 2048 the base 2 works with a power of 11, and it is found first because the outer loop starts at 2. For 90 no pair is ever recorded, so the two names still hold their starting values at the end.

The outer loop can stop when the square of the base passes the number, because the smallest allowed power is 2.

The step has two parts: the height above zero, and the slope at the guess. Identify which part of the line carries each before comparing the choices.

The step is the height divided by the slope, subtracted from the guess. For the guess cubed minus k the height is exactly what the loop condition measures, and the slope is three times the guess squared.

So the top of the fraction must be guess ** 3 - k, matching the loop condition, and the bottom must be 3 * guess ** 2.

The correct body is guess - ((guess ** 3 - k) / (3 * guess ** 2)).

Two counters and one loop over the characters. Decide what each counter means before writing the loop, and leave the reporting until after it.

Walking the characters directly with for ch in text: is enough; no positions are needed. Inside, one test decides whether the character contributes, and it contributes to both counters.

For A3B7C1 the digit characters are 3, 7 and 1, so the count is 3 and the sum is 11, and 11 divided by 3 is 3.6666..., which to two places is 3.67.

For abc it prints the count 0 and the sum 0 and nothing else, because dividing by the count would stop the program.

Two loops means the order of the printed lines is decided by which loop a print belongs to, so mark that before tracing any arithmetic.

The inner loop runs all the way through for each single pass of the outer one, and the row line prints once per outer pass, after its inner loop has finished.

With a target of 6 the pairs that multiply to it are 2 with 3 and 3 with 2, and 1 has no partner in the range because 6 is not among 1, 2 and 3.

It prints row 1 done, then 2 3, then row 2 done, then 3 2, then row 3 done.

The thing being asked for is a count, so decide first whether the count is known before the loop starts. That decides which loop to use.

A while loop is needed when the number of passes is the answer. The balance is the name the condition reads, and it has to change inside the block or the loop never ends.

Starting from 10000 and multiplying by 1.15: after 7 years the balance is about 26600, still under 30000, so an eighth year happens and takes it to 30590.23.

Eight years, and the balance prints as 30590.23TL.

Take the four lines one at a time and decide for each value whether the answer should carry a decimal point before working out its digits.

True division always gives a float even when the division is exact. Whole division rounds downwards, which for a negative value means away from zero, and the remainder then comes out positive.

For the second line: -7 divided by 2 is -3.5, so the whole division goes down to -4, and the remainder has to be 1 because -4 times 2 plus 1 is -7.

It prints 3.5 3 1, then -3.5 -4 1, then -3 3.7, then 1024 1.4142135623730951.