S2T2 | Solving Sunday Times Teasers

Recent Updates Toggle Comment Threads | Keyboard Shortcuts

Jim Randell 11:08 am on 5 June 2026 Permalink | Reply
Tags: by: Graham Smithers ( 86 )
Teaser 2432: [Alphametic TIME]
From The Sunday Times, 3rd May 2009 [link]

I started with an addition sum and then consistently replaced digits by letters, with different letters used for different digits. This gave me the (very reasonable) result:

TIMES = A + GOOD + READ

Furthermore, I then glanced at my 24-hour digital clock and noticed that the same substitution for the four digits shown would make the display equal to TIME.

What was the time?

This puzzle was originally published with no title.

[teaser2432]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Ruud and Jim Randell are discussing. Toggle Comments
- Jim Randell 11:09 am on 5 June 2026 Permalink | Reply
  Here is a solution using the [[ SubstitutedExpression.split_sum ]] solver from the enigma.py library.
  
  It runs in 116ms. (Internal runtime of the generated code is 2.5ms).
```
#! python3 -m enigma -rr

SubstitutedExpression.split_sum

"A + GOOD + READ = TIMES"

--extra="TI < 24"
--extra="ME < 60"

--answer="TIME"
```
  Solution: The time was: 15:30 (i.e. 3:30 pm).
  
  The sum is one of:
  
  TIMES = A + GOOD + READ
  15304 = 6 + 8229 + 7069
  15304 = 6 + 7229 + 8069
  
  Both of which give TIME = 1530.
  
  G and R are 7 and 8 in some order, and the values of the other letters are fixed.
  
  LikeLike
- Ruud 1:47 pm on 5 June 2026 Permalink | Reply
```
import peek
import istr

for ti, m, e in istr.product(range(10, 24), range(6), range(10)):
    if (time := ti | m | e).all_distinct():
        rest = set(istr.digits()) - set(time)
        for s, a, g, o, d, r in istr.permutations(rest, 6):
            if a and g and r and (times := time | s) == a + istr(":=good") + istr(":=read"):
                peek(time, times, a, good, read)
```
  LikeLike
Reply Cancel reply
Required fields are marked *

Name *

Email *

Website

Notify me of new comments via email.
Notify me of new posts via email.
Δ
Jim Randell 8:20 am on 3 June 2026 Permalink | Reply
Tags: by: Nick MacKinnon ( 59 )
Teaser 2431: [Football league]
From The Sunday Times, 26th April 2009 [link]

Teams A, B, C… (up to some letter) play in a football league. Last season, they finished in alphabetical order. This season, the league consisted of the same teams, but last season’s losers were the champions, and B finished below C, but not in the bottom three. One third of the teams finished higher this season than last; no two moved the same number of places. So, if one team went up four places, no other team will have gone up or down by four places. In particular, just one team had the same position in both seasons.

Starting with the champions, list the order of the teams this season.

This puzzle was originally published with no title.

[teaser2431]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell and John Crabtree are discussing. Toggle Comments
- Jim Randell 8:21 am on 3 June 2026 Permalink | Reply
  If exactly one third of the teams moved up, then the number of teams must be divisible by 3, and if they are each allocated a letter of the alphabet there can be no more than 26.
  
  B finished below C, but not in the bottom three teams, so there must be at least 5 teams.
  
  So the possible number of teams is: 6, 9, 12, 15, 18, 21, 24.
  
  This Python program looks for the smallest possible number of teams.
  
  It labels the teams from 1 .. n, so last year’s position is the same as the label. It then tries all possible allocations for this year’s positions, and checks to see if all the conditions are met.
  
  It runs in 126ms. (Internal runtime is 55ms).
```
from enigma import (
  Enumerator, irange, subsets, multiset, compare, update,
  diff, str_upper, item, join, map2str, printf
)

# check that pos: map team -> position satisfies the requirements
def check(n, pos):
  # for each team collect the up/down and the gap
  (updown, gap) = (multiset(), multiset())
  for (k, v) in pos.items():
    d = k - v
    updown.add(compare(d, 0))
    gap.add(abs(d))
  # ups = n/3, non-movers = 1, no duplicate gaps
  return (updown.count(1) * 3 == n and updown.count(0) == 1 and not gap.is_duplicate())

# solve for teams 1 .. n (= A .. ?)
def solve(n):
  # choose values for teams B and C (1 < C < B < n - 2)
  for (C, B) in subsets(irange(2, n - 3), size=2):
    pos1 = { n: 1, 2: B, 3: C }
    # allocate the remaining positions
    ks = diff(irange(1, n), pos1.keys())
    for vs in subsets(diff(irange(1, n), pos1.values()), size=len, select='P'):
      pos = update(pos1, ks, vs)
      if check(n, pos):
        yield pos

# consider multiples of 3
for n in irange(6, 24, step=3):
  sols = Enumerator(solve(n))
  for pos in sols:
    # construct the order of the teams
    order = tuple(str_upper[k - 1] for (k, v) in sorted(pos.items(), key=item(1)))
    # output solution
    printf("{n} teams -> {order} [pos = {pos}]", order=join(order), pos=map2str(pos))
  # stop at first n with solutions
  if sols.count > 0: break
```
  Solution: The order of the teams (first to last) is: I, H, G, C, B, F, E, A, D.
  
  Fortunately the solution occurs with 9 teams, because this approach gets much slower as the number of teams increases. (I used a more sophisticated version of this approach to check teams up to 18, but it would take too long to check 21 and 24).
  
  LikeLike
  - Jim Randell 4:37 pm on 5 June 2026 Permalink | Reply
    Here is a solution that uses the exact multiset cover solver [[ mcover() ]] from the enigma.py library to consider situations with 6 – 24 teams.
    
    For each team and possible position it constructs a set of tokens giving the team name, the position, the amount of movement, the direction of movement.
    
    So, for example in the situation with 9 teams, team I has only one possible position (it must end up first), so we add the following candidate:
    
    I1 → { I, p1, g8, + }
    
    The other teams have multiple candidates, so for Team D,we add candidates like this:
    
    D2 → { D, p2, g2, + }
    D3 → { D, p3, g1, + }
    D4 → { D, p4, g0, 0 }
    D5 → { D, p5, g1, − }
    …
    D9 → { D, p9, g5, − }
    
    Once all the candidates are set up we use the [[ mcover() ]] solver to find a set of team/positions that give: 1 of each team, 1 of each position, 1 of each gap, n/3 teams moving up, 1 team staying in the same position, the rest of the teams moving down.
    
    The program is able to check all situations with 6 – 24 teams in 9.3s, and verifies that the result given above is the only solution.
```
from enigma import (
  irange, multiset, mcover, compare, ediv,
  str_upper, sprintf as f, map2str, printf
)

# solve the puzzle for n teams
def solve(n):

  # values are:
  #   A .. n  = team name
  #   p1 .. pn  = 1st - nth position this year)
  #   g0 .. g{n - 1}  = positions moved (abs)
  #   +|-|0  = up/down/same
  #
  # then we need to find values that give us:
  #   1 of each team
  #   1 of each position
  #   1 of each gap value
  #   n/3 up, 1 same, rest down

  # construct the map of <team>+<pos> -> <values>
  m = dict()
  def value(k, p, g, s): m[f("{k}{p}")] = multiset.from_seq([k, f("p{p}"), f("g{g}"), s])
  # last team (= team n) must move from last to pos 1
  k = str_upper[n - 1]
  value(k, 1, n - 1, '+')

  # fill out possible positions for teams A .. n-1
  for i in irange(1, n - 1):
    k = str_upper[i - 1]
    # team B cannot finish if the bottom 3 (not team C in the bottom 4)
    M = (n - 4 if k == 'C' else n - 3 if k == 'B' else n)
    for g in irange(-(n - 2), +(n - 2)):
      p = i + g
      if not (p < 2 or p > M):
       value(k, p, abs(g), compare(g, 0, vs="+0-"))

  # set up the target multiset:
  tgt = multiset()
  # each team appears once
  tgt.update_from_seq(str_upper[k - 1] for k in irange(1, n))
  # each position is occupied once
  tgt.update_from_seq(f("p{i}") for i in irange(1, n))
  # each gap is occupied once
  tgt.update_from_seq(f("g{i}") for i in irange(0, n - 1))
  # n/3 ups; 1 non-mover; the rest are down
  k = ediv(n, 3)
  tgt.update_from_dict({'+': k, '0': 1, '-': n - (k + 1)})

  # reject situations where B is higher up the table than C
  def reject(ss):
    d = dict((x[0], int(x[1:])) for x in ss)
    try:
      if d['B'] < d['C']: return True
    except KeyError:
      pass
    return False

  # find exact covers
  for ss in mcover(m, tgt, reject):
    # record teams by their position
    d = dict((int(x[1:]), x[0]) for x in ss)
    # output teams in order
    printf("{n} teams -> {d}", d=map2str(d, enc=""))

# consider possible numbers of teams
for n in irange(6, 24, step=3):
  solve(n)
```
    It we stop looking after the first solution is found (like my first program) the internal execution time is only 2.6ms.
    
    LikeLiked by 1 person
- John Crabtree 1:49 pm on 4 June 2026 Permalink | Reply
  
  Let there be 3n teams.
  The maximum number of places gained is (3n – 1) + (3n – 3) + …(n + 1) with n terms.
  The minimum number of places lost is (3n – 2) + (3n – 4) + …(n) + sum[0 to (n -1)].
  And so n >= n(n-1)/2, ie n<=3
  If n = 1 or 2, the sum of the changes in places is odd. And so n = 3, with places gained = places lost = 18.
  The changes in the places are then forced: champions I up 8 to 1; H up 6 to 2; G up 4 to 3; A (not B) down 7 to 8; D (not B or C) down 5 to 9; B down 3 (max) to 5 and C down 1 to 4; E down 2 to 7; and F stays at 6.
  
  LikeLike
Jim Randell 7:51 am on 31 May 2026 Permalink | Reply
Tags: by: Stephen Hogg ( 65 )
Teaser 3323: Planet 9 from outer space
From The Sunday Times, 31st May 2026 [link] [link]

T’zer was the ninth planet of the Sol-Vit system. Over time, astronomers on T’zer observed each of the eight innermost planets when the lines from the sun to the planet and the planet to T’zer were perpendicular. Radar showed the eight T’zer-to-planet distances at these positions were different whole numbers of light-chrons.

Simultaneously, measuring the angle between the sun’s centre and the planet, they then calculated each planet’s distance from the sun (they were all whole numbers of light-chrons).

T’zer’s calculated distance from the sun was always the same whole number of light-chrons due to its circular orbit.

Astrologers grumbled about this latter distance being under the 80 light-chrons used, historically, when producing horoscopes.

What is T’zer’s distance from its sun (in light-chrons)?

[teaser3323]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Ruud and Jim Randell are discussing. Toggle Comments
- Jim Randell 7:52 am on 31 May 2026 Permalink | Reply
  When the distances are measured, T’zer (T), the planet (P), and the sun (S) form a right-angled triangle, where all distances are whole numbers of light-chrons, and the distance ST forms the hypotenuse of the triangle.
  
  Using the [[ pythagorean_triples() ]] function from the enigma.py library allows us to get a very fast solution.
  
  The following Python program runs in 70ms. (Internal runtime is 95µs).
```
from enigma import (defaultdict, pythagorean_triples, printf)

# collect possible SP distances by ST distance
d = defaultdict(set)
for (x, y, z) in pythagorean_triples(79):
  d[z].update({x, y})

# look for ST distances with (at least) 8 values
for (k, vs) in d.items():
  if len(vs) >= 8:
    printf("{k} -> {vs}", vs=sorted(vs))
```
  Solution: [To Be Revealed]
  
  LikeLike
- Ruud 3:23 pm on 31 May 2026 Permalink | Reply
```
import math
import itertools

for c in range(10, 80):
    if len(sol := [b for b in range(1, c) if (a := math.sqrt(c * c - b * b)) == int(a)]) >= 8:
        print("T-zer:", c, "; others:", *sol)
```
  LikeLike
Jim Randell 8:15 am on 29 May 2026 Permalink | Reply
Tags: by: Graham Smithers ( 86 )
Teaser 2435: [Swimming across the river]
From The Sunday Times, 24th May 2009 [link]

Philip, the fastest swimmer, was on one bank of the River Times; Beth and Sam were directly opposite him on the other bank. Simultaneously, each of them started to swim at their own steady speed to the opposite bank, then, without pause, back to where they had started. On each stretch, Philip crossed each of the others once, and he noted the distances to the nearer bank on each occasion. These four distances were all different whole numbers of metres between 10 and 15, inclusive.

How wide was the river?

This puzzle was originally published with no title.

[teaser2435]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Frits and Jim Randell are discussing. Toggle Comments
- Jim Randell 8:16 am on 29 May 2026 Permalink | Reply
  Consider Philip (starting from the far bank) and one of the other swimmers (starting from the near bank). They set off at the same time, and as Philip is the stronger swimmer, he encounters the other swimmer a distance a from the near bank. They have been swimming for the same amount of time, so the ratio of the swimming speeds is:
  
  P/Q = (x − a) / a
  
  As the stronger swimmer, Philip makes the turn first, and then passes the other swimmer for a second time at a distance b from the far bank (b < a). This time we get:
  
  P/Q = (2x − b) / (x + b)
  
  Equating these ratios gives:
  
  (x − a) / a = (2x − b) / (x + b)
  (x − a)(x + b) = a(2x − b)
  (x² + bx − ax − ab = 2ax − ab
  x² = (3a − b)x
  x = 3a − b
  
  So, we can choose a pair of values (a, b) (given 10 ≤ a < b ≤ 15) and calculate the corresponding value x (which is the width of the river).
  
  And we then need to find two disjoint pairs that give the same value for the width of the river.
  
  This Python program runs in 68ms. (Internal runtime is 81µs).
```
from enigma import (defaultdict, irange, subsets, union, printf)

# record pairs by calculated width
d = defaultdict(list)

# consider possible pairs of distances
for (b, a) in subsets(irange(10, 15), size=2):

  # calculate the width of the river = x
  # (x - a)(x + b) = (2x - b)a
  # => x = 3.a - b
  x = 3*a - b
  # check b < x / 2
  if x < 2 * b: continue
  d[x].append((a, b))
  printf("[({b}, {a}) -> x={x}]")

# look for 2-different, disjoint pairs
for (x, ps) in d.items():
  for (p1, p2) in subsets(ps, size=2):
    if len(set(p1 + p2)) != 4: continue
    # output solution
    printf("x={x} -> p1={p1} p2={p2}")
```
  Solution: The river is 32 m wide.
  
  The pairs of distances are (14, 10) and (15, 13).
  
  And the ratios of the speeds are 15/17 (≈ 0.882) and 7/9 (≈ 0.778).
  
  Other widths that give multiple pairs are:
  
  x=29 → (13, 10) and (14, 13)
  x=31 → (14, 11) and (15, 14)
  
  But these cannot give two disjoint pairs.
  
  LikeLike
- Frits 12:11 pm on 2 June 2026 Permalink | Reply
```
we are looking for 2 pairs (a, b) and (c, d) with a > b and c > d
and we assume a < c.

we have river width = 3a - b = 3c - d or 3.(c - a) = d - b
as d - b <= 5 (c - a) must be 1 and (d - b) must be 3 which leads to
pairs (a, b) and (a + 1, b + 3)
also a + 1 > b + 3 or a > b + 2, as a may not be equal to b + 3 
we have a >= b + 4, as a <= 14 and b >= 10 we see that a = 14, b = 10
leading to pairs (14, 10) and (15, 13) with river width = 3.14 - 10 = 32
```
  LikeLike
Jim Randell 10:35 am on 27 May 2026 Permalink | Reply
Tags: by: C Higgins ( 39 ), by: H Bradley ( 39 )
Teaser 2434: [Metal box]
From The Sunday Times, 17th May 2009 [link]

In metalwork class, Pat was given a thin tin sheet, the shape of a regular polygon, each of whose sides was a two-digit number of centimetres. By sawing and discarding an identical piece from each corner, and doing some folding, he made an open-topped box. Its base was a similar-shaped polygon to the original piece, with vertical sides.

Pat had chosen the size of the discarded pieces to maximise the volume of the box: a six-figure number of cubic centimetres. That number, written as dd/mm/yy, was his grandfather’s date of birth.

What was the volume of the box?

This puzzle was originally published with no title.

[teaser2434]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 10:35 am on 27 May 2026 Permalink | Reply
  This Python program considers possible n-gons for n = 3 .. 10, and possible 2-digit side lengths. And looks for viable combinations where the maximum volume is a recognisable 6-digit date.
  
  It runs in 94ms. (Internal runtime is 25ms).
```
from math import (tan, pi)
from enigma import (irange, fdiv, polygon_area_regular, cproduct, find_max, snapf, nsplit, printf)

# calculate volume of a box, starting with a regular n-gon
# with side <x>, and then make a box by measuring <y> from
# each corner and cutting off a quadrilateral from each corner
def vol(n, x, y):
  # the area of the base = A
  A = polygon_area_regular(n, x - 2*y)
  # height of the sides = z
  t = pi * fdiv(n - 2, 2 * n)
  z = y * tan(t)
  # volume
  return A * z

# consider possible n-gons and possible 2-digit sides (= x)
for (n, x) in cproduct([irange(3, 10), irange(10, 99)]):

  # maximise the volume (= V)
  r = find_max((lambda y: vol(n, x, y)), 0, 0.5 * x)
  # volume is close to a 6-digit integer
  V = snapf(r.fv, t=1e-4, default=None)
  # V should be recognisable as a 6-digit date (dd/mm/yy)
  if V is None or V < 100000: continue
  (dd, mm, yy) = nsplit(V, k=3, base=100)
  if not (0 < dd < 32 and 0 < mm < 13): continue
  y = r.v

  # output solution
  printf("n={n} x={x} -> y={y:.4f} V={V} ({dd:02d}/{mm:02d}/{yy:02d})")
```
  Solution: The volume of the box is 140625 cm³ .
  
  So the grandfather’s DOB is 14/06/25 (14th June 1925).
  
  The original sheet of metal was a hexagon (6-gon) with a side length of 75 cm.
  
  Cuts perpendicular to the sides at a distance 12.5 cm from each corner are made to produce a hexagonal base with side length 50 cm (area = 3750 √3 cm²) and six rectangular sides with height 12.5 √3 cm.
  
  The volume of the box is then: (3750 √3) × (12.5 √3) = 3750 × 12.5 × 3 = 140625.
  
  LikeLike
  - Jim Randell 3:30 pm on 28 May 2026 Permalink | Reply
    Using some analysis:
    
    The equation for the volume is:
    
    V(n, x, y) = (1/4) n y (x − 2y)² cot²(𝝅/n)
    
    And, for a fixed n and x this is at a maximum when:
    
    y = x/6
    
    hence:
    
    V = (1/54) n x³ cot²(𝝅 / n)
    
    And for an integer volume the cot²(𝝅/n) part (= c) must be rational, restricting the value of n to one of the following:
    
    n = 3 → c = 1/3
    n = 4 → c = 1
    n = 6 → c = 3
    
    And so we can simplify the program:
```
from enigma import (irange, cproduct, div, cb, nsplit, printf)

# rational (n, cot^2(pi/n)) pairs as (n, p/q)
ncs = {
  3: (1, 3),
  4: (1, 1),
  6: (3, 1),
}

for ((n, (p, q)), x) in cproduct([ncs.items(), irange(10, 99)]):

  # calculate volume V
  V = div(n * cb(x) * p, 54 * q)
  # must be recognisable as a 6-digit date (dd/mm/yy)
  if V is None or V < 100000: continue
  (dd, mm, yy) = nsplit(V, k=3, base=100)
  if not (0 < dd < 32 and 0 < mm < 13): continue

  # output solution
  printf("n={n} x={x} -> V={V} ({dd:02d}/{mm:02d}/{yy:02d})")
```
    LikeLike
Jim Randell 6:53 am on 24 May 2026 Permalink | Reply
Tags: by: Bernardo Recaman ( 7 )
Teaser 3322: Three houses in long lane
From The Sunday Times, 24th May 2026 [link] [link]

My two best friends and I all live along Long Lane, a row of 60 houses numbered consecutively from 1 to 60. I live at number 10, while my two friends have higher house numbers. One day, I was walking from one friend’s house to the other, and I kept my mind busy by adding up all the house numbers that I passed (not including their two house numbers). Thinking about this sum for a while, I realised that it is precisely the product of their two house numbers.

In which two houses do my friends live?

[teaser3322]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Ruud, Jim Randell, and Frits are discussing. Toggle Comments
- Jim Randell 7:02 am on 24 May 2026 Permalink | Reply
  (See also: Enigma 914, Teaser 2994, Enigma 1).
  
  If the friends houses are numbers A and B:
  
  10 < A < B ≤ 60
  
  Then the product A × B is the same as the sum of the house numbers in the interval [A + 1, B − 1].
  
  A simple search suffices to find the answer.
  
  This Python program runs in 70ms. (Internal runtime is 871µs).
```
from enigma import (irange, subsets, printf)

for (A, B) in subsets(irange(11, 60), size=2):
  if A * B == sum(irange(A + 1, B - 1)):
    printf("A={A} B={B}")
```
  But we can convert the O(n²) search into an O(n) one with a bit of analysis:
  
  We have:
  
  AB = (B − 1)B / 2 − A(A + 1) / 2
  ⇒
  2AB = (B − 1)B − A(A + 1)
  
  So we can choose a value for A, and then look for roots of the following quadratic equation in B:
  
  B² − B(2A + 1) − A(A + 1) = 0
  
  The following Python program runs in 72ms. (Internal runtime is 2.7ms).
```
from enigma import (irange, quadratic, printf)

# consider the lower friends number
for A in irange(11, 59):
  # look for possible B values
  for B in quadratic(1, -(2*A + 1), -A*(A + 1), domain='Z'):
    if A < B <= 60:
      printf("A={A} B={B}")
```
  For the small search space of this puzzle, it is no faster.
  
  Solution: The house numbers of the friends are 14 and 35.
  
  The product is: 14 × 35 = 490.
  
  And the sum of the house numbers in the interval [15, 34] is also 490.
  
  LikeLike
  - Jim Randell 9:56 am on 24 May 2026 Permalink | Reply
    With a bit more analysis we can find a family of solutions where the numbers are not limited:
    
    If we suppose there are k houses between A and B (so B = A + k + 1).
    
    Then the sum of the numbers of these k houses is:
    
    S = kA + tri(k) = kA + k(k + 1)/2
    
    And the product of A and B is:
    
    P = A(A + k + 1)
    
    Equating these gives:
    
    k(k + 1)/2 = A(A + 1)
    ⇒
    tri(k) = 2 tri(A)
    
    And if we make the following substitution: X = 2k + 1, Y = 2A + 1 we get:
    
    X² − 2Y² = −1
    
    Which is a form of Pell’s equation [@wikipedia], and there is already code to solve such Diophantine equations in the pells.py library.
    
    The following program finds the first 10 non-negative candidate (k, A, B) values.
```
from enigma import (div, arg, printf)
import pells

(n, i) = (arg(10, 0, int), 0)
for (X, Y) in pells.diop_quad(1, -2, -1):
  k = div(X - 1, 2)
  A = div(Y - 1, 2)
  if k is None or A is None: continue
  B = A + k + 1
  # assert A * B == irange.sum(A + 1, B - 1)
  sol = (10 < A < B <= 60)
  printf("[X={X} Y={Y}] -> k={k} A={A} B={B}{s}", s=(" [*SOLUTION*]" if sol else ""))
  i += 1
  if i == n: break
```
```
% python3 teaser3322pells.py 10
[X=1 Y=1] -> k=0 A=0 B=1
[X=7 Y=5] -> k=3 A=2 B=6
[X=41 Y=29] -> k=20 A=14 B=35 [*SOLUTION*]
[X=239 Y=169] -> k=119 A=84 B=204
[X=1393 Y=985] -> k=696 A=492 B=1189
[X=8119 Y=5741] -> k=4059 A=2870 B=6930
[X=47321 Y=33461] -> k=23660 A=16730 B=40391
[X=275807 Y=195025] -> k=137903 A=97512 B=235416
[X=1607521 Y=1136689] -> k=803760 A=568344 B=1372105
[X=9369319 Y=6625109] -> k=4684659 A=3312554 B=7997214
```
    Only one candidate is in the required range for the puzzle (and is found in 133µs).
    
    The (k, A) pairs form an increasing sequence such that tri(k) = 2 tri(A).
    
    LikeLike
- Ruud 7:22 am on 24 May 2026 Permalink | Reply
```
for a in range(10, 60):
    for b in range(a + 1, 61):
        if (b - a - 1) * (a + b) / 2 == a * b:
            print(a, b)
```
  LikeLike
- Frits 9:12 am on 24 May 2026 Permalink | Reply
```
from math import ceil

# (f2 - f1)^2 = 2.f1^2 + f1 + f2
for f1 in range(11, 60):
  # determine the minimum and maximum of (f2 - f1)
  mn = ceil((f1 * (2 * f1 + 1) + f1 + 1)**.5)
  mx = int((f1 * (2 * f1 + 1) + 60)**.5)
  for f2 in range(mn + f1, min(mx + f1 + 1, 61)):
    if (f2 - f1)**2 == f1 * (2 * f1 + 1) + f2:
      print(f"answer: {f1} and {f2}")
```
  LikeLike
- Ruud 10:43 am on 24 May 2026 Permalink | Reply
  As a one liner:
```
import itertools

print(*[f"{a} {b}" for a, b in itertools.combinations(range(10, 61), 2) if (b - a - 1) * (a + b) / 2 == a * b])
```
  LikeLike

Jim Randell 8:21 am on 22 May 2026 Permalink | Reply
Tags: by: Nick MacKinnon ( 59 )

Teaser 2437: [Spending money]

From The Sunday Times, 7th June 2009 [link]

My granddaughter Madeline has been shopping. When I asked her the prices of the three items she had bought, she said that each cost less than £10, and that the three prices between them used all the digits 1 to 9. Furthermore, the middle-priced item cost one penny less than three times the cheapest, and the total amount spent was a whole number of pounds.

What were the three prices?

This puzzle was incorrectly published as Teaser 2537.

This puzzle was originally published with no title.

[teaser2437]

Jim Randell 8:23 am on 22 May 2026 Permalink | Reply

Here is a solution using the [[ SubstitutedExpression ]] solver from the enigma.py library.

The following run-file executes in 78ms. (Internal runtime of the generated code is 211µs).

#! python3 -m enigma -rr

SubstitutedExpression

# suppose the prices (in pence) are:
#
#  ABC = cheapest
#  DEF
#  GHI = most expensive
#
--digits="1-9"

# the prices are in order
"A < D < G"

# the middle price is 1p less than 3 times the cheapest
"3 * ABC - 1 = DEF"

# the total came to a whole number of pounds (= multiple of 100p)
"(BC + EF + HI) % 100 = 0"

# answer is the 3 prices
--answer="(ABC, DEF, GHI)"

Solution: The prices were: 239p, 716p, 845p.

The total amount spent being 1800p = £18.

LikeLike

ruudvanderham 9:52 am on 22 May 2026 Permalink | Reply

import peek
import istr

set123456789=set(istr.range(1, 10))
for price2 in istr.range(1, 1000):
    price1 = 3 * price2 - 1
    if price2 < 1000 and (price1 | price2).all_distinct():
        for price0 in istr.range(price1 + 1, 1000):
            if set(price0 | price1 | price2) == set123456789 and (price0 + price1 + price2)[-2:]=="00":
                peek(price0, price1, price2, price0 + price1 + price2)

LikeLike

ruudvanderham 1:37 pm on 22 May 2026 Permalink | Reply

Here’s a different (significantly faster) version:

import peek
import istr

set123456789 = set(istr.range(1, 10))
for price2 in istr.range(1, 1000):
    price1 = 3 * price2 - 1
    if price2 < 1000:
        for total in istr.range((price2 + price1 * 2 + 1).ceil(100), 3000, 100):
            price0 = total - price1 - price2
            if price0 >= 1000:
                break
            if set(price0 | price1 | price2) == set123456789:
                peek(price0, price1, price2, price0 + price1 + price2)

LikeLike

Frits 5:22 pm on 2 June 2026 Permalink | Reply

# prices p1 < p2 < p3
for p2 in range(123 * 3 - 1, 876 + 1, 3):
  if len(s3 := set(str(p2))) != 3: continue
  if '0' in s3: continue
  # calculate and check p1
  if len(s6 := set(str(p1 := (p2 + 1) // 3)) | s3) != 6: continue
  if '0' in s6: continue
  # last 2 digits of p3 in order to get a whole number of pounds
  if not (11 < (l2_p3 := 100 - ((p1 + p2) % 100)) < 99): continue
  # different digits
  if not s6.isdisjoint(s2 := set(str(l2_p3))): continue
  # calculate first digit of p3
  if len(f_p3 := set("123456789") - s6 - s2) != 1: continue
  if (p3 := 100 * int(f_p3.pop()) + l2_p3) <= p2: continue
  print(f"answer: {p1}, {p2} and {p3}")

LikeLike

Jim Randell 9:01 am on 20 May 2026 Permalink | Reply
Tags: by: W S Graff-Baker ( 3 ), flawed ( 56 )
Teaser 2418: [Square park]
From The Sunday Times, 25th January 2009 [link]

Our park is square, with sides of length 104 metres. In the centre is a circular garden with a diameter of 38 metres.

When walking around the edge of the garden, I can reach a point that is a whole number of metres from the nearest corner of the park, and is also a whole number of metres from the furthest corner of the park.

What are those two distances?

This puzzle was originally published with no title.

[teaser2418]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 9:02 am on 20 May 2026 Permalink | Reply
  We place the corners of the park at (±52, ±52), and the circle is centred on (0, 0) with a radius of 19.
  
  If the point on the circumference of the circle is (x, y), and the distance to the nearest corner (+52, +52) is a, and the distance to the furthest corner (−52, −52) is b, then we have the following equations:
  
  x² + y² = 19
  (52 − x)² + (52 − y)² = a²
  (52 + x)² + (52 + y)² = b²
  
  And we can eliminate x and y to get:
  
  a² + b² = 4 × 52² + 2 × 19² = 11538
  
  So we can look for two squares that sum to give the required value.
  
  The following Python program runs in 70ms. (Internal runtime is 51µs).
```
from enigma import (
  sq, sum_of_squares, circle_intersect_circle, peek, point_dist, printf
)

S = 4 * sq(52) + 2 * sq(19)
for (a, b) in sum_of_squares(S, 2):
  printf("a={a} b={b} [S={S}]")

  # find one of the intersection points
  p = peek(circle_intersect_circle(((52, 52), a), ((-52, -52), b)), default=None)
  if p is None: continue
  printf("-> p={p}")

  # determine distance to the corners
  for q in [(52, 52), (-52, -52), (-52, 52), (52, -52)]:
    d = point_dist(p, q)
    printf("-> dist to {q} = {d:.6f}")
  printf()
```
  Solution: The distances are 63 m and 87 m.
  
  However there is a problem with this answer.
  
  If we look at the distances to each of the corners, we find that the integer distances are not the distances to the nearest and furthest corners (at least not the nearest and furthest from (x, y)).
  
  (The integer distances are shown in red).
  
  The distances are:
  
  AX = 63 m
  BX = 88.92 m
  CX = 87 m
  DX = 60.26 m
  
  The shortest distance is DX and the longest distance is BX.
  
  But the puzzle can be saved if the radius of the circle is changed from 19 m to 18 m, then the integer distances are 58 m and 90 m, and these are the nearest and furthest distances:
  
  In this case the distances are:
  
  AX = 58 m
  BX = 83.16 m
  CX = 90 m
  DX = 67.44 m
  
  In fact for N = 52 there are solutions when R = 18, 27, 48.
  
  And there are solutions with integer distances that are not the nearest/furthest distances when R = 19, 26, 33, 39, 51.
  
  LikeLike
Jim Randell 6:24 am on 17 May 2026 Permalink | Reply
Tags: by: Colin Vout ( 39 )
Teaser 3321: The more you buy, the more you save
From The Sunday Times, 17th May 2026 [link] [link]

… or so we are often encouraged to believe.

I needed to buy exactly 42 coloured pens and I could buy them in packs of 1, 4, 7, 11 or 17. A pack of 1 cost £2, a pack of 17 cost £23, and the prices of the other packs were whole numbers of pounds. The average price per pen always decreased going to larger packs. Given the prices I was faced with, I found a suitable and unique combination of the packs that gave me the lowest possible total cost, and this involved buying at least one pack of 11.

In ascending order of pack size, how many of each pack did I buy, and what were the pack prices (e.g., 5 at £2 each, 3 at £8 each, etc.)?

[teaser3321]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell, Hugo, and Ruud are discussing. Toggle Comments
- Jim Randell 6:39 am on 17 May 2026 Permalink | Reply
  We can use the more sophisticated [[ Denominations() ]] class from the enigma.py library to solve this puzzle.
  
  The following Python program runs in 70ms. (Internal runtime is 1.6ms).
```
from enigma import (
  Denominations, Accumulator,
  irange, choose, fdiv, dot, singleton, seq2str, fmts, printf
)

# denominations
ds = [1, 4, 7, 11, 17]
# find ways to express 42 using the given denominations
qss = list(Denominations(ds).express(42))

# find prices for 4, 7, 11 packs (cost per item decreases)
(f1, f17) = (fdiv(2, 1), fdiv(23, 17))
fns = [
  (lambda p4: f1 > fdiv(p4, 4) > f17),
  (lambda p4, p7: fdiv(p4, 4) > fdiv(p7, 7) > f17),
  (lambda p4, p7, p11: fdiv(p7, 7) > fdiv(p11, 11) > f17),
]
for (p4, p7, p11) in choose(irange(3, 22), fns):
  ps = (2, p4, p7, p11, 23)

  # find ways to buy exactly 42 for the lowest total cost
  r = Accumulator(fn=min, collect=1)
  for qs in qss:
    t = dot(qs, ps)
    r.accumulate_data(t, qs)
  # there is a single way to achieve the lowest total cost
  # which involves buying at least 1 pack of 11 (index 3)
  (t, qs) = (r.value, singleton(r.data))
  if qs is None or qs[3] < 1: continue

  # output solution
  fmt = lambda vs: seq2str(vs, fn=fmts("2d"), enc="[]")
  printf("total cost = {t}")
  printf("-> packs      = {ds}", ds=fmt(ds))
  printf("-> prices     = {ps}", ps=fmt(ps))
  printf("-> quantities = {qs}", qs=fmt(qs))
  printf()
```
  Solution: 3 at £2 each; 2 at £15 each; 1 at £23.
  
  i.e. the pack prices were:
  
  1-pack = £2 (= £2.00/item)
  4-pack = £7 (= £1.75/item)
  7-pack = £12 (= £1.71/item)
  11-pack = £15 (= £1.36/item)
  17-pack = £23 (= £1.33/item)
  
  And the 42 pens were bought as:
  
  3× 1-pack (= 3 items, £6)
  2× 11-pack (= 22 items, £30)
  1× 17-pack (= 17 items, £23)
  total = 42 items, £59 (avg = £1.40/item)
  
  LikeLike
- Ruud 5:07 pm on 17 May 2026 Permalink | Reply
```
import collections
import itertools

p17 = 23
p1 = 2
for p4 in range(23):
    if not (p17 / 17) < p4 / 4 < (p1 / 1):
        continue
    for p7 in range(23):
        if not (p17 / 17) < p7 / 7 < (p4 / 4):
            continue
        for p11 in range(23):
            if not (p17 / 17) < p11 / 11 < (p7 / 7):
                continue

            n = 42
            c = collections.defaultdict(list)
            for n17 in itertools.count():
                a17 = n - n17 * 17
                if a17 < 0:
                    break
                for n11 in itertools.count():
                    a11 = a17 - n11 * 11
                    if a11 < 0:
                        break
                    for n7 in itertools.count():
                        a7 = a11 - n7 * 7
                        if a7 < 0:
                            break

                        for n4 in itertools.count():
                            a4 = a7 - n4 * 4
                            if a4 < 0:
                                break
                            n1 = a4

                            sum = n17 * p17 + n11 * p11 + n7 * p7 + n4 * p4 + n1 * p1
                            c[sum].append((n1, n4, n7, n11, n17))
            if len(lowest := c[min(c)]) == 1 and lowest[0][3]:
                print(f"total={min(c)} quantities={lowest[0]} prices={p1, p4, p7, p11, p17}")
```
  LikeLike
- Hugo 8:02 am on 24 May 2026 Permalink | Reply
  
  I reckoned two 7-packs at £10 each, one 11-pack at £15, and one 17-pack at £23,
  making £58 in all. Where did I go wrong?
  
  LikeLike
  - Jim Randell 9:04 am on 24 May 2026 Permalink | Reply
    
    For example, with prices of:
    
    1-pack = £2
    4-pack = £7
    7-pack = £10
    11-pack = £15
    17-pack = £23
    
    The lowest possible cost for 42 pens is £58 (as you say).
    
    But there are two ways this minimum price can be achieved:
    
    2× 7-packs (@ £10) = £20
    1× 11-pack (@ £15) = £15
    1× 17-pack (@ £23) = £23
    total (42 items) = £58
    
    1× 1-pack (@ £2) = £2
    1× 7-pack (@ £10) = £10
    2× 17-pack (@ £23) = £46
    total (42 items) = £58
    
    So this cannot be scenario, as there must be only one way to achieve the minimum price.
    
    In fact there are 9 possible sets of prices that allow the condition that the prices per item decreases as the pack price increases. Of these only 3 have a unique way to achieve the minimum price (which, in each case, is £59). And only one of these 3 candidates uses 11-packs in the unique arrangement that achieves the minimum price, and so this provides the answer to the puzzle.
    
    LikeLike
Jim Randell 8:21 am on 15 May 2026 Permalink | Reply
Tags: by: Rupert Segar
Brain teaser 975: Ambiguous birthdays
From The Sunday Times, 29th March 1981 [link]

Recently I attended the Numerical Astrologers Conference, held annually in Brighton. At this meeting, members wore badges on which were written not only their names, but also their dates of birth. These dates were written numerically in the usual English manner of first putting the day, then the month, then the year (e.g. 7th March 1946 would be represented by 7/3/46, and the 31st December 1954 by 31/12/54). The year always uses two digits.

I had just entered the meeting when I was accosted by an internationally acclaimed cabalist, who, I noticed, shared with me the month of his birthday, though he was born in a year eight years prior to the year of my birth. He had been looking at my badge, and now told me that the digits of my date of birth were, in sequence, in exactly the reverse order to his own.

We were eagerly discussing this coincidence when an old acquaintance of mine introduced himself to the cabalist, who then made the same claim to my friend about their dates of birth. At first this puzzled me, as I knew my friend to be younger than myself, but, upon inspection, both the claims proved to be correct.

Strangely, both of us had dates of birth whose digits, when taken in completely the reverse order, were exactly the same as those of the cabalist.

Numerically, what was the cabalist’s date of birth?

The puzzle is included in the book The Sunday Times Book of Brainteasers (1994).

[teaser975]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
ruudvanderham and Jim Randell are discussing. Toggle Comments
- Jim Randell 8:22 am on 15 May 2026 Permalink | Reply
  The cabalist’s DOB cannot be 6 digits or 4 digits, as there is only one way to reverse these:
  
  UV/WX/YZ → ZY/XW/VU
  W/X/YZ → Z/Y/XW
  
  But if it had 5 digits, there are 2 ways it can be reversed:
  
  V/WX/YZ or VW/X/YZ → Z/YX/VW or ZY/X/VW
  
  As the friend is younger than the setter they must be born later in the year, so:
  
  setter = ZY/X/VW
  friend = Z/YX/VW
  
  And the cabalist and the setter share their birth month, so:
  
  cabalist = VW/X/YZ
  setter = ZY/X/VW
  friend = Z/YX/VW
  
  Here is a solution using the [[ SubstitutedExpression ]] solver from the enigma.py library.
  
  It runs in 86ms. (Internal runtime of the generated code is 2.2ms).
```
#! python3 -m enigma -rr

SubstitutedExpression

# convert a 2-digit year
--code="year = lambda y: (1900 + y if y < 70 else 1800 + y)"
# check for a valid date
--code="from datetime import date"
--code="valid = lambda d, m, y: catch(date, year(y), m, d) is not None"

# the cabalist's DOB is VW/X/YZ
# and can be reversed as setter = ZY/X/WV, friend = Z/YX/WV
--distinct=""
--invalid="0,VYZ" # dates do not have components with leading zeros

# check the three dates are valid
"valid(VW, X, YZ)"
"valid(ZY, X, WV)"
"valid(Z, YX, WV)"

# the [2-digit] years are 8 apart
"year(YZ) + 8 == year(WV)"

--template="VW/X/YZ -> ZY/X/WV and Z/YX/WV"
--solution=""
```
  Solution: The cabalist’s date of birth was 12/1/13 (12th January 1913).
  
  And so the setter’s date of birth is 31/1/21 (31st January 1921) and the friend’s date of birth is 3/11/21 (3rd November 1921).
  
  LikeLike
- ruudvanderham 2:01 pm on 15 May 2026 Permalink | Reply
```
import datetime

date0 = datetime.datetime(1880, 1, 1)
date1 = datetime.datetime(1980, 1, 1)

day = {}
month = {}
date = date0
while date < date1:
    date = date + datetime.timedelta(1)
    as_str = f"{date.day}{date.month}{date.year % 100:02d}"[::-1]
    if len(as_str) == 5 and "0" not in as_str[:3]:
        year = int(as_str[3:])
        year += 1800 if year > 80 else 1900
        if year - date.year == 8:
            for i in range(2):
                month[i] = int(as_str[i + 1 : 3])
                day[i] = int(as_str[: i + 1])
                if month == date.month:
                    i_equal = i
                try:
                    datetime.datetime(year, month[i], day[i])
                except ValueError:
                    break
            else:
                for i in range(2):
                    if month[i] == date.month:
                        if datetime.datetime(year, month[i], day[i]) < datetime.datetime(year, month[1 - i], day[1 - i]):
                            print(
                                f"Cabalist: {date:%Y-%m-%d} / Me: {datetime.datetime(year, month[i], day[i]):%Y-%m-%d} / Friend:{datetime.datetime(year, month[1 - i], day[1 - i]):%Y-%m-%d}"
                            )
```
  LikeLike
Jim Randell 8:05 am on 13 May 2026 Permalink | Reply
Tags: by: Des MacHale ( 12 )
Teaser 2417: [Flower bed]
From The Sunday Times, 18th January 2009 [link]

Old Mellors, the estate gardener, has designed a large flower bed. He has marked out two overlapping circles whose radii differ by one metre: the bed consists of the area within one or both of the circles. He wants to plant various straight lines of seeds in the flower bed. The longest such possible is 25 metres long; if he wants the line to touch the perimeter of the bed in three places, then the longest possible is 22 metres.

What are the radii of the circles?

This puzzle was originally published with no title.

[teaser2417]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 8:08 am on 13 May 2026 Permalink | Reply
  If we suppose the circle have radii R and r, where R ≥ r, then:
  
  For the circles to overlap the distance d between their centres must be:
  
  R − r < d < R + r
  
  In this case we have R = r + 1, so:
  
  1 < d < 2r + 1
  
  The longest possible line is 25, so:
  
  R + d + r = 25
  ⇒
  d = 24 − 2r
  
  Hence:
  
  d > 1
  ⇒
  r < 11.5
  
  and:
  
  d < 2r + 1
  ⇒
  r > 5.75
  
  So we have bounds on possible values for r, we can look for situations where the maximum line through an intersection is 22 m.
  
  First I defined some additional 2D geometry functions to help with circles:
```
Circle = namedtuple('Circle', 'centre radius')

# find intersection points of circle <c>
# with the line defined by points <p1>, <p2>
# may return 0, 1, 2 points
def circle_intersect_line(c, p1, p2):
  (((x0, y0), r), (x1, y1), (x2, y2)) = (c, p1, p2)
  (xd, yd) = (x2 - x1, y2 - y1)
  # construct a polynomial for the intersection
  f = sq(Polynomial([x1 - x0, xd])) + sq(Polynomial([y1 - y0, yd]))
  ts = f.roots(sq(r), domain='F')
  return list(P2(x1 + t * xd, y1 + t * yd) for t in ts)

# parameterised circle t = -1 to +1 for a full circle
# 0 = 3 o'clock; 0 -> 1 = anticlockwise to 9 o'clock; 0 -> -1 = clockwise to 9 o'clock
def circle_param(c, t=None):
  ((x, y), r) = c
  f = lambda t, x=x, y=y, r=r: P2(x + r * math.cos(t * pi), y + r * math.sin(t * pi))
  return (f if t is None else f(t))

# find <t> parameter for point <p> on circle centre <c> radius <r>
def circle_param_t(c, p, t=1e-9):
  (o, r) = c
  if not (abs(point_dist(o, p) - r) < t): return None
  ((x0, y0), (x, y)) = (o, p)
  t = math.acos(fdiv(x - x0, r)) / pi
  return min(t, -t, key=(lambda t: abs(point_dist(circle_param(c, t), p))))
```
  (These functions are in the latest version of enigma.py).
  
  The following Python program solves the problem constructively. Given a value for r (the radius of the smaller circle) it first derives the values of R (the radius of the larger circle) and d (the separation between the centres), and then finds P (one of the intersection points of the circle). It then extends the tangent to the smaller circle at P to intersect with the larger circle at Q.
  
  We then look for a point A on the circumference of the larger circle between P and Q, and extend AP to a point B on the smaller circle. And we choose A so to maximise the length of AB (using the [[ find_max() ]] function from the enigma.py library.
  
  We can then use the [[ find_values() ]] function from the enigma.py library to determine what value of r gives a maximum AB of 22.
  
  It runs in 220ms. (Internal runtime is 151ms).
```
from enigma import (
  Circle, circle_intersect_line, circle_param, circle_param_t,
  triangle_point, point_dist, line_param, line_bisect,
  find_max, find_values, call, item, printf
)

# extract leftmost and rightmost points from a sequence
leftmost = lambda pts: (min(pts, key=item(0)) if pts else None)
rightmost = lambda pts: (max(pts, key=item(0)) if pts else None)

# find maximum length line through intersection point P, given <r>
def solve(r):
  # larger circle radius is 1 m larger
  R = r + 1
  # distance between circle centres
  d = 24 - 2*r

  # specify the two circles (centre, radius)
  (CR, Cr) = (Circle((0, 0), R), Circle((d, 0), r))

  # find the upper intersection point = P
  P = triangle_point(d, R, r)
  # and the corresponding start <t> parameter on the larger circle
  tP = circle_param_t(CR, P)

  # calculate the tangent to the smaller circle at P
  f = line_param(Cr.centre, P)
  (p1, p2) = line_bisect(f(0), f(2))
  # and where it intersects the larger circle at Q
  Q = leftmost(circle_intersect_line(CR, p1, p2))
  # and the finish <t> parameter on the larger circle
  tQ = circle_param_t(CR, Q)
  if tQ < tP: tQ += 2

  # points on the larger circle parameterised by <t>
  fR = circle_param(CR)
  # find the A, B intersection points for A at parameter <t>
  def fAB(t):
    # A is on the larger circle
    A = fR(t)
    # the line from A extends through P and intersects the smaller circle at B
    B = rightmost(circle_intersect_line(Cr, A, P))
    return (A, B)
  # find the maximum length AB line for <t> parameters between P and Q
  m = find_max((lambda t: call(point_dist, fAB(t))), tP, tQ)
  # return the maximal value
  return m.fv

# find <r> when the max line through an intersection point is 22
for s in find_values(solve, 22.0, 5.75, 11.5):
  # determine parameters
  r = s.v
  R = r + 1
  d = 24 - 2*r
  printf("r = {r:.2f}; R = {R:.2f}; d = {d:.2f}")
```
  Solution: The radii of the circles are 6.5 m and 7.5 m.
  
  And the distance between the centres of the circles is 11 m.
  
  Manually:
  
  Suppose the centres of the circles are separated by a distance d.
  
  Then we can plot the circles as follows:
  
  centre of the larger circle (radius R) = (0, 0)
  centre of the smaller circle (radius r) = (d, 0)
  upper intersection point of the circles, P = (x, y)
  
  We can draw a straight line L through P at an angle of 𝛉.
  
  At a distance t (negative to the left and positive to the right) it has the following parametric equation:
  
  L(t) = (x + t cos(𝛉), y + t sin(𝛉))
  
  The intersection with the larger circle (A) is given when t ≠ 0 and:
  
  (x + t cos(𝛉))² + (y + t sin(𝛉))² = R²
  ⇒
  t = −2(x cos(𝛉) + y sin(𝛉))
  
  So the distance AP is given by:
  
  AP = 2(x cos(𝛉) + y sin(𝛉))
  
  Similarly the intersection with the small circle (B) is given by:
  
  (x + t cos(t) − d)² + (y + t sin(t))² = r²
  ⇒
  t = 2(d cos(𝛉) − x cos(𝛉) − y sin(𝛉))
  
  So the distance BP is given by:
  
  BP = 2(d cos(𝛉) − x cos(𝛉) − y sin(𝛉))
  
  And so the total distance AB is:
  
  AB = 2(x cos(𝛉) + y sin(𝛉)) + 2(d cos(𝛉) − x cos(𝛉) − y sin(𝛉))
  AB = 2d cos(𝛉)
  
  From which we see the distance AB achieves a maximum when 𝛉 = 0 (i.e. when the line is horizontal [*]), and the maximum value is twice the distance between the centres of the circles.
  
  We can now apply this finding to the puzzle.
  
  The maximum length line through the intersection is 22 m, hence the distance between the circles is 11 m.
  
  And the maximum length line between two points on the perimeter of the bed is 25 m.
  
  Hence:
  
  R + d + r = 25
  (r + 1) + 11 + r = 25
  ⇒
  2r = 13
  r = 6.5
  
  And the solution follows.
  
  [*] However, not all configurations permit a horizontal line to be drawn, in which case the maximum length line is given by the tangent to the smaller circle (PQ), with the angle increased infinitesimally to permit the line to intercept the perimeter of the combined shape at 3 distinct points.
  
  For example:
  
  LikeLike
Jim Randell 12:07 am on 10 May 2026 Permalink | Reply
Tags: by: Howard Williams ( 45 )
Teaser 3320: Penblwydd Hapus
From The Sunday Times, 10th May 2026 [link] [link]

I’m now in my thirties and for many years I’ve treated myself to some bottles of beer on my birthday. To compensate for my increasing age, I buy the same number of bottles each year as my age. On my recent birthday, after storing my bottles, I noticed that, on the beer receipt from the supermarket, all of the nine digits 1 to 9 appeared once, and only once, in the number of bottles, the price per bottle in pence and the total cost in pence.

What was the total cost of the beer in pence?

[teaser3320]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Ruud, Tony Smith, Hugo, and 2 others are discussing. Toggle Comments
- Jim Randell 12:20 am on 10 May 2026 Permalink | Reply
  I think the wording on this puzzle could be tightened up a little. (Specifically to clear up: “what constitutes a recent birthday?”, and “how many times can the digit 0 appear?”).
  
  I assumed we are looking for a sum consisting of 9 digits, using each of the digits 1-9 exactly once, but I find multiple solutions. (And if we allow the digit 0 to appear then there are even more solutions).
  
  Using birthdays in the last 5 years, but disallowing 0 digits, I get 3 candidate solutions. If we take “recent birthday” to mean “most recent birthday”, then we can eliminate two of these, so maybe that is what the setter intended.
  
  This Python program runs in 88ms. (Internal runtime is 19ms).
```
from enigma import (irange, inf, nsplit, flatten, printf)

# consider possible ages for a "recent" birthday
for n in irange(26, 39):
  # consider price per bottle
  for p in irange(100, inf):
    # calculate the total cost
    t = n * p
    # find the digits used in the sum
    ds = flatten(nsplit(x) for x in (n, p, t))
    # look for 9 different non-zero digits
    if len(ds) > 9: break
    if 0 not in ds and len(set(ds)) == 9:
      # output solution
      printf("{n} * {p} = {t}")
```
  Solution: The total cost of the beer was 7254p.
  
  If we suppose the “recent birthday” is the setter’s most recent birthday (that perhaps happened within the last few weeks), then the birthday is 30 .. 39, and the only solution using just the 9 digits 1-9 exactly once is:
  
  39 × 186 = 7254
  
  i.e. the beer cost 186p per bottle.
  
  However, if the recent birthday is one of the last (say) 5 (the puzzle text does say the practice has been going on “for many years”), then it could be between 26 .. 39, and this permits the following additional solutions:
  
  27 × 198 = 5346
  28 × 157 = 4396
  
  Also, the puzzle text does not place restrictions on how many occurrences of the digit 0 there may be, so we can get the following reasonable solutions:
  
  27 × 594 = 16038
  36 × 495 = 17820
  39 × 402 = 15678
  
  And if very expensive bottles of beer were purchased there are further solutions with more than one 0 digit, e.g.:
  
  39 × 1284 = 50076
  
  In fact any solution can have the price per bottle and the total price multiplied by 10 to give a further solution if no restrictions are placed on the digit 0.
  
  So, I think the intended puzzle is:
  
  I am now in my thirties. On my most recent birthday I bought a number of identical bottles of beer. That number was the same as my age in years.
  
  The number of bottles, the price per bottle in pence, and the total cost in pence, when taken together comprised 9 different non-zero digits, with each of the digits 1–9 occurring exactly once.
  
  What (in pence) was the total cost of the beer?
  
  This revised puzzle is easily solved directly from the command line using the [[ SubstitutedExpression ]] solver from the enigma.py library:
```
% python3 enigma.py SubstitutedExpression "AB * CDE = FGHI" --digits="1-9" --assign="A,3"
(AB * CDE = FGHI)
(39 * 186 = 7254) / A=3 B=9 C=1 D=8 E=6 F=7 G=2 H=5 I=4
[1 solution]
```
  (The internal runtime of the generated code is 550µs).
  
  LikeLike
- Ruud 6:48 am on 10 May 2026 Permalink | Reply
  It is easy to see that the price should have 3 digits and the total cost 4 digits.
```
import peek
import istr

for age in istr.range(31, 40):
    for rest in istr.permutations({*istr.range(1, 10)} - {*age}):
        if (price := istr.join(rest[:3])) * age == (total := istr.join(rest[3:])):
            peek(age, price, total)
```
  LikeLike
- Frits 11:04 am on 10 May 2026 Permalink | Reply
```
# forbidden unit digits (3 is reserved for the tens digit of the age) 
fb = {0, 3}

# dictionary of price unit digits per n_bottles unit digit
d = {b: {p for p in range(10) if p not in fb and p != b and 
                                (u := (p * b) % 10) not in fb | {b, p}} 
        for b in range(10) if b not in fb}

# the number of bottles (equal to age)
for b in [n for n in range(30, 40) if n % 10 in d]:
  # unit digit
  u = b % 10
  # minimum/maximum price, price/cost should have resp. 3/4 digits
  mn, mx = 124, 9876 // b
  #pr(b, (mn, mx), (b * mn, b * mx), d[u])
  # the price per bottle in pence
  for p in [n for n in range(mn, mx + 1) if n % 10 in d[u]]:
    if '0' in (dgts := set(str(b) + str(p) + str((c := b * p)))): continue
    if len(dgts) == 9:
      print(f"answer: {c}p")
```
  LikeLike
- Hugo 12:29 pm on 12 May 2026 Permalink | Reply
  
  Keeping the pattern AB × CDE = FGHI but without the condition that A = 3, I found
  18 × 297 = 5346
  27 × 198 = 5346
  28 × 157 = 4396
  42 × 138 = 5796
  48 × 159 = 7632
  
  I didn’t try any other patterns, with or without the inclusion of 0.
  No doubt Jim can fill that gap for us.
  
  LikeLike
  - Tony Smith 11:04 am on 13 May 2026 Permalink | Reply
    
    12 x 483=5796
    
    LikeLike
  - Ruud 8:38 am on 14 May 2026 Permalink | Reply
    
    And
    4 x 1738 = 6952
    4 x 1963 =7852
    
    LikeLike
Jim Randell 8:35 am on 8 May 2026 Permalink | Reply
Tags: by: Victor Bryant ( 147 )
Teaser 2441: [Letter grid]
From The Sunday Times, 5th July 2009 [link]

Your task today is to place nine different letters of the alphabet in a 3-by-3 grid.

The letters must include S, A, M, E. You must do this in such a way that, when the letters are given their numerical value (A = 1, B = 2, C = 3, etc.) then each row, column and diagonal of the grid has the same total.

You will find that the other five letters used can swiftly be rearranged into a common word.

What is that word?

This puzzle was originally published with no title.

[teaser2441]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 8:36 am on 8 May 2026 Permalink | Reply
  Here is a solution using the [[ SubstitutedExpression ]] solver from the enigma.py library.
  
  The following run file executes in 92ms. (Internal runtime of the generated code is 10.2ms).
```
#! python3 -m enigma -rr

SubstitutedExpression

# assign values from 1 - 26 to the grid:
#
#   A B C
#   D E F
#   G H I
#
# to make a magic square with sum 3E
--base="27"
--digits="1-26"

# rows sum to 3E
"A + B + C == 3 * E"
"D + F == 2 * E"
"G + H + I == 3 * E"

# cols sum to 3E
"A + D + G == 3 * E"
"B + H == 2 * E"
"C + F + I == 3 * E"

# diags sum to 3E
"A + I == 2 * E"
"C + G == 2 * E"

# required values (S, A, M, E)
"{1, 5, 13, 19}.issubset({A, B, C, D, E, F, G, H, I})"

# remove symmetric arrangements
"A < C" "C < G" "A < I"

--template=""
--answer="ordered(A, B, C, D, E, F, G, H, I)"
```
  The completed grid is:
```
[ C  (3) | U (21) | I  (9) ]      [ S (19) | A  (1) | M (13) ]
[ Q (17) | K (11) | E  (5) ]  ->  [ E  (5) | K (11) | Q (17) ]
[ M (13) | A  (1) | S (19) ]      [ I  (9) | U (21) | C  (3) ]
```
  Each row, column and diagonal has a sum of 33.
  
  And the corresponding letters are: SAME (= 19, 1, 13, 5) + KQIUC (= 11, 17, 9, 21, 3).
  
  Solution: The word is: QUICK.
  
  LikeLike
Jim Randell 8:44 am on 5 May 2026 Permalink | Reply
Tags: by: Robin Nayler ( 17 )
Teaser 2433: [Date of birth]
From The Sunday Times, 10th May 2009 [link]

I was looking at the dates of birth of three of my friends. When written in the format DDMMYY, each date of birth uses six consecutive digits in some order.

Today (just taking each of their ages on their last birthday) the difference between Alex’s age and Bernard’s age is 40 or more, and the difference between Alex’s age and Charlie’s age is 14.

What, in the format DDMMYY, is Charlie’s date of birth?

This puzzle was originally published with no title.

[teaser2433]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 8:45 am on 5 May 2026 Permalink | Reply
  Note that the puzzle was originally set on 10th May 2009.
  
  The first digit of the month can only be 0 (for Jan – Sep) or 1 (for Oct – Dec).
  
  So the consecutive digits can only be 0-5 or 1-6. And if they are 1-6 then the month can only be 12 and then it is not possible for there to be a date in the range 01-31 using digits 3-6, so the digits used must be 0-5.
  
  This Python program runs in 64ms. (Internal runtime is 1.5ms).
```
from datetime import date
from enigma import (irange, subsets, catch, printf)

# date the puzzle was set
dS = date(2009, 5, 10)

# calculate age
def age(dX, dY):
  return (dY.year - dX.year) - ((dY.month, dY.day) < (dX.month, dX.day))

# collect possible dates and ages
ds = set()
for (u, v, w, x, y, z) in subsets(irange(0, 5), size=6, select='P'):
  (d, m, y) = (10*u + v, 10*w + x, 1900 + 10*y + z)
  t = catch(date, y, m, d)
  if t is not None:
    ds.add((t, age(t, dS)))

ss = set()
# consider DOB for A
for (dA, aA) in ds:
  # choose DOB for C
  for (dC, aC) in ds:
    if not (abs(aA - aC) == 14): continue
    # chose DOB for B
    for (dB, aB) in ds:
      if not (abs(aA - aB) >= 40): continue
      printf("[A={dA} ({aA}); B={dB} ({aB}); C={dC} ({aC})]")
      ss.add(dC)

# output solutions
for dC in ss:
  printf("C = {dC:%d%m%y} [{dC}]")
```
  Solution: Charlie’s date of birth is 250341 (25th March 1941).
  
  So Charlie was 68 when the puzzle was set.
  
  Alex was born in 1954, and his date of birth (and age) is one of the following:
  
  23/10/54 (54)
  03/12/54 (54)
  30/12/54 (54)
  
  Whichever it is his age is 54 and he is 14 years younger than Charlie.
  
  Bernard’s date of birth (and age) is one of the following:
  
  25/04/13 (96)
  24/05/13 (95)
  25/03/14 (95)
  23/05/14 (94)
  24/03/15 (94)
  23/04/15 (94)
  
  And he is 94, 95, or 96.
  
  But whichever it is he is at least 40 years older than Alex.
  
  Note: The puzzle only works when set between 25th March 2009 and 22nd May 2009.
  
  LikeLike

Jim Randell 7:57 am on 3 May 2026 Permalink | Reply
Tags: by: Victor Bryant ( 147 )

Teaser 3319: Watch out!

From The Sunday Times, 3rd May 2026 [link] [link]

One January a few years ago I was given a new watch that also displayed the date. It did this by turning two wheels, one with 0-3 on it and the other with 0-9. So, if left running, it displayed in turn 00, 01, 02, … 29, 30, 31, … 39, 00, 01, … . Therefore it needed resetting each month, but I never bothered. The date was correctly displayed when I received the watch but then was incorrect for every other month of that year. However, on my birthday that year the display showed an odd number that was in fact the correct date but with the digits reversed! I had to console myself with the fact that, before the watch was 30 years old, on one occasion my birthday would be correctly displayed!

When is my birthday (day and month)?

[teaser3319]

Jim Randell 8:13 am on 3 May 2026 Permalink | Reply

We only need to consider 4 candidate start years (a leap year, +1, +2, +3).

This Python program runs in 63ms. (Internal runtime is 755µs).

from datetime import (date, timedelta)
from enigma import (irange, repeat, inc, nrev, printf)

# start in year y
def solve(y):
  # look for possible birthdays in the first year
  bds = set()
  # consider odd displays
  n = 1
  for t in repeat(inc(timedelta(days=2)), date(y, 1, 1)):
    if t.year > y: break
    # display must be incorrect for months other than January
    if n == t.day:
      if t.month > 1: return
    elif n == nrev(t.day, 2):
      # display is the reverse of the day
      bds.add((t, n))
    # advance the display
    n = (n + 2) % 40

  # consider birthdays up to 29 years later
  for (t, n) in bds:
    for i in irange(1, 29):
      t1 = t.replace(year=y + i)
      n1 = (n + (t1 - t).days) % 40
      if n1 == t1.day:
        printf("{t} ({n:02d}) -> {t1} ({n1:02d}) [+{i} years]")

# consider 4 candidate years ("a few years ago")
for y in [2020, 2021, 2022, 2023]:
  solve(y)

Solution: Your birthday is 30th August.

The setter was given the watch in a leap year (2020 for example), when it showed the correct date for January (but not in any other months).

On 2020-08-30 the watch displays “03” (instead of “30”). And 28 years later on 2048-08-30 the watch will display “30”.

There are other birthdays in the first year when the watch will display a date that is incorrect, but the actual date reversed:

10th February (displays “01” in any year; displays “10” after 55 years)
10th June (displays “01” in a non-leap year)
31st July (displays “13” in a leap year; displays “31” after 34 years)

LikeLike

Ruud 12:57 pm on 3 May 2026 Permalink | Reply

import datetime
import istr
import calendar

istr.int_format("02")


def display_time(start_date, year, month, day):
    diff = (datetime.datetime(year, month, day) - start_date).days
    return istr((diff + 1) % 40)


for year in (2021, 2022, 2023, 2024):
    start_date = datetime.datetime(year, 1, 1)
    for month in range(2, 13):
        if display_time(start_date, year, month, 1) == 1:
            break
    else:
        for month in range(1, 13):
            for day in range(1, calendar.monthrange(year, month)[1]):
                displayed = display_time(start_date, year, month, day)
                if displayed.is_odd() and day == displayed.reversed() and displayed.reversed() != displayed:
                    correct_years = [year for year in range(year, year + 30) if display_time(start_date, year, month, day) == day]
                    if len(correct_years) == 1:
                        print(year, correct_years[0], month, day)

LikeLike

Jim Randell 4:38 pm on 3 May 2026 Permalink | Reply

@Ruud: Python’s [[ range(a, b) ]] builtin excludes the final value (b in this case). So your code at line 20 will miss checking the final day of the month.

The enigma.py library has the [[ irange(a, b) ]] function, if you want to include both endpoints.

LikeLike

Ruud 4:47 pm on 3 May 2026 Permalink | Reply

Well spotted. It should read

import datetime
import istr
import calendar

istr.int_format("02")


def display_time(start_date, year, month, day):
    diff = (datetime.datetime(year, month, day) - start_date).days
    return istr((diff + 1) % 40)


for year in (2021, 2022, 2023, 2024):
    start_date = datetime.datetime(year, 1, 1)
    for month in range(2, 13):
        if display_time(start_date, year, month, 1) == 1:
            break
    else:
        for month in range(1, 13):
            for day in range(1, calendar.monthrange(year, month)[1] + 1):
                displayed = display_time(start_date, year, month, day)
                if displayed.is_odd() and day == displayed.reversed() and displayed.reversed() != displayed:
                    correct_years = [year for year in range(year, year + 30) if display_time(start_date, year, month, day) == day]
                    if len(correct_years) == 1:
                        print(year, correct_years[0], month, day)

LikeLike

Jim Randell 9:21 am on 1 May 2026 Permalink | Reply
Tags: by: Victor Bryant ( 147 )
Teaser 2445: [Divisible by 9]
From The Sunday Times, 2nd August 2009 [link]

I started with a list of six numbers (with no leading zeros, of course). Five of the six numbers were divisible by 9.

Then I coded the numbers by consistently using letters for digits, with different letters representing different digits.

In this way, the list became:

SETTER
SENT
PRETTY
EASY
SUNDAY
TEASER

Which of those words represented the number that was not divisible by 9?

This puzzle was originally published with no title.

[teaser2445]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Ruud and Jim Randell are discussing. Toggle Comments
- Jim Randell 9:22 am on 1 May 2026 Permalink | Reply
  Here is a straightforward solution using the [[ SubstitutedExpression ]] solver from the enigma.py library.
  
  It runs in 106ms. (Internal runtime of the generated code is 21ms).
```
#! python3 -m enigma -rr

SubstitutedExpression

--distinct="ADENPRSTUY"
--invalid="0,EPST"

# exactly five of the six numbers are divisible by 9
# so just 1 of them isn't, identify it as X = 1..6
--invalid="0|7-9,X"

"(X == 1) == (SETTER % 9 != 0)"
"(X == 2) == (SENT % 9 != 0)"
"(X == 3) == (PRETTY % 9 != 0)"
"(X == 4) == (EASY % 9 != 0)"
"(X == 5) == (SUNDAY % 9 != 0)"
"(X == 6) == (TEASER % 9 != 0)"

--answer="X"

--template="(SETTER) (SENT) (PRETTY) (EASY) (SUNDAY) (TEASER) (X)"
```
  Solution: TEASER is not divisible by 9.
  
  There are 36 ways to assign the digits to the letters, but in all cases TEASER is the odd number out.
  
  If the puzzle had been set so that just one of the words is not divisibly by 29, then there is a single way to assign digits to the letters.
  
  LikeLike
  - Ruud 11:07 am on 1 May 2026 Permalink | Reply
    Brute force reveals that there are 36 different solutions, all resulting in TEASER to be the one that’s not divisible by 9.
```
import peek
import istr

count = 0
for s, e, t, r, n, p, y, a, u, d in istr.permutations(range(10)):
    if s * p * e * t: # may not start with 0
        not_divisible_by_9 = ""
        for name in "setter sent pretty easy sunday teaser".split():
            if not istr(f":={name}").is_divisible_by(9):
                if not_divisible_by_9:
                    break
                not_divisible_by_9 = name
        else:
            if not_divisible_by_9:
                count += 1
                peek(count, not_divisible_by_9, setter, sent, pretty, easy, sunday, teaser)
```
    LikeLike
Jim Randell 9:04 am on 28 April 2026 Permalink | Reply
Tags: by: Alfred Moritz ( 2 )
Brainteaser 1049: A question of colour
From The Sunday Times, 5th September 1982 [link]

A frame at snooker, as every player — and every watcher of “Pot Black” — will know, consists of fifteen red balls, worth one point each, and six “colours”: yellow = 2, green = 3, brown = 4, blue = 5, pink = 6 and black = 7.

The reds must all be potted first: after each red the player chooses a single colour to pot (immediately replaced on the table) before addressing the next red. Any miss (or potting of the wrong colour) causes the other player to have his turn. After the last red has been potted, with an attempt at a colour, all the colours are on the table, and they must be potted in ascending order of value.

The game ends when all the colours have been potted, or earlier if the current player has reached a score that cannot be equalled or exceeded by his opponent. For our present purposes, there are no penalty points or snookers.

Unlike the champions we see on television, Arthur and Bertie recently played a frame which was as undistinguished in quality (though neither actually incurred any penalty points) as it was remarkable in other ways. Each of them potted the same number of balls; the scores were level immediately before Bertie potted the last of the reds; and the winner — Arthur by a single point —was not decided until the table was finally cleared. They then discovered that Arthur’s score was the lowest possible for such a close win.

What was Arthur’s score? Which player potted each of the final six “colours” (e.g. B, B, B, B, B, A).

This puzzle is included in the book The Sunday Times Book of Brainteasers (1994).

[teaser1049]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 9:04 am on 28 April 2026 Permalink | Reply
  We are looking for the lowest possible scores.
  
  The scores are level with 1 red remaining. So 14 of the reds have been potted. For the lowest possible scores the associated colours must have been missed. So each player has potted 7 reds (and no colours) for a total score of 7.
  
  The remaining balls are: the final red, a possible additional colour, and the 6 colours in order.
  
  So, if the table is cleared and each player pots the same number of balls: B pots the final red, and a colour, to put him on 8 + x points (and has now potted 9 balls). So of the 6 remaining colours B pots 2 and A pots 4.
  
  This Python program examines possible ends to the match.
  
  It runs in 70ms. (Internal runtime is 143µs).
```
from enigma import (Enumerator, printf)

colours = [2, 3, 4, 5, 6, 7]

# play the remaining colours
def play(A, B, cols, As=[], Bs=[]):
  # are we done?
  if not cols:
    yield (A, B, cols, As, Bs)
  else:
    rest = sum(cols)
    # has someone won?
    if A > B + rest or B > A + rest:
      yield (A, B, cols, As, Bs)
    else:
      # someone pots the next colour
      x = cols[0]
      yield from play(A + x, B, cols[1:], As + [x], Bs)
      yield from play(A, B + x, cols[1:], As, Bs + [x])

# solve the puzzle, where B pots the final red with colour <x>
def solve(x):
  for (A, B, cols, As, Bs) in play(7, 8 + x, colours):
    # A wins by 1 point
    if not (A == B + 1): continue
    # the table is cleared
    if cols: continue
    # A and B potted the same number of balls
    if not (len(As) == 4 and len(Bs) == 2): continue
    # return the final scores and colours potted
    yield (A, B, As, Bs)

# choose a colour for A to pot with the final red
for x in colours:
  ss = Enumerator(solve(x))
  for (A, B, As, Bs) in ss:
    # output solution
    printf("A pots colours {As}; total = {A} pts")
    printf("B pots final red + {x}; pots colours {Bs}; total = {B} pts")
    printf()
  # we only need the smallest solution
  if ss.count > 0: break
```
  Solution: Arthur’s score was 23. The final six colours were potted as: A, A, A, B, B, A.
  
  The match started with A and B each potting 7 reds and no colours, and then:
  
  → A=7, B=7, [1 red remaining]
  B pots the final red and the green (3)
  → A=7, B=11, [27 points remaining]
  A pots the yellow (2)
  → A=9, B=11, [25 points remaining]
  A pots the green (3)
  → A=12, B=11, [22 points remaining]
  A pots the brown (4)
  → A=16, B=11, [18 points remaining]
  B pots the blue (5)
  → A=16, B=16, [13 points remaining]
  B pots the pink (6)
  → A=16, B=22, [7 points remaining]
  A pots the black (7)
  → A=23, B=22 [final scores]
  
  B has potted 7 + 2 + 2 = 11 balls. And A has potted 7 + 4 = 11 balls.
  
  LikeLike
Jim Randell 6:24 am on 26 April 2026 Permalink | Reply
Tags: by: Andrew Skidmore ( 88 )
Teaser 3318: Squaring the circle
From The Sunday Times, 26th April 2026 [link] [link]

Liam is designing a logo as part of a school project. He has drawn a circle that touches all the sides of an octagon. The side lengths of the octagon are all different two-digit numbers of mm; in fact, they are all triangular numbers (i.e. numbers of the type 1+2+3+4+…). Taken together these numbers use all the digits 0 to 9 (at least once each). If I told you the value of one of the lengths that is an odd number, then you would be able to answer the question below.

What (in mm) is the perimeter of the octagon?

[teaser3318]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell, Brian Gladman, Frits, and 1 other are discussing. Toggle Comments
- Jim Randell 7:01 am on 26 April 2026 Permalink | Reply
  I used the characterisation of a tangential polygon given here [@wikipedia].
  
  Namely:
  
  If the sides are (a0, …, a7), then a tangential octagon exists if and only if the following equation set has positive real solutions for (x0, …, x7):
  
  x0 + x1 = a0
  x1 + x2 = a1
  …
  x7 + x0 = a7
  
  For positive solutions to exist this means:
  
  x0 > 0
  x0 < a0
  x0 > a0 − a1
  x0 < a0 − a1 + a2
  …
  x0 < a0 − a1 + a2 − a3 + a4 − a5 + a6
  x0 > a0 − a1 + a2 − a3 + a4 − a5 + a6 − a7 = 0
  
  So we can bracket possible x0 values by constructing the alternating sum of the candidate side lengths, and then look for non-empty intervals at the end of the process. Any x0 value in this interval will give a viable tangential octagon.
  
  This Python program runs in 68ms. (Internal runtime is 861µs).
```
from enigma import (
  defaultdict, irange, inf, tri, first, lt, div,
  diff, subsets, cproduct, union, nsplit, printf
)

# 2-digit triangular numbers
ns = first((tri(n) for n in irange(1, inf)), count=lt(100), skip=lt(10))

# is there a tangential octagon with sides <ss>?
def is_tangential(ss):
  xs = None
  # for a valid arrangement, the sum of the even numbered sides
  # is the same as the sum of the odd numbered sides
  s = div(sum(ss), 2)
  if s is None: return
  # choose the even numbered sides
  a0 = min(ss)
  ssx = diff(ss, {a0})
  for ss0 in subsets(ssx, size=3, fn=list):
    if a0 + sum(ss0) != s: continue
    # arrange the sides
    ss1 = diff(ssx, ss0)
    for ((a2, a4, a6), (a1, a3, a5, a7)) in cproduct(subsets(xs, size=len, select='P') for xs in [ss0, ss1]):
      if not (a1 < a7): continue
      # bracket possible values for x0 by constructing the alternating sum of the sides
      lo = max(0, a0 - a1, a0 - a1 + a2 - a3, a0 - a1 + a2 - a3 + a4 - a5)
      hi = min(a0, a0 - a1 + a2, a0 - a1 + a2 - a3 + a4, a0 - a1 + a2 - a3 + a4 - a5 + a6)
      # is the bracket non-empty?
      if lo < hi:
        return (a0, a1, a2, a3, a4, a5, a6, a7)

# map odd side lengths to perimeter
d = defaultdict(set)

# choose 8 of the numbers
for ss in subsets(ns, size=8):
  # all 10 digits should be used
  ds = union(nsplit(n) for n in ss)
  if len(ds) < 10: continue
  # is there a tangential octagon?
  rs = is_tangential(ss)
  if rs is None: continue
  # record perimeter by side length
  p = sum(ss)
  printf("[{rs} -> {p}]")
  for n in ss:
    d[n].add(p)

# look for odd side lengths with only one possible perimeter
for n in sorted(d.keys()):
  vs = d[n]
  if n % 2 == 1 and len(vs) == 1:
    printf("{n} -> {vs}")
```
  Solution: The perimeter of the octagon is 358 mm.
  
  There are three candidate sets of sides that permit a tangential octagon to be constructed. Example arrangements for these sets are:
  
  (10, 15, 36, 28, 55, 91, 78, 45) → perimeter = 358
  (10, 21, 36, 28, 45, 55, 91, 78) → perimeter = 364
  (10, 21, 45, 36, 55, 66, 91, 78) → perimeter = 402
  
  (Note that these are not the only arrangements of the sides that permit a tangential octagon to be constructed. For the first and second set there are 20 possible arrangements, and for the third set there are 24. So not all candidate arrangements are viable).
  
  15 only appears in the first of these, and is the only odd valued side that uniquely identifies a candidate (the one with perimeter 358).
  
  There is also one even valued side which only appears in one of the candidates, namely 66, which identifies the candidate with perimeter 402.
  
  LikeLike
  - Jim Randell 11:13 pm on 26 April 2026 Permalink | Reply
    Here is my program modified to use the [[ find_max() ]] solver from the enigma.py library to ensure the equations have a positive solution, and to find the corresponding tangent lengths, which allows candidate tangential octagons to be constructed.
    
    This Python program runs in 69ms. (Internal runtime is 924µs).
```
from enigma import (
  defaultdict, irange, inf, tri, first, lt, div, diff,
  subsets, cproduct, find_max, union, nsplit, printf
)

# 2-digit triangular numbers
ns = first((tri(n) for n in irange(1, inf)), count=lt(100), skip=lt(10))

# is there a tangential octagon with sides <ss>?
def is_tangential(ss):
  # for a valid arrangement, the sum of the even numbered sides
  # is the same as the sum of the odd numbered sides
  s = div(sum(ss), 2)
  if s is None: return
  # choose the even numbered sides
  a0 = min(ss)
  ssx = diff(ss, {a0})
  for ss0 in subsets(ssx, size=3, fn=list):
    if a0 + sum(ss0) != s: continue
    # arrange the sides
    ss1 = diff(ssx, ss0)
    for ((a2, a4, a6), (a1, a3, a5, a7)) in cproduct(subsets(xs, size=len, select='P') for xs in [ss0, ss1]):
      if not (a1 < a7): continue

      # can we solve the equations for positive <x> values?
      def solve(x0):
        x1 = a0 - x0
        x2 = a1 - x1
        x3 = a2 - x2
        x4 = a3 - x3
        x5 = a4 - x4
        x6 = a5 - x5
        x7 = a6 - x6
        return min(x0, x1, x2, x3, x4, x5, x6, x7)

      # look for the maximum smallest <x> value
      r = find_max(solve, 0, a0)
      if r.fv > 0:
        # return viable solution
        return (a0, a1, a2, a3, a4, a5, a6, a7)

# map odd side lengths to perimeter
d = defaultdict(set)

# choose 8 of the numbers
for ss in subsets(ns, size=8):
  # all 10 digits should be used
  ds = union(nsplit(n) for n in ss)
  if len(ds) < 10: continue
  # is there a tangential octagon?
  rs = is_tangential(ss)
  if rs is None: continue
  # record perimeter by side length
  p = sum(ss)
  printf("[{rs} -> {p}]")
  for n in ss:
    d[n].add(p)

# look for odd side lengths with only one possible perimeter
for n in sorted(d.keys()):
  ps = d[n]
  if n % 2 == 1 and len(ps) == 1:
    printf("{n} -> {ps}")
```
    If the equations admit a positive solution, then there are infinitely many, so the program finds the polygon where the closest tangent point to a vertex is as far as possible.
    
    We can then use the data to plot viable tangential octagons for candidate arrangements.
    
    Here are the three viable candidate arrangements, each side of the octagon is shown with its tangent point and side length. (Some of the angles at the vertices are very close to 180°).
    
    LikeLiked by 2 people
- Frits 10:59 am on 26 April 2026 Permalink | Reply
```
from itertools import combinations

# collect possible triangular side lengths
n, t, sides = 0, 0, []
while True:
  t = n * (n + 1) // 2
  if t > 99: break
  if t > 9:
    sides.append(t)
  n += 1

# claim from Google AI:
# a convex octagon with the sum of its odd-numbered sides' lengths equal to  
# the sum of its even-numbered sides' lengths has an inscribed circle.
# thus s1 + s3 + s5 + s7 must be equal to s2 + s4 + s6 + s8

sols = []
# select eight sides of the octagon
for c8 in combinations(sides, 8):
  h, r = divmod(sum(c8), 2)
  if r: continue
  # all digits should be present
  if len(set("".join(str(n) for n in c8))) != 10: continue
  # pick four sides s(i) from <c8> with sum <h>
  c1 = c8[0]
  for c3 in combinations(c8[1:], 3):
    if sum(c3) + c1 != h: continue
    sols.append(c8)
    
# collect possible solutions per odd number
cands = [[s for s in sols if n in s] for n in range(11, 100, 2)]
# select odd numbers that only occur in one solution
sols = [str(sum(vs[0])) for vs in cands if len(vs) == 1]
print("answer:", ' or '.join(sols))
```
  LikeLiked by 1 person
  - Frits 12:02 pm on 26 April 2026 Permalink | Reply
    
    Wikipedia mentions that in a tangential polygon with an even number of sides, the sum of the odd numbered sides’ lengths is equal to the sum of the even numbered sides’ lengths. Google AI claims that the reverse is also true (at least for a convex octagonal).
    
    LikeLike
    - Jim Randell 5:10 pm on 26 April 2026 Permalink | Reply
      
      @Frits: Yes. I can use that condition to reduce the number of side arrangements that are considered by my program. (Although Wikipedia does not claim it is an “if and only if” condition, and I would require a more trustworthy source than Google AI to verify the sufficiency condition).
      
      LikeLike
      - Jim Randell 5:33 pm on 26 April 2026 Permalink | Reply
        
        This paper [link] seems to suggest that the condition is not sufficient for 2n-gons larger than quadrilaterals.
        
        I think a (2, 2, 2, 2, 100, 3, 3, 100) octagon would be a counterexample.
        
        LikeLike
        
        Frits 7:28 pm on 26 April 2026 Permalink | Reply
        
        @Jim, Thanks for debunking the claim.
        I haven’t looked at your program yet (beside the use of Matrix.linear).
        
        Probably you can use your method to check if a sequence of 8 octagon side lengths (with property sum(odd) = sum(even)) has an inscribed circle.
        
        LikeLiked by 1 person
        
        Jim Randell 4:01 pm on 4 May 2026 Permalink | Reply
        
        Instead of attempting to solve the equations (and looking for non-inconsistent sets) I’ve rejigged my program to determine the interval for x0 where the equations give positive x_i values, and if this interval is non-empty then it is possible to construct a tangential octagon using the given side arrangement.
        
        [I am yet to see another solution that checks if a candidate arrangement of sides can actually form a tangential octagon].
        
        LikeLike
- Brian Gladman 10:28 pm on 27 April 2026 Permalink | Reply
  
  @Jim Nice work on the three candidates shapes. The radius of the incircle is 2.A / sum(sides) where A is the polygon’s area but is there a direct route to this radius from the a and x values?
  
  LikeLike
  - Jim Randell 7:58 am on 28 April 2026 Permalink | Reply
    I took the x values determined by my second program, and for a given radius r you can calculate the angles at each vertex of the octagon.
    
    You can then vary r until the sum of the vertex angles is 1080° (or 6𝝅 radians).
    
    I already had a program (written for Teaser 2438) to plot a cyclic polygon (given the angles subtended at the centre by the sides), and then construct a tangential polygon from that.
    
    So I just needed to calculate the angles at the centre of the octagon, these are supplementary to the angles at the vertices.
    
    This is the program I used to plot the diagrams:
```
from math import (atan2, fsum, pi, degrees)
from enigma import (find_value, run, arg, printf)

# possible tangents
xss = {
  1: [6.5, 3.5, 11.5, 24.5, 3.5, 51.5, 39.5, 38.5],  # arrangement 1
  2: [5, 5, 16, 20, 8, 37, 18, 73],  # arrangement 2
  3: [5, 5, 16, 29, 7, 48, 18, 73],  # arrangement 3
}
xs = xss[arg(1, 0, int)]
printf("xs = {xs}")

# calculate vertex angles for radius r
def angles(r): return list(2 * atan2(r, x) for x in xs)

# find radius that gives an angle sum of 6.pi
r = find_value((lambda r: fsum(angles(r))), 6 * pi, 0, 1000).v
printf("inradius = {r}")

# angles at the centre are supplementary to the vertex angles
args = list(degrees(pi - a) for a in angles(r))
run("cyclic-polygon.py", *args)
```
    LikeLiked by 1 person
    - Brian Gladman 8:40 am on 28 April 2026 Permalink | Reply
      
      Thanks Jim, I hoped that you might have found a direct method to avoid the search for the inradius.
      
      LikeLike
    - Frits 9:44 am on 28 April 2026 Permalink | Reply
      
      @Jim, where can we find the program “cyclic-polygon.py”?
      
      LikeLike
      - Jim Randell 11:00 am on 28 April 2026 Permalink | Reply
        
        I’ve uploaded it here [@github].
        
        (Make sure you are running the latest version of enigma.py).
        
        LikeLike
      - Brian Gladman 12:14 pm on 28 April 2026 Permalink | Reply
        
        @Frits, you will also need Jim’s very nice 2D drawing program plot.py
        
        LikeLike
- Ruud 7:55 am on 28 April 2026 Permalink | Reply
  Based on @Frits’s solution:
```
import istr

sides = [i for i in istr.range(10, 100) if i.is_triangular()]

from itertools import combinations

occurs = {istr(i): [] for i in range(10, 100)}
sides = [i for i in istr.range(10, 100) if i.is_triangular()]
for sel_sides in istr.combinations(sides, 8):
    if len(set(istr.join(sel_sides))) == 10:
        for sides3 in istr.combinations(sel_sides[1:], 3):
            if (sel_sides[0] + sum(sides3)) * 2 == sum(sel_sides):
                for i in sel_sides:
                    occurs[i].append(sum(sel_sides))

for i, sum_sides in occurs.items():
    if i.is_odd() and len(sum_sides) == 1:
        print(*sum_sides)
```
  LikeLike
Jim Randell 7:14 am on 24 April 2026 Permalink | Reply
Tags: by: C Higgins ( 39 ), by: H Bradley ( 39 )
Teaser 2444: [Pat’s lawn]
From The Sunday Times, 26th July 2009 [link]

Pat’s lawn is a 600 sq metre rectangle with a tree at each corner. Working around the perimeter, these are apple, beech, cherry and damson. Pat has marked four straight lines on the grass: one from the apple to a point 75% of the way from the beech to the cherry; the second from the beech to 75% of the way from the cherry to the damson; the third from the cherry to 75% of the way from the damson to the apple; the fourth from the damson to 75% of the way from the apple to the beech. He plans to turn the area enclosed by the four lines into a rose garden.

What will the rose garden’s area be?

This puzzle was originally published with no title.

[teaser2444]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 7:15 am on 24 April 2026 Permalink | Reply
  This is similar to Routh’s Theorem but in a rectangle instead of a triangle. (See: Teaser 3021).
  
  If the lines are drawn to a fraction f along the appropriate side, then the area of the central quadrilateral is (as a fraction of the overall parallelogram):
  
  A = (1 − f)² / (1 + f²)
  
  Specifically if f is represented as a fraction a/b we get:
  
  A = (b − a)² / (a² + b²)
  
  And in our case a = 3, b = 4, hence:
  
  A = (4 − 3)² / (3² + 4²)
  A = 1/25
```
from enigma import (Rational, sq, printf)

Q = Rational()

# fraction along the sides
f = Q(75, 100)
printf("[f = {f}]")

# calculate the area of the central quadrilateral
A = Q(sq(1 - f), 1 + sq(f))
printf("[A = {A}]")

# output solution (area of central region)
R = A * 600
printf("area = {R} sq m")
```
  Solution: The area of the rose garden is 24 sq m.
  
  LikeLike
Jim Randell 8:13 am on 22 April 2026 Permalink | Reply
Tags: by: Lachlan MacKinnon, by: Nick MacKinnon ( 59 )
Teaser 2447: [Number grid]
From The Sunday Times, 16th August 2009 [link]

In this variation on a sudoku theme, your task is to find a particular 5-by-5 array of digits in which each row and each column use the same five consecutive digits. When completed, you can read five 5-digit numbers across the rows and a further five down the columns. These 10 numbers should all be different, and their product should be divisible by the fourth powers of 11, 10 and 9. The product should also be divisible by the fourth (but not the fifth) power of 8.

What are the lowest and highest of your 10 numbers?

This puzzle was originally published with no title.

[teaser2447]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 8:14 am on 22 April 2026 Permalink | Reply
  The overall product is divisible by 9^4 (= 3^8), so at least one of the numbers is divisible by 3, and as the numbers are rearrangements of each other, they must all be divisible by 3. (And so the final product will have a divisor of at least 3^10).
  
  We can fill out a grid using the digits 0-4 (allowing leading zeros), and than add the same value (between 0 and 5) to each digit to form a candidate grid.
  
  The sum of the digits 0-4 is 10, and if this combines with 5 copies of the additional digit to give a multiple of 3 then the additional digit can only be 1 or 4.
  
  This is the approach taken with the following run file, using the [[ SubstitutedExpression ]] solver from the enigma.py library.
  
  It executes in 661ms. (Internal runtime of the generated code is 448ms (using PyPy 7.3.21)).
```
#! python3 -m enigma -rr

SubstitutedExpression

#  A B C D E
#  F G H I J
#  K L M N O
#  P Q R S T
#  U V W X Y
#
# and each number is increased by: ZZZZZ

--macro="@rows = ABCDE, FGHIJ, KLMNO, PQRST, UVWXY"
--macro="@cols = AFKPU, BGLQV, CHMRW, DINSX, EJOTY"
--macro="@nums = [@rows, @cols]"

# rows and cols are rearrangements of the same 5 digits
--distinct="ABCDE,FGHIJ,KLMNO,PQRST,UVWXY,AFKPU,BGLQV,CHMRW,DINSX,EJOTY"

# numbers are formed from 5 consecutive digits
# so the numbers in the grid are formed from 0-4
# and the base (Z) is 1 or 4
--digits="0-4"
--invalid="0|2|3,Z"

# the numbers are all different
"seq_all_different(@nums)"

# check divisibility
--code="""
D = mlcm(8**4, 9**4, 10**4, 11**4)  # product is divisible by D
X = 8**5  # but not X
def check(ns, b=0):
  p = multiply(n + b for n in ns)
  return (p % D == 0) and (p % X != 0)
"""
"check(@nums, ZZZZZ)"

# remove duplication
"ABCDE < AFKPU"

--template=""
--denest=-30  # CPython workaround
```
  Solution: The lowest of the numbers is: 45768. And the highest is: 86547.
  
  The prime factors are:
  
  74856 = (2^3)(3)(3119)
  68475 = (3)(5^2)(11)(83)
  86547 = (3)(17)(1697)
  57684 = (2^2)(3)(11)(19)(23)
  45768 = (2^3)(3)(1907)
  
  76854 = (2)(3)(12809)
  48675 = (3)(5^2)(11)(59)
  84567 = (3)(7)(4027)
  57486 = (2)(3)(11)(13)(67)
  65748 = (2^2)(3)(5479)
  
  These combine to give an overall product with the following repeated prime factors:
  
  (2^12)(3^10)(5^4)(11^4)
  
  In the published solution the lowest number was given as 45678, but this is likely to have been a typo.
  
  LikeLike

	Ellen Napier on Teaser 3150: Pyramids of …
	Jim Randell on Teaser 2431: [Football le…
	Ruud on Teaser 2432: [Alphametic …
	Jim Randell on Teaser 2432: [Alphametic …
	John Crabtree on Teaser 2431: [Football le…
	Jim Randell on Teaser 2431: [Football le…
	Frits on Teaser 2437: [Spending mo…
	Frits on Teaser 2435: [Swimming across…

Search

Recent Posts

Recent Comments

Archives

Categories

Subscribe

RSS Links

Site Stats

Meta

Recent Updates Toggle Comment Threads | Keyboard Shortcuts

Jim Randell 11:08 am on 5 June 2026 Permalink | Reply Tags: by: Graham Smithers ( 86 )

Rate this:

Share:

Jim Randell 11:09 am on 5 June 2026 Permalink | Reply

Ruud 1:47 pm on 5 June 2026 Permalink | Reply

Reply Cancel reply

Jim Randell 8:20 am on 3 June 2026 Permalink | Reply Tags: by: Nick MacKinnon ( 59 )

Rate this:

Share:

Jim Randell 8:21 am on 3 June 2026 Permalink | Reply

Jim Randell 4:37 pm on 5 June 2026 Permalink | Reply

John Crabtree 1:49 pm on 4 June 2026 Permalink | Reply

Jim Randell 7:51 am on 31 May 2026 Permalink | Reply Tags: by: Stephen Hogg ( 65 )

Rate this:

Share:

Jim Randell 7:52 am on 31 May 2026 Permalink | Reply

Ruud 3:23 pm on 31 May 2026 Permalink | Reply

Jim Randell 8:15 am on 29 May 2026 Permalink | Reply Tags: by: Graham Smithers ( 86 )

Rate this:

Share:

Jim Randell 8:16 am on 29 May 2026 Permalink | Reply

Frits 12:11 pm on 2 June 2026 Permalink | Reply

Jim Randell 10:35 am on 27 May 2026 Permalink | Reply Tags: by: C Higgins ( 39 ), by: H Bradley ( 39 )

Rate this:

Share:

Jim Randell 10:35 am on 27 May 2026 Permalink | Reply

Jim Randell 3:30 pm on 28 May 2026 Permalink | Reply

Jim Randell 6:53 am on 24 May 2026 Permalink | Reply Tags: by: Bernardo Recaman ( 7 )

Rate this:

Share:

Jim Randell 7:02 am on 24 May 2026 Permalink | Reply

Jim Randell 9:56 am on 24 May 2026 Permalink | Reply

Ruud 7:22 am on 24 May 2026 Permalink | Reply

Frits 9:12 am on 24 May 2026 Permalink | Reply

Ruud 10:43 am on 24 May 2026 Permalink | Reply

Jim Randell 8:21 am on 22 May 2026 Permalink | Reply Tags: by: Nick MacKinnon ( 59 )

Rate this:

Share:

Jim Randell 8:23 am on 22 May 2026 Permalink | Reply

ruudvanderham 9:52 am on 22 May 2026 Permalink | Reply

ruudvanderham 1:37 pm on 22 May 2026 Permalink | Reply

Frits 5:22 pm on 2 June 2026 Permalink | Reply

Jim Randell 9:01 am on 20 May 2026 Permalink | Reply Tags: by: W S Graff-Baker ( 3 ), flawed ( 56 )

Rate this:

Share:

Jim Randell 9:02 am on 20 May 2026 Permalink | Reply

Jim Randell 6:24 am on 17 May 2026 Permalink | Reply Tags: by: Colin Vout ( 39 )

Rate this:

Share:

Jim Randell 6:39 am on 17 May 2026 Permalink | Reply

Ruud 5:07 pm on 17 May 2026 Permalink | Reply

Hugo 8:02 am on 24 May 2026 Permalink | Reply

Jim Randell 9:04 am on 24 May 2026 Permalink | Reply

Jim Randell 8:21 am on 15 May 2026 Permalink | Reply Tags: by: Rupert Segar

Rate this:

Share:

Jim Randell 8:22 am on 15 May 2026 Permalink | Reply

ruudvanderham 2:01 pm on 15 May 2026 Permalink | Reply

Jim Randell 8:05 am on 13 May 2026 Permalink | Reply Tags: by: Des MacHale ( 12 )

Rate this:

Share:

Jim Randell 8:08 am on 13 May 2026 Permalink | Reply

Jim Randell 12:07 am on 10 May 2026 Permalink | Reply Tags: by: Howard Williams ( 45 )

Rate this:

Share:

Jim Randell 12:20 am on 10 May 2026 Permalink | Reply

Ruud 6:48 am on 10 May 2026 Permalink | Reply

Frits 11:04 am on 10 May 2026 Permalink | Reply

Hugo 12:29 pm on 12 May 2026 Permalink | Reply

Tony Smith 11:04 am on 13 May 2026 Permalink | Reply

Jim Randell 11:08 am on 5 June 2026 Permalink | Reply
Tags: by: Graham Smithers ( 86 )

Jim Randell 8:20 am on 3 June 2026 Permalink | Reply
Tags: by: Nick MacKinnon ( 59 )

Jim Randell 7:51 am on 31 May 2026 Permalink | Reply
Tags: by: Stephen Hogg ( 65 )

Jim Randell 8:15 am on 29 May 2026 Permalink | Reply
Tags: by: Graham Smithers ( 86 )

Jim Randell 10:35 am on 27 May 2026 Permalink | Reply
Tags: by: C Higgins ( 39 ), by: H Bradley ( 39 )

Jim Randell 6:53 am on 24 May 2026 Permalink | Reply
Tags: by: Bernardo Recaman ( 7 )

Jim Randell 8:21 am on 22 May 2026 Permalink | Reply
Tags: by: Nick MacKinnon ( 59 )

Jim Randell 9:01 am on 20 May 2026 Permalink | Reply
Tags: by: W S Graff-Baker ( 3 ), flawed ( 56 )

Jim Randell 6:24 am on 17 May 2026 Permalink | Reply
Tags: by: Colin Vout ( 39 )

Jim Randell 8:21 am on 15 May 2026 Permalink | Reply
Tags: by: Rupert Segar

Jim Randell 8:05 am on 13 May 2026 Permalink | Reply
Tags: by: Des MacHale ( 12 )

Jim Randell 12:07 am on 10 May 2026 Permalink | Reply
Tags: by: Howard Williams ( 45 )

Jim Randell 8:35 am on 8 May 2026 Permalink | Reply
Tags: by: Victor Bryant ( 147 )

Jim Randell 8:44 am on 5 May 2026 Permalink | Reply
Tags: by: Robin Nayler ( 17 )

Jim Randell 7:57 am on 3 May 2026 Permalink | Reply
Tags: by: Victor Bryant ( 147 )

Jim Randell 9:21 am on 1 May 2026 Permalink | Reply
Tags: by: Victor Bryant ( 147 )

Jim Randell 9:04 am on 28 April 2026 Permalink | Reply
Tags: by: Alfred Moritz ( 2 )

Jim Randell 6:24 am on 26 April 2026 Permalink | Reply
Tags: by: Andrew Skidmore ( 88 )

Jim Randell 7:14 am on 24 April 2026 Permalink | Reply
Tags: by: C Higgins ( 39 ), by: H Bradley ( 39 )

Jim Randell 8:13 am on 22 April 2026 Permalink | Reply
Tags: by: Lachlan MacKinnon, by: Nick MacKinnon ( 59 )