This week the #puzzle is: Can You Hop in a Spiral? #geometry #trigonometry #angle #arctan #minimize #markovchain #coding

Frankie the frog is hopping on a large, packed grid of lily pads, shown below. The pads are circular and each is a distance 1 from its nearest neighbors. (More concretely: Each pad has a diameter of 1 and they are arranged in a hexagonal lattice.) Frankie starts at (0, 0), the center of the pad labeled A. Then she hops due east to pad B at (1, 0), and from there she hops to pad C at (1.5, √(3)/2).

She wants to continue hopping in a counterclockwise, spiral-like pattern. Each of her jumps is to the center of a neighboring pad, a net distance of 1. But there are two rules her spiral must follow:

– Each next pad must be in a more counterclockwise direction (relative to spiral’s origin at pad A) than the previous pad. – Each pad must be farther from A than the previous pad.

After a number of hops spiraling around, Frankie realizes she is, once again, due east from A. What is the closest to A she could possibly be? That is, what is the minimum possible distance between the center of the pad she’s currently on from the center of pad A?

And for extra credit:

Can You Hop in a Spiral?

Highlight to reveal (possibly incorrect) solution:

Desmos 1 Program Desmos 2

Method 1:

• I try to construct the path in Desmos. At every step, is it possible to turn 60° counter clockwise and still obey the rules? If not, continue straight ahead.
• There are just too many steps!

Method 2:

• I write a program to assist. I look at all 6 directions. But I also know which 2 are 60° counter clockwise and straight ahead. I look at the distance and the angle. And then I choose.
• I reuse Desmos to show the result.
• I end up at a distance 64.

Method 3:

• I can vaguely see a method, where I keep going straight ahead, until I reach x = 0, y = x/2k or y = – x/2k. (k = √3/2.) (These guide lines are also shown in Desmos.) Let’s try it out. Desmos 2 assists.
• I want my spiral to be as tight as possible. From any point, I test going back the same way, or 60° less, or 120° less, or 180° less, or 240° less, or 300° less, in that order. I am looking for small additions to the distance to A, hopefully getting large jumps in angle.
• |AX| denotes the distance between points A and X, where points A and X are the centers of pads A and X. α_X denotes the angle to point A from X.
• Looking for D.
  • From C = (1.5,k) I could go back to D0 = B. But |AD0| = |AB| < |AC|, as the rules state. Likewise α_D0 = α_B < α_C, as the rules state. Rejected.
  • I could go to D1. But |AD1| < |AC|. Rejected.
  • I could go to D2. |AC| = 1.73, |AD2| = 2. α_C = 30°, α_D2 = 60°.
  • I could go to D3. |AD3| = 2.65. α_D3 = 40.89°. D2 would be better, more angle, less distance.
  • I could go to D4. α_D4 = 19.11°. Rejected.
  • I could go to D5. α_D5 = 0°. Rejected.
• I choose D = D2 = (1,2k). |AD| = 2. α_D = 60°.
• The line through C and D crosses y = x/2k in C. It is y = -2kx + 4k.
• Looking for E.
  • E1 = D1. |AE1| = |AD1| < |AC| < |AD|. Rejected.
  • E2. |AE2| < |AD|. Rejected.
  • E3. |AE3| = 2.65. α_E3 = 79.11°.
  • E4. α_E4 = 60°. Not smaller than α_D. Rejected.
  • E5 = D3. α_E5 = 40.89°. Rejected.
• There’s only 1 choice, E3 = E = (0.5,3k). |AE| = 2.65. α_E = 79.11°.
• Looking for F. F1 fails both distance and angle. F2 has the same distance. F3 is okay. F4 and F5 both fail the angle rule. So I choose F3 = F = (0,4k). I am now on the line x = 0 and the line y = 4k.
• Going forward, I will choose G3, H3 etc. until I reach L3, on the line y = – x/2k. All these points are on the line y = 4k. Then I will turn left a little, choosing M2. And then go straight forward a bit.
• Let’s look at some of these distances a bit more detailed.
• Being in D = (1,2k), on the line y = -2kx + 4k, I am looking for E.
  • |AD|² = 1² + (2k)²
  • E1 = D + (-0.5,-k).
  • |AE1|² = (1-0.5)² + (2k-k)² < 1² + (2k)² = |AD|²
  • E2 = D + (-1,0).
  • |AE2|² = (1-1)² + (2k+0)²
    • = 1² – 2*1*1 + 1² + (2k)²
    • = 1² + (2k)² – 2*1*1 + 1²
    • = |AD|² – 2*1*1 + 1²
    • = |AD|² – 2 + 1
    • = |AD|² – 1
    • < |AD|²
  • E3 = D + (-0.5,k)
  • |AE3|² = (1-0.5)² + (2k+k)²
    • = 1² – 2*1*0.5 + 0.5² + (2k)² + 2*2k*k + k²
    • = 1² + (2k)² – 2*1*0.5 + 0.5² + 2*2k*k + k²
    • = |AD|² – 2*1*0.5 + 0.5² + 2*2k*k + k²
    • = |AD|² – 1 + 0.5² + 4k² + k²
    • = |AD|² – 0.75 + 5k²
    • = |AD|² + 3
  • Distance wise, E3 is the only candidate. (E4 and E5 are rejected because of the angle.)
• For a more general case, let’s look at the search for H, I etc.
• X = (x, 4k), x < 0
• Y1 = (x+0.5, 4k-k)
• Y2 = (x-0.5, 4k-k)
• Y3 = (x-1, 4k)
• Y4 = (x-0.5, 4k+k)
• Y5 = (x+0.5, 4k+k)
• |AX|² = x² + (4k)²
• |AY1|² = (x+0.5)² + (4k-k)²
  • = x² + 2*0.5*x + 0.5² + (4k)² – 2*4k*k + k²
  • = x² + (4k)² + 2*0.5*x + 0.5² – 2*4k*k + k²
  • = |AX|² + 2*0.5*x + 0.5² – 2*4k*k + k²
  • = |AX|² + x + 0.5² – 8k² + k²
  • = |AX|² + x + 0.5² – 7k²
• We want |AX|² < |AY1|²
  • <=> |AX|² < |AX|² + x + 0.5² – 7k²
  • <=> 0 < x + 0.5² – 7k²
  • <=> – 0.5² + 7k² < x
  • <=> – 0.25 + 7*(√3/2)² < x
  • <=> – 0.25 + 7 * 3/4 < x
  • <=> 5 < x
• But x < 0, so that won’t happen.
• |AY2|² = (x-0.5)² + (4k-k)²
  • = x² – 2*0.5*x + 0.5² + (4k)² – 2*4k*k + k²
  • = x² + (4k)² – 2*0.5*x + 0.5² – 2*4k*k + k²
  • = |AX|² – 2*0.5*x + 0.5² – 2*4k*k + k²
  • = |AX|² – x + 0.5² – 8k² + k²
  • = |AX|² – x + 0.5² – 7k²
• We want |AX|² < |AY2|²
  • <=> |AX|² < |AX|² – x + 0.5² – 7k²
  • <=> 0 < – x + 0.5² – 7k²
  • <=> x < 0.5² – 7k²
  • <=> x < 0.25 – 7*(√3/2)²
  • <=> x < 0.25 – 7 * 3/4
  • <=> x < -5
• This should certainly happen at some point, say x = -6. In that case we would have M2 = (-6.5, 3k).
• Let’s also look at Y3.
• |AY3|² = (x-1)² + (4k)²
  • = x² – 2x + 1 + (4k)²
  • = x² + (4k)² – 2x + 1
  • = |AX|² – 2x + 1
• We want |AX|² < |AY3|²
  • <=> |AX|² < |AX|² – 2x + 1
  • <=> 0 < – 2x + 1
  • <=> 2x < 1
  • <=> x < 0.5
• We already have that as x < 0.
• The turn to M2 happens at L3 = (-6, 4k).
  • x = -6
  • k = √3/2
  • 1/k = 2/√3
    • = 2√3/3
  • Does L3 lie on y = – x/2k?
  • y = – (-6) / (2k)
    • = 6/2k
    • = 6 * 2√3/3 / 2
    • = 6 * √3/3
    • = 2 * √3
    • = 4 * √3/2
    • = 4k
  • Yes, it does.
• I think I need some more details here. But they should be trivial.
• Sketch: Rotate the situation around A. L3 is now on x = 0. Do similar calculations. Etc.
• In conclusion: Within the guide lines, travelling on a line perpendicular to x = 0, y = x/2k or y = – x/2k, it is safe to turn left when a guide line is hit.

And for extra credit:

Spreadsheet

Method 1:

• I fiddle around with a spreadsheet, just to see what happens.
• There are just too many steps!

Method 2:

• I write a program. Markov chain like.
• I end up with N = 28.

This week the #puzzle is: Bingo! #statistics #probabilities #combinatorics #counting #coding #program #montecarlo

A game of bingo typically consists of a 5-by-5 grid with 25 total squares. Each square (except for the center square) contains a number. When a square’s number is called, you place a marker on that square. The goal is to get “bingo,” which is five squares in a row, either across, down, or along one of the two long diagonals. The center square, which doesn’t have a number, is labeled “Free,” and begins with a marker on it before any numbers are called. Here’s an example of a winning 5-by-5 grid in which 10 squares (other than the “Free” square) have been marked:

Consider a smaller version of the game with a 3-by-3 grid: a “Free” square surrounded by eight other squares with numbers. Suppose each of these eight squares is equally likely to be called, and without replacement (i.e., once a number is called, it doesn’t get called again).

On average, how many markers must you place until you get “bingo” in this 3-by-3 grid? (The “Free” square doesn’t count as one of the markers—it’s “free”.)

And for extra credit:

Bingo!

Highlight to reveal (possibly incorrect) solution:

Program By hand

Method 1: Monte carlo. See program.

Method 2: Go through all options. See program.

Method 3: Go through all options by hand.

Result: 3.471429 markers.

And for extra credit:

Method 1 and 2, from above.

Result: 13.608084 markers.

I had to optimize the program quite a lot to get a reasonable run time. Memoization. And taking into account, that each setup exists in 8 versions, rotated and mirrored. As always it’s a joy when a recursive function suddenly works.

My previous post #ThisMonthsScienceNewsPuzzle, 20260116 is now public.

This week the #puzzle is: Can You Brighten Up the Room? #geometry #trigonometry #angles #reflection #animation

While dining at a restaurant, I notice a lamp descending from the ceiling, as shown in the diagram below. The lamp consists of a point light source at the center of a spherical bulb with a radius of 1 foot. The top half of the sphere is opaque. The bottom half of the sphere is semi-transparent, allowing light out (and thus illuminating my table) but not back in. The light source itself is halfway up to the ceiling—5 feet off the ground and 5 feet from the ceiling. The ground reflects light.

Above the light, on the ceiling, I see a circular shadow. What is the radius R of this shadow?

And for extra credit:

Can You Brighten Up the Room?

Highlight to reveal (possibly incorrect) solution:

Desmos

Thoughts:

• Playing around with Desmos a little shows, that we want to find, where light hits the floor and reflects back and just nicks the lamp.
• The light will travel 5 feet down and then 5 up. Meanwhile it will travel 1 foot horizontally.
• After nicking the lamp, it will travel a further 5 up and 0.5 horizontally.
• It will hit the light 1.5 feet away from the center. This is the radius of the shadow.
• Playing with the angle of the light, I find a solution when the angle is 4.6122 rad and the radius is 1.507556 feet.

And for extra credit:

Program Animation

Thoughts:

• Originally we had r = 1 and h = 5, resulting in R = 1.5.
• We want different values for r, h and R, so that they are all integers and R is minimized.
• I don’t think h actually matters.
• R = 1.5 * r.
• r should be an integer n, and so should 1.5 * n.
• 1.5 * n
  • = 3/2 * n
  • = 3 * n/2
• So n should be divisible by 2.
• We minimize R by minimizing r.
• The solution seems to be r = 2, R = 3. (And then h = 5 or whatever.)

Ahem.

• Originally we had r = 1 and h = 5, resulting in R = 1.507556. This happens at angle k = 4.6122216 rad.
• R = 3 * h / tan(k)
• Furthermore the distance between the line nicking the lamp and (0,0) has to be 1.
• The second part of the light beam is represented by y = tan(k) * x – 2 * h.
• x² + y² = 1 and y = tan(k) * x – 2 * h
  • <=> x² + (tan(k) * x – 2 * h)² = 1
  • <=> x² + tan²(k) * x² – 4 * h * tan(k) * x + 4h² = 1
  • <=> (tan²(k) + 1) * x² – 4 * h * tan(k) * x + 4h² – 1 = 0
  • <=> x = (4 * h * tan(k) +- √((4 * h * tan(k))² – 4 * (tan²(k) + 1) * (4h² – 1))) / (2 * (tan²(k) + 1))
  • <=> x = (4 * h * tan(k) +- √(4² * h² * tan²(k) – 4 * (tan²(k) + 1) * (4h² – 1))) / (2 * (tan²(k) + 1))
  • <=> x = (2 * h * tan(k) +- √(4 * h² * tan²(k) – (tan²(k) + 1) * (4h² – 1))) / (tan²(k) + 1)
  • <=> x = (2 * h * tan(k) +- √(4 * h² * tan²(k) – tan²(k) (4h² – 1) – 4h² – 1)) / (tan²(k) + 1)
  • <=> x = (2 * h * tan(k) +- √(tan²(k) – 4h² + 1)) / (tan²(k) + 1)
• We want this to only have 1 solution.
• tan²(k) – 4h² + 1 = 0
  • <=> tan²(k) = 4h² – 1
  • <=> tan(k) = √(4h² – 1)
  • <=> k = arctan(√(4h² – 1))
• Just to test: h = 5, k = 1.47063. k + π = 4.61222.

This actually assumes r = 1. Let’s try again.

• R = r * 3 * h / tan(k)
• The result for k becomes:
• k = arctan(√(4h² – r²))
• Therefore:
• R = r * 3 * h / tan(arctan(√(4h² – r²)))
  • = r * 3 * h / √(4h² – r²)
• So. We want h, r and R all to be integer.
• First we need 4h² – r² to be a square.
• Let r = 2m
• 4h² – r² = 4h² – (2m)²
  • 4h² – 4m²
  • 4(h² – m²)
• This is a square when h² – m² is square.
• h > m, squares have to be positive. (Also, we don’t want to lamp to hit the floor, so h > 2m.)
• h² – m² = a²
  • <=> h² = a² + m²
• h, m and a are all integer. (r is even.)
• Example: m = 5, a = 12, h = 13.
• h = 13, r = 2m = 10
• 4h² – r² = 4 * 13² – 10²
  • = 576
• R = r * 3 * h / √(4h² – r²)
  • 10 * 3 * 13 / √576
  • 390 / 24
  • 16.25
• So that wasn’t actually enough.
• a has to divide r * 3 * h
• R = r * 3 * h / √(4h² – r²)
  • = 2m * 3 * h / √(4h² – (2m)²)
  • = 2m * 3 * h / √(4 * (h² – m²))
  • = 2m * 3 * h / √(4 * a²)
  • = 2m * 3 * h / 2√(a²)
  • = 3mh / a
• I think it’s time to write a program.

My program finds several possible solutions.

Oh, and I did an animation of some of the solutions. Baby’s first animation.

From this I find, that R = 65 feet is the smallest solution.

This month the #puzzle is: Math puzzle: The homesick rover #addition #sum

And as a bonus:

Math puzzle: The homesick rover

(Possibly incorrect) solution:

Desmos

Thoughts:

• The rover travels 1 km in some direction on day 1. Let’s call it north.
• On day 2 it travels 2 km either east or west.
• On day 3 it travels 3 km either north or south.
• And so on for 8 days.
• It must go the same amount north as south. It travels 1+3+5+7 = 16 in all. It must go 8 north and 8 south. This can be achieved by traveling e.g. 1+7 north and 3+5 south.
• Same principle for east and west. 2+4+6+8 = 20. 2+8 = 4+6 = 10.

And for the bonus:

Spreadsheet

Thoughts:

• For 100 rovers, with 1-100 day missions, some are excluded right away.
• Let’s say the sum of all the odd numbers is o, and the sum of all the even numbers is e.
• Both o and e have to be even.
• Therefore o is a sum of an even number of numbers.
• For a 1 day mission, o = 1, e = 0. Out. o is odd.
• For a 2 day mission, o = 1, e = 2. Out. o is odd.
• For a 3 day mission, o = 4, e = 2. Possible?
• The next step is, that each sum has to break down into 2 equal sums. But we can’t break 1+3 into 2 equal sums. So this is out too.
• For a 4 day mission, o = 4, e = 6. Out because of 4.
• It’s not enough to say, that o and e are both even, or that o is a sum of an even number of numbers.

Let’s look at the general case for odd numbers.

• o = 1+3+…+n, where n is odd.
• We already know, there has to be an even number of numbers. There are 2k numbers, where k is an integer.
• o = 1+3+…+(4k-1)
  • = 2-1 + 4-1 + … 4k-1
  • = 2 + 4 + … + 4k – 2k
  • = 2(1+2+…+2k) – 2k
  • = 2 * 2k/2 * (1+2k) – 2k
  • 2 * k * (2k+1) – 2k
  • 4k² + 2k – 2k
  • 4k²
• The odd numbers have to break down nicely into 2 sums, each 2k².
• k = 1 doesn’t work, 1+3 can’t be broken down to 2 sums of 2.
• k = 2 works, 1+3+5+7 = 1+7 + 3+5 = 2 * 8.
• k = 3 works, 1+3+5+7+9+11 = 7+11 + 1+3+5+9 = 2 * 18.
• k = 4 works, the sum has 8 numbers, the 4 innermost and the 4 outermost have the same sum, 1+3+13+15 = 5+7+9+11 = 32. In general, this can be done when k is divisible by 4.
• k = 5 works, 19+17+13+1 = 3+5+7+…+16 = 50.
• k = 6 works, 23+21+19+9 = (the rest) = 72.
• k = 7 works, 27+25+23+19+3+1 = 98
• (so far I am just constructing a sum, to see whether it can be done)
• k = 8 works, k = 2 * 4
• Given the first 2k odd numbers, can I always find a sum of 2k²?
• Let’s look at the sum of the m top odd numbers:
• 4k-1 + 4k-3 + … + 4k-2m+1
  • = m/2 * (4k-1 + 4k-2m+1)
  • = m/2 * (8k – 2m)
  • = m * (4k-m)
• I create a spreadsheet and look at my options. If for each k I can find an m, so that the difference between 2k² and m * (4k-m) is small enough to be filled with small, odd numbers, I am home.
• Apparently the only k, this doesn’t work for, is 1.
• For an n day mission, if there are 2k odd numbers (meaning n = 4k or n = 4k-1), and k is an integer, 1 < k, then we can get the sums of odd numbers to work.
• This means 7, 8, 11 and 12 might work. And we have already checked, that regarding the odd numbers, they do.

Now let’s look at the even numbers.

• e = 2+4+…+n, where n is even.
• e = n/2 * (2+n)/2
  • = n * (2+n) / 4
  • = (n² + 2n) / 4
• This has to split up nicely into 2 sums of (n² + 2n) / 8.
• So n² + 2n is divisible by 8.
• We know n is even, so it could be written as 2k.
• n² + 2n = (2k)² + 2*2k
  • = 4k² + 4k
  • = 4k * (k + 1)
• This is divisible by 8 when k is divisible by 2 or k is odd — so always!
• n = 2. This still fails, because 2 is only 1 number and can’t be split up into 2 sums.
• n = 4. This still fails, 2+4 can’t be split up.
• n = 6. 2+4+6 = 2+4 + 6 = 2 * 6.
• n = 8. Already done.
• n = 10. 2+4+6+8+10 = 2 * 15? Oh wait. e/2 also has to be even, because it’s a sum of even numbers. So this fails.
• e/2 = 4k * (k + 1)/8
  • = k * (k+1)/2
• If 2 divides k:
  • k/2 * (k+1)
  • This is even when k/2 is even.
• If 2 divides k+1:
  • k * (k+1)/2
  • This is even when (k+1)/2 is even.
• New rule: Either k or k+1 is divisible by 4.
• n = 10. k = 5. We need (5+1)/2 = 3 to be even, and it isn’t.
• n = 12. k = 6. k is even, but k/2 = 3 isn’t. e = 42. e/2 = 21. Fail.
• n = 14. k = 7. k+1 = 8 is divisible by 4. e = 56. e/2 = 28. 1 of the sums could be 14 + 12 + 2. Success.
• n = 16. k = 8, divisible by 4. e = 72. e/2 = 36. 1 of the sums could be 16 + 14 + 6. Success.
• n = 18, k = 9, k+1 = 10, neither divisible by 4. Fail.
• n = 20, k = 10, k+1 = 11, neither divisible by 4. Fail.
• n = 22, k = 11, k+1 = 12, divisible by 4. e = 132. e/2 = 66. 1 of the sums could be 22 + 20 + 18 + 6.
• n = 24, k = 12, divisible by 4. e = 156. e/2 = 78. 1 of the sums could be 24 + 22 + 20 + 18.
• At this point I predict: For an n day mission, if there are k = n/2 even numbers (meaning n = 2k or n = 2k + 1), if either k or k+1 is divisible by 4, then we can get the sums of even numbers to work.

Putting the 2 rules together:

• For an n day mission, if there are 2k odd numbers (meaning n = 4k or n = 4k-1), and k is an integer, 1 < k, then we can get the sums of odd numbers to work.
• At this point I predict: For an n day mission, if there are k = n/2 even numbers (meaning n = 2k or n = 2k + 1), if either k or k+1 is divisible by 4, then we can get the sums of even numbers to work.

Let’s write this another way.

• The mission has n days.
• If x is an integer, 1 < x, n = 4x or n = 4x-1, success for the odd numbers.
• If y is an integer, n = 2y or n = 2y + 1, y or y+1 divisible by 4, success for the even numbers.

This develops into a pattern. These work:

• 7 and 8.
• 15 and 16.
• 23 and 24.
• …

Let’s look at one of the actual problems in the Moscow Mathematical Papyrus.

Problem 05:

• Example of the calculation of a ship’s mast from a cedar log.
• If someone says to you: “[Make] a mast from a cedar log 30 cubits
• long [such that the mast] is 1/3 1/5 (?) [of the length of the log].” Calculate 1/3 1/5 of this 30.
• [If the result is 16, say to him:] “You have obtained
• [this mast. You have found it] correctly.”

Nowadays we would have a formula:

• ml = c * cl
• ml: mast length
• c: constant
• cl: cedar length

And of course we would have drilled school children in this formula, because everybody needs to know these things. Next we would have defined, for this particular problem, some values:

• c = 1/3 + 1/5
• cl = 30 cubits

We’re not used to writing values with fractions like that in our time, so we need to convert that.

• c = 1/3 + 1/5
  • = 5/15 + 3/15
  • = 8/15

Now we can plug these values in.

• ml = c * cl
  • = 8/15 * 30

And calculate.

• ml = 16

You have found it correctly!

For some time now I have been trying to understand the Moscow Mathematical Papyrus. And for me, understanding = writing and sharing. Therefore the results of my thoughts are now available on this page.

What is this particular papyrus? Well, it’s math problems and solutions. Some of its importance hinges on “did they know how to do that already?” This goes for problems 10 and 14 especially. They knew how to calculate the area of a sphere? And the volume of a pyramid? Well, apparently, yes. They could also work with unknowns and take square roots. Exciting!

At some point the papyrus ended up in Moscow, and a lot of research was done on it at that time.

Without further ado, welcome to my treatment of the Moscow Mathematical Papyrus.

This week the #puzzle is: Some Coffee With Your Tea? #summation

And for extra credit:

Some Coffee With Your Tea?

Intermission

I’m not quite sure what happened with the magic squares. I guess the method I found (writing code to calculate equations and choose among primes) didn’t work. Ah well.

I was actually part of the way with the extra credit. N has to be even. N can’t be 18 or more. But then I would have gotten it wrong, by saying N = 4 wouldn’t work.

Highlight to reveal (possibly incorrect) solution:

Thoughts:

• There’s 12 fluid ounces in each cup. There’s a coffee cup and a tea cup.
• After the mixing, the coffee cup still has 12 fluid ounces, some of it coffee, some of it tea. Let’s say the amount of coffee is c and the amount of tea is t.
• 12 = c + t.
• The tea cup has the amount 12 – c of coffee and 12 – t of tea. (The rest of the coffee and the rest of the tea.)
• How much coffee in the tea cup?
  • 12 – c
  • = (c + t) – c
  • = c + t – c
  • = t
• There’s t tea in the coffee cup and t coffee in the tea cup. The 2 amounts/ratios are the same.

And for extra credit:

Desmos 1 2

Throughts:

• In general:
  • cc₀ = 12 (coffee in coffee cup to begin with)
  • tc₀ = f(0) (tea in coffee cup 1st time , for some function f)
• Then something is poured out.
• Δcc = cc₀ * f(0) / (cc₀ + tc₀)
  • = cc₀ * f(0) / (12 + f(0))
• Δtc = tc₀ * f(0) / (12 + f(0))
• cc₁ = cc₀ – Δcc
  • = cc₀ – cc₀ * f(0) / (12 + f(0))
  • = cc₀ (1 – f(0)/(12 + f(0))
• tc₁ = tc₀ (1 – f(0) / (12 + f(0))
• cc₂ = cc₁ (1 – f(1)/(12 + f(1))
  • cc₀ (1 – f(0)/(12 + f(0)) (1 – f(1)/(12 + f(1))
• Example 1:
  • f is always some ε, constant.
  • We go n = 12 / ε rounds.
  • cc_n = cc₀ (1 – ε/(12 + ε)ⁿ
    • = cc₀ (1 – ε/(12 + ε)^(12/ε)
  • Going to desmos, this expression has a minimum with ε approaching 0, approximately 4.41455. This looks suspiciously like 12/e. Also it’s the best option I’ve found.
• Example 2:
  • f is shrinking. E.g., it might say, that each round half the remaining pure tea is added.
  • f(0) = 12/2 = 6 = 6/2⁰
  • f(1) = f(0)/2 = 12/2² = 6/2 = 6/2¹
  • f(n) = 6/2ⁿ
  • This one goes ∞ rounds.
  • cc_∞ = cc₀ (1 – 6/2⁰/(12 + 6/2⁰)) (1 – 6/2¹/(12 + 6/2¹)) (1 – 6/2²/(12 + 6/2²)) … (1 – 6/2^∞/(12 + 6/2^∞))
  • 1 – 6/2⁰/(12 + 6/2⁰)
    • = (12 + 6/2⁰)/(12 + 6/2⁰) – 6/2⁰/(12 + 6/2⁰)
    • = (12 + 6/2⁰ – 6/2⁰)/(12 + 6/2⁰)
    • = 12/(12 + 6/2⁰)
    • = (6 * 2)/(6 * (2 + 2^-0))
    • = 2 / (2 + 2^-0)
  • cc_∞ = cc₀ (2 / (2 + 2^-0)) (2 / (2 + 2^-1)) (2 / (2 + 2^-2)) … (2 / (2 + 2^-∞))
    • = cc₀ * 2/3 * 4/5 * 8/9 * … 1
  • Using Desmos, cc_∞ = cc₀ * 0.41942 = 12 * 0.41942 = 5.03307
  • There might be a shrinking strategy, that works better, but this one gave a worse result than using a constant.
  • Just for fun I tried adding 2/3 of the pure tea instead of 1/2. Now cc_∞ = cc₀ * 0.44058 = 12 * 0.44058 = 5.28696. Worse. 3/4 is even worse.
• I haven’t gone through all the possible strategies, because it’s hard to find a systematic way to do this.

I’ve done Everybody Codes, back in November.

The Song of Ducks and Dragons [ 2025 ]

All my code is available . And so are my times. And I really like, that we operate with local times here.

.........................................................................................#
.................#...........#.....#........#........#.....#...........#.................#
.....#..##.#..#..#.#...#..#..#.....#...#.#..#..#.#...#.....#..#..#...#.#..#..#.##..#.....#
.#####.###.#.###.#.###.#####.#.#####.###.#.###.#.###.#####.#.#####.###.#.###.#.###.#####.#
##########################################################################################

Quest 16. There’s a certain kind of wall, with a connection between a list of numbers, a given length and the resulting wall built by a known number of blocks. For the list of numbers, 1 means, place a block in every column. 9 means, place a block every 9 columns. Given a list of numbers and a length, count all the blocks (part 1). Given a known wall, find the list (part 2). Given a known wall segment and a number of blocks, find the length (part 3).

Oh, the circularity! Part 1 uses floor(). For part 2, I can reverse engineer the wall. Is there a block in column 1? Add 1 to the list of numbers and mark all the corresponding blocks. Is there an unmarked block in column 2? Add 2 to the list of numbers and mark blocks. Is there an unmarked block in column 3? Add 3 to the list… For part 3, bisection is good.

..........4..........
......473483436......
....4671465878781....
...219317375373724...
..81639828352872922..
..73694243721961934..

Quest 17. Given a map with numbers and @ marking a volcano, and a rule for how the volcano “grows”, add up all numbers within radius 10 of the volcano (part 1). The volcano grows in steps, find the step with the highest sum of numbers (part 3). Plan a path from S around the volcano and back to S, given the volcano has grown n steps, each step of the path adds the number and the sum mest be less than (n + 1) * 30. Find n.

In part 1, go through the map and remove all the numbers outside the radius, then add up the remaining numbers. In part 2, visit all numbers. Calculate the step, where this number would be affected, and add the number to a corresponding sum. Find the highest sum. In part 3, Dijkstra! This one I had to think about. In part because the path might visit a number twice. But, there’s a way to do it.

First assume the volcano has grown to radius n. (Beginning with 0.) Then use Dijkstra to find 2 paths, one going clockwise (*) from the red S to a point in the green bar, one counterclockwise. Examine for all points in the green bar. Find the best sum of 2 paths. If it’s too high, calculate the n where this path would have worked, set n to this value and try again. Whew! And I also had to remove my big data structures, when my calculations has finished, or the program would crash.

(*) Force clockwise by removing the lower blue bar.

Plant 1 with thickness 1:
- free branch with thickness 1

Plant 2 with thickness 1:
- free branch with thickness 1

Plant 4 with thickness 17:
- branch to Plant 1 with thickness 15
- branch to Plant 2 with thickness 3

Quest 18. There are plants with branches. Plants like no. 1 can simply be activated. Plants like no. 4 depends on its input from other plants. Given a rule for how plants affect other plants, activate all the simple plants and see how it affects the last plant (part 1). Activate the simple plants using a pattern (part 2). Find the best pattern (part 3).

I had a function to calculate the so called energy for each plant, because I used that code a lot. In part 1 call that function once. In part 2 call it for each pattern. Part 3… For the example data, I could simply try all patterns. But for the notes, a little analysis was required. It turned out, that some simple plants, if activated, would always drag the quality of the pattern down. So, turn on the rest, and boom! Best pattern.

. .......#....#..#........#...#.↑.↑.↑.↑.↑.#.......
9 .......#....#..#...↑....#....↑.↓.↓.↓.↓.↓........
8 ............#..#..↑.↓...#...↑...........↓.......
7 .......↑....#....↑...↓..#..↑............#.......
6 ......↑#↓...#...↑.....↓...↑.............#.......
5 .....↑.#.↓..#..↑.......↓.↑..............#.......
4 ....↑..#..↓.#.↑#........↓...#...........#.......
3 ...↑...#...↓.↑.#............#...........#.......
2 ..↑....#....↓..#............#...........#.......
1 .↑.....#.......#............#...........#.......
↑ S......#.......#........#...#...........#.......

Quest 19. Numbers describe the walls (or rather, the holes in the walls) in a chamber. A rule describes how a duck might fly through the chamber, using the holes. Some of the flight will be flaps upward. Count the flaps (part 1). A wall might have more than 1 hole, find the flight with the lowest number of flaps (part 2 and 3).

There’s recursion involved, because there’s each choice for flap or not flap + the rest of the flight. For small data, trying all choices works fine. For large data… I have a list of the holes. I can calculate the best way to get from a hole to the next. It was fiddly to get this one right. But it’s important to learn. Using sparse data instead of the complete map is a good technique.

T#TTT###T##
.##TT#TT##.
..T###T#T..
...##TT#...
....T##....
.....#.....

Quest 20. A map shows an area with some trampolines. Count pairs of trampolines (part 1). Given 2 points, find the shortest path, jumping between trampolines (part 2). Do it again, but the area is rotating (part 3).

Oh yes. The rotating triangle. But first. Part 1 is very much about interpreting the map correctly. In the top left corner, “T#T” shows a “T#” pair and a “#T” pair. That “#” is also in a pair with a “#” below it, but the “T” on the right is not in a pair with anything below it. Part 2: Convert a Dijkstra to take these pairs into account. Part 3: Implement the rotation. I chose to rotate the jumper. Jump up here, come down there. (Took forever to get right! Better model next time!) And if I come down there, which pairs are available? Wrinkle: I might in essence jump up and down in place. Also, for part 3 I had a more standard graph for Dijkstra. The rotation? Just look at it.

$mn1 = floor($x / 2);
$mn2 = $x % 2;
$m = $mn1 + $mn2;
$n = $mn1;

$op1 = floor($y / 2);
$op2 = $y % 2;
if($mn2 == 0) {
	$o = $op1 + $op2;
	$p = $op1;
} else {
	$p = $op1 + $op2;
	$o = $op1;
}

$new_x = $M - 1 - $n + 2 * $o + $p;
$new_y = $M - 1 - $m - $o;
return [$new_x, $new_y];

I’ve done Everybody Codes, back in November.

The Song of Ducks and Dragons [ 2025 ]

All my code is available .

 Step 1 [1,2]    Step 2 [2,3]    Step 3 [3,4]    Step 4 [4,5]    Step 5 [5,6]
  1 2 3 4 5 6     1 2 3 4 5 6     1 2 3 4 5 6     1 2 3 4 5 6     1 2 3 4 5 6
  * * * * * *     * * * * * *     * * * * * *     * * * * * *     * * * * * *
  *(*)  * * *     *  (*)* * *     *   * * * *     *   * * * *     *   * * * *
  *     * * *     *     * * *     *     * * *     *     * * *     *     * * *
  *     * * *     *     * * *     *     * * *     *     * * *     *     * * *
  *       * *     *       * *     *       * *     *       * *     *       * *
  *       * *     *       * *     *       * *     *       * *     *       * *
  *       *       *       *       *       *       *       *       *       *(*)
  *       *       *       *       *       *       *       *       *       *
          *               *               *               *

Quest 11. Given a list of numbers, interpret them as columns of ducks. A column will check whether the next columns has fewer birds, and if so, move a duck. This happens to all columns. And until no more moves are possible. Then the check goes the other way. The result is a balanced set of columns. Do this for 10 rounds (part 1). Or until balanced (part 2 and 3).

For part 1 and 2, the hardest part was probably to understand what was going on. For part 3… There is a shortcut. I’ve written about why it works. I made a video! Anyway, once the shortcut was in place, it was, again, easy.

989601     989601     989601     989601     989601     989601     989601
857782     857782     857782     857782     857782     857782     857782
746543     746543     746543     746543     746543     746543     746543
766789     766789     766789     766789     766789     766789     766789

Quest 12. Given a map of numbers and a starting point, add numbers to the group of points by adding numbers that are less than or equal to an already added numbers. Do this until no more can be added (part 1). Again with 2 starting points (part 2). Again, with 3 starting points chosen for maximum effect (part 3).

A bit fiddly, but straightforward. In part 3 it turned out to be important, that a good starting point was also a local maximum. If a < b, a can’t set b on fire.

72
58
47
61
67

Quest 13. Given a list of numbers, construct a dial and turn it 2025 times (part 1). Given a list of intervals, construct a dial and turn it 20252025 times (part 2). Again, but 202520252025 times.

In part 3 the numbers got too big. It was important not to construct the whole dial as an array. So, only note beginnings and ends of intervals.

 Round 1     Round 2     Round 3     Round 4     Round 5
  .#.#..      .###..      #.#.#.      #####.      ..###.
  ##.##.      #.####      ###.##      ...##.      ##.###
  #.#...      #..###      #.#.##      .#..#.      .#.#.#
  ....##      ##...#      .#..#.      ##.##.      .#.###
  #.####      #.#.#.      #..#.#      .####.      #...#.
  ##..#.      ...#..      ###.#.      .###.#      .#...#

Quest 14. A map of tiles. In a game of life way, determine which tiles will be active in the next round. Run some rounds (part 1 and 2). Run a lot of rounds, noting when a certain pattern matches (part 3).

The interesting bit is part 3. Run a few rounds, and keep track of repetitions. Then calculate the rest of the rounds instead of actually going through them. A few interesting questions like how to represent the tiles in a manageable way when recording “I have seen this before”, and then the actual math at the end, trying very hard not to get any off by 1 errors.

 start             R3              R4              L3
 S               S###            S###            S###
                                    #               #
                                    #               #
                                    #               #
                                    #               ####
                      

Quest 15. Given a list of instructions about how to walk (turn right and walk 3, turn right again and walk 4…), interpret the walked segments as walls and find the shortest path from start to end (part 1-3).

Dijkstra! And then in part 3, it was necessary to not just build the whole map. Similar to day 13, only build the interesting bits. This was fiddly! A lot of small steps, a lot of testing and correcting errors.