S2T2 | Solving Sunday Times Teasers

Recent Updates Toggle Comment Threads | Keyboard Shortcuts

Jim Randell 6:00 am on 14 June 2026 Permalink | Reply
Tags: by: John Owen ( 34 )

Teaser 3325: Olive and Don

From The Sunday Times, 14th June 2026 [link] [link]

Olive lives at the southwest corner of a city with a grid of streets (as shown with north at the top). She wants to visit her father Don, who lives at the northeast corner. Olive is trying to work out how many possible routes she can use along the streets, not visiting any intersection more than once, but thinks that there are too many to count. To make the calculation easier, she has decided that she will only travel in the following directions: NW, N, NE, E or SE.

She tells Don the number of possible routes, and he works out that the number is the product of their ages (both of which have two digits).

How old are Olive and Don?

[teaser3325]

Jim Randell 6:17 am on 14 June 2026 Permalink | Reply

This Python 3 program generates all possible paths between O and D using the specified directions. And then factorises the number of paths found into two 2-digit numbers.

It runs in 71ms. (Internal runtime is 7.9ms).

from enigma import (icount, divisors_pairs, printf)

# the grid of intersections is composed of those points (x, y) = [0..6] * [0..4]
# where x and y have the same parity

# possible moves (<delta-x>, <delta-y>) which preserve parity
moves = [
  # parity 0: NW, N, NE, E, SE
  [(-1, +1), (+0, +2), (+1, +1), (+2, 0), (+1, -1)],
  # parity 1: NW, NE, SE
  [(-1, +1), (+1, +1), (+1, -1)],
]

# extend path <vs> to <dst> without revisiting a vertex
def paths(vs, dst):
  (x, y) = vs[-1]
  # are we done?
  if (x, y) == dst:
    yield vs
  else:
    # consider possible moves
    for (dx, dy) in moves[x % 2]:
      v = (vx, vy) = (x + dx, y + dy)
      if not (vx < 0 or vy < 0 or vx > 6 or vy > 4 or v in vs):
        yield from paths(vs + [v], dst)

# count the number of paths between (0, 0) and (6, 4)
n = icount(paths([(0, 0)], (6, 4)))
printf("{n} possible paths")

# factor n into two 2-digit numbers
for (a, b) in divisors_pairs(n):
  if 9 < a < b < 100:
    printf("-> {n} = {a} * {b}")

Solution: [To Be Revealed]

LikeLike

Ruud 11:37 am on 14 June 2026 Permalink | Reply

def search(pos, visited):
    if pos == (6, 4):
        yield 1
    else:
        for dir in ((-1, 1), (1, 1), (1, -1)) if pos[0] % 2 else ((-1, 1), (0, 2), (1, 1), (2, 0), (1, -1)):
            pos_next = tuple(v + d for v, d in zip(pos, dir))
            if pos[0] in range(7) and pos[1] in range(5) and pos_next not in visited:
                yield from search(pos_next, visited | {pos_next})


number_of_routes = sum(search((0, 0), {(0, 0)}))

for olive in range(10, 100):
    if (number_of_routes % olive) == 0 and olive < (don := number_of_routes // olive) < 100:
        print(f"{number_of_routes=} {olive=} {don=}")

LikeLike

Jim Randell 8:44 am on 12 June 2026 Permalink | Reply
Tags: by: Derek Emley ( 2 )
Teaser 2421: [Silver pennies]
From The Sunday Times, 15th February 2009 [link]

The winning team at a seven-a-side football tournament was awarded a four-figure perfect square number of silver pennies. This was shared as equally as possible between the players, the remaining pennies being placed in the Benevolent Fund. The same procedure, with an equal prize, was followed for the cricket and rugby league tournaments. In each case, more than one penny went into the fund. And one sport’s contribution was the sum of the other two.

How much did the wicket keeper win?

The prize for the football tournament is split between 7 players. For the cricket team the prize is split between 11 players (including the wicket keeper), and for the rugby league team the prize is split between 13 players.

This puzzle was originally published with no title.

[teaser2421]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Ruud and Jim Randell are discussing. Toggle Comments
- Jim Randell 8:44 am on 12 June 2026 Permalink | Reply
  We are to assume that the in each case the entire quantity of pennies is evenly distributed to the 7 players in the football team, the 11 players in the cricket team, and the 13 players in the rugby league team. And the that wicket keeper is part of the cricket team (and does not play in any of the other teams).
  
  If we have 3 numbers, and one of them is the sum of the other two, then by adding them all together we get twice the largest number.
  
  This Python program runs in 76ms. (Internal runtime is 140µs).
```
from enigma import (powers, div, printf)

# sizes of the groups
teams = (7, 11, 13)

# consider 4-digit squares
for n in powers(32, 99, 2):
  rs = tuple(n % k for k in teams)
  if any(r < 2 for r in rs): continue
  if div(sum(rs), 2) not in rs: continue
  # output solution
  printf("n={n}: {rs}")
  for k in teams:
    (d, r) = divmod(n, k)
    printf("-> /{k} = {d} rem {r}")
  printf()
```
  Solution: The wicket keeper won 820 pennies.
  
  In each case the prize was 9025 pennies.
  
  The football team (7 players) won 1289 pennies each, with the remaining 2 pennies going to the Benevolent Fund.
  
  The cricket team (11 players) won 820 pennies each, with the remaining 5 pennies going to the Benevolent Fund.
  
  The rugby league team (13 players) won 694 pennies each, with the remaining 3 pennies going to the Benevolent Fund.
  
  So the Benevolent Fund received 10 of the 27075 pennies (= 0.33% of the total amount).
  
  LikeLike
- Ruud 11:06 am on 12 June 2026 Permalink | Reply
```
for total in (i * i for i in range(32, 100)):
    if all(total % n > 1 for n in (7, 11, 13)) and any(x == y + z for x, y, z in istr.permutations(total % n for n in (7, 11, 13))):
        print(total // 11)
```
  LikeLike
Jim Randell 8:36 am on 10 June 2026 Permalink | Reply
Tags: by: Nick MacKinnon ( 60 )
Teaser 2424: [Five-pointed star]
From The Sunday Times, 8th March 2009 [link]

I have drawn a five-pointed star with points A, B, C, D, E clockwise (i.e., the star is formed by the lines AC, CE, EB, BD and DA). Measured in degrees, the star’s angles at A, B, C, D and E, respectively, form an arithmetic progression of whole numbers. Also, within that star, the lines have created a small pentagon. Altogether the five angles in the star and the five angles of the small pentagon include four prime numbers.

What are those primes?

This puzzle was originally published with no title.

[teaser2424]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Ruud and Jim Randell are discussing. Toggle Comments
- Jim Randell 8:38 am on 10 June 2026 Permalink | Reply
  (See also: Teaser 1885, also set by Nick MacKinnon).
  
  If we denote the angles at the vertices of the star as a, b, c, d, e, and the opposite angles in the pentagon as a′, b′, c′, d′, e′, then from the triangles formed by the star we have:
  
  a′ + b + e = 180°
  b′ + c + a = 180°
  c′ + d + b = 180°
  d′ + e + c = 180°
  e′ + a + d = 180°
  
  And the internal angles of the pentagon sum to 540°, hence:
  
  (a′ + b′ + c′ + d′ + e′) + 2(a + b + c + d + e) = 900°
  ⇒
  a + b + c + d + e = 180°
  
  And these form an arithmetic progression, so we can write:
  
  (a, b, c, d, e) = (c − 2x, c − x, c, c + x, c + 2x)
  ⇒
  c = 36
  x ≤ 17
  
  If x is even then all the angles involved will also be even, so we are not going to get 4 different prime numbers among them. So we can skip even x.
  
  This program considers possible x values to find a viable angles for the internal vertices of the star and for the smaller pentagon.
  
  It runs in 74ms. (Internal runtime is 91µs).
```
from enigma import (irange, icount, is_prime, printf)

# consider possible common differences in the arithmetic progression
for x in irange(1, 17, step=2):
  # construct the progression
  ns = list(irange(36 - 2*x, 36 + 2*x, step=x))
  # count the number of primes involved
  pn = icount(ns, is_prime)

  # calculate the internal angles of the pentagon
  (a, b, c, d, e) = ns
  Ns = (
    180 - (b + e),
    180 - (c + a),
    180 - (d + b),
    180 - (e + c),
    180 - (a + d),
  )
  # count the primes in these
  pN = icount(Ns, is_prime)

  # check for exactly 4 prime angles
  if pn + pN == 4:
    # output solution
    printf("a={a} x={x} -> ns={ns} ({pn} prime); Ns={Ns} ({pN} prime)")
```
  Solution: The primes are: 31, 41, 103, 113.
  
  The angles at the vertices of the star form the following progression: (26°, 31°, 36°, 41°, 46°).
  
  And the corresponding angles at the vertices of the pentagon are: (103°, 118°, 108°, 98°, 113°).
  
  Here is a possible construction of the star:
  
  LikeLike
- Ruud 1:31 pm on 10 June 2026 Permalink | Reply
```
import peek
import istr

for start in range(2, 35, 2):
    inc = (180 - 5 * start) // 10
    outer_angles = [start + i * inc for i in range(5)]
    inner_angles = [180 - angle1 - angle2 for angle1, angle2 in zip(outer_angles, outer_angles[2:] + outer_angles[:2])]
    if len(prime_angles := [angle for angle in outer_angles + inner_angles if istr.is_prime(angle)]) == 4:
        peek(prime_angles)
```
  LikeLike

Jim Randell 6:56 am on 7 June 2026 Permalink | Reply
Tags: by: Victor Bryant ( 148 )

Teaser 3324: Prime tournament

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

Our squash club recently organised a round-robin tournament (i.e., each participant played each of the others once), with each game resulting in a win for one of the players. An even number of players, fewer than 28, took part. At the end of the tournament a player’s score was the number of games he or she had won.

It turned out that each player’s score was a prime number, and each prime number less than the number of players occurred as somebody’s score. Furthermore each such score was achieved by a prime number of players! The players who tied bottom shared equally the £10 booby prize.

How many players were there, and what was the most common score?

[teaser3324]

Jim Randell 9:23 am on 7 June 2026 Permalink | Reply

(See also: Enigma 1045).

I split the puzzle into two parts.

The first finds candidate score distributions:

from enigma import (irange, primes, C, express, multiset, run, printf)

# consider the number of players = n
for n in irange(2, 26, step=2):

  # find primes less than n
  ps = list(primes.between(2, n - 1))
  if not ps: continue

  # count the number of matches in the tournament
  # this is the total number of points allocated
  t = C(n, 2)

  printf("n={n}: ps={ps} t={t}")

  # express the points total using the prime numbers
  # each prime total must appear a prime number of times
  for qs in express(t, ps, qs=ps):
    # must be totals for n players
    if not (sum(qs) == n): continue
    # and the number of players with the lowest points must divide into 1000
    if not (1000 % qs[0] == 0): continue

    # generate the list of totals
    m = multiset.from_pairs(zip(ps, qs))
    ts = list(m.sorted(reverse=1))
    printf("-> {ts}")
    assert sum(ts) == t

    # check to see if this list of totals is viable
    run("teaser3324mzn.py", *ts)

And the second part (which is called from the first program) uses a MiniZinc model to check if the given score distribution is viable:

from enigma import (multiset, sprintf, args, printf)
from minizinc import MiniZinc

# collect required points
pts = args(None, 0, int)
n = len(pts)

# construct a MiniZinc model to make the table
model = sprintf("""

% indices for the players
set of int: T = 1..{n};

% points to allocate
array[T] of int: points = {pts};

% wins for A against B
array [T, T] of var {{0, 1}}: x;

% no player plays themselves
constraint forall (i in T) (x[i, i] = 0);

% symmetry constraints
constraint forall (i, j in T where i < j) (x[i, j] + x[j, i] = 1);

% points for each player
constraint forall (i in T) (points[i] = sum (j in T where j != i) (x[i, j]));

solve satisfy;
""")

# solve the model
for [table] in MiniZinc(model).solve(result='x'):
  # output the table
  printf()
  for row in table:
    printf("{row} -> {t}", t=sum(row))
  printf()
  # output solution
  m = multiset.from_seq(pts)
  for (s, k) in m.multiplicity(max(m.values())):
    printf("num players = {n}; most common score = {s} (appears {k} times)")
  printf()
  # one example is enough
  break

It turns out only one of the candidate distributions of points allows a table to be constructed, and this gives the answer.

Solution: There were 16 players in the tournament. The most common score was 11 points.

With 16 players there are C(16, 2) = 120 matches, and so 120 points are allocated.

The scores were:

2 players with 13 points
5 players with 11 points
2 players with 7 points
3 players with 5 points
2 players with 3 points
2 players with 2 points
total = 120 points

The bottom two players (with 2 points each) get to share the £ 10 booby prize, so they get £ 5 each.

There are many possible tables that correspond to this score sequence, but here is one example to show it is possible:

% python3 teaser3324mzn.py 13 13 11 11 11 11 11 7 7 5 5 5 3 3 2 2

[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0] -> 13
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0] -> 13
[0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1] -> 11
[0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1] -> 11
[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] -> 11
[0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] -> 11
[0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1] -> 11
[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1] -> 7
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1] -> 7
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1] -> 5
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1] -> 5
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1] -> 5
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1] -> 3
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1] -> 3
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1] -> 2
[1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] -> 2

num players = 16; most common score = 11 (appears 5 times)

So, although we don’t need the MiniZinc program to check that a score sequence is viable, it is handy to generate an example table for a given score sequence.

The first program finds 16 candidate score sequences:

12 players, 1 candidate, starting [11, 11, …]
16 players, 1 candidate, starting [13, 13, …]
20 players, 3 candidates, starting [19, 19, …]
24 players, 11 candidates, starting [23, 23, …]

Each sequence starts with 2 copies of the largest prime less than n (and this is the smallest number of copies of the largest prime that can appear, as it must appear a prime number of times).

But none of the cases where the largest prime is (n − 1) are possible, as the first player (A) has to win all of their matches, and so does the second player (B). But they cannot both win the A v B match.

This means we can immediately eliminate all candidate numbers of players that are one more than a prime number.

This leaves a single candidate score sequence:

16 players, scores = [13, 13, 11, 11, 11, 11, 11, 7, 7, 5, 5, 5, 3, 3, 2, 2]

So if the puzzle has a solution it must be derived from this score sequence, and the sequence is enough to give the required answer without finding a viable table.

However for a complete solution we need to demonstrate that the table can be constructed. In my first solution (above) I used a MiniZinc model to search for a viable table, and in my second solution (below) I used Landau’s Theorem to check the score sequence. The Landau condition is both necessary and sufficient for a valid table to exist, but it does not build a constructive example.

LikeLike

Jim Randell 12:47 pm on 7 June 2026 Permalink | Reply

Instead of using MiniZinc to look for a viable table we can use Landau’s Theorem [@wikipedia] to check for a valid sequence of scores (although it does not provide us with an example table):

Landau’s Theorem (1953)

A score sequence for n players:

0 ≤ s[1] ≤ s[2] ≤ …≤ s[n] ≤ n − 1

is valid if and only if:

s[1] + … + s[k] ≥ C(k, 2)

for k = 1 .. n, with equality when k = n.

(And I believe the theorem also holds providing 1 point is divided between the teams involved in each match, specifically it still holds in the case where each side in a drawn match is awarded ½ point. [J W Moon, 1963]).

The following Python program runs in 138ms. (Internal runtime is 67ms).

from enigma import (irange, primes, C, express, csum, compare, multiset, printf)

# check the Landau condition for the score sequence of a tournament of <n> teams
# ss = ordered score sequence (low to high) 0 <= ss[i] <= n - 1
def landau(n, ss):
  if not (len(ss) == n and n > 1): raise ValueError("landau: invalid arguments")
  for (i, s) in enumerate(csum(ss), start=1):
    r = compare(s, C(i, 2))
    if r == -1: return False
  return (r == 0)

# consider the number of players = n
for n in irange(2, 26, step=2):

  # find primes less than n
  ps = list(primes.between(2, n - 1))
  if not ps: continue

  # count the number of matches in the tournament
  # this is the total number of points allocated
  t = C(n, 2)

  # express the points total using the prime numbers
  # each prime total must appear a prime number of times
  for qs in express(t, ps, qs=ps):
    # must be totals for n players
    if not (sum(qs) == n): continue
    # and the numbers of players with the lowest points must divide into 1000
    if not (1000 % qs[0] == 0): continue

    # generate the list of totals
    m = multiset.from_pairs(zip(ps, qs))
    ts = list(m.sorted())
    assert sum(ts) == t
    # check the Landau condition for this sequence
    if not landau(n, ts): continue

    # output solution
    ts.reverse()
    printf("[n={n}: ps={ps} t={t} -> scores = {ts}]")
    for (s, k) in m.multiplicity(max(m.values())):
      printf("num players = {n}; most common score = {s} (appears {k} times)")
    printf()

LikeLike

Ruud 3:23 pm on 7 June 2026 Permalink | Reply

import peek
import istr
import functools

@functools.cache
def primes(n):
    return [*map(int, istr.primes(n))]

def is_feasible_round_robin(wins): # Landau theorem (suggested byChatGPT)
    prefix = 0
    for k in range(1, len(wins) + 1):
        prefix += wins[k - 1]
        if prefix < k * (k - 1) // 2:
            return False

    return True


def assign(total, p, n, nteams):
    if p:
        for i in primes(total // p[0] + 1):
            if total - p[0] * i == 0:
                if len(p) == 1 and 10 % n[0] == 0 and sum(n) + i == nteams:
                    yield n + [i]
                break
            yield from assign(total - p[0] * i, p[1:], n + [i], nteams)


for n in range(4, 28, 2):
    total = n * (n - 1) // 2
    for s in assign(total, primes(n), [], n):
        wins = []
        for i, j in zip(s, primes(n)):
            wins.extend(i * [j])
        if is_feasible_round_robin(wins):
            most_frequent = [j for i, j in zip(s, primes(n)) if i == max(s)]
            peek(n, most_frequent, wins, s)

LikeLike

Frits 8:01 pm on 8 June 2026 Permalink | Reply

I totally forgot to work on yesterday’s teaser.

# primes below 28
P = [2, 3, 5, 7, 11, 13, 17, 19, 23]
Pmin2 = {p - 2 for p in P}
        
# decompose: choose numbers from <ns> so that sum(chosen numbers) equals <t>
def decompose(t, k, ns, s=[]):
  if k == 0:
    if t == 0:
      # count last added number
      if s.count(s[-1]) in Pmin2: 
        yield s
  else:
    for n in ns:
      if s and n > s[-1]:
        # count last added number
        if s.count(s[-1]) not in Pmin2: break
      if n <= t and (not s or n >= s[-1]):
        yield from decompose(t - n, k - 1, ns, s + [n])        

# Landau theorem (from Ruud's program)
def is_feasible_round_robin(wins): 
  prefix = 0
  for k in range(1, len(wins) + 1):
    prefix += wins[k - 1]
    if 2 * prefix < k * (k - 1):
      return False

  return True     

# number of players
for n in range(2, 28, 2):
  pts = (n * (n - 1)) // 2
  # each prime number less than the number of players occurred as somebody's score
  if not(prms := [p for p in P if p < n]): continue
  # each such score was achieved by a prime number of players (so at least 2)
  if (todo := pts - 2 * sum(prms)) < 0: continue
  
  # determine the primes to make the missing <todo> points
  for s in decompose(todo, n - len(prms) * 2, prms):
    # the players who tied bottom shared equally the £10 booby prize
    if 1000 % (2 + s.count(2)): continue
    # is this set of wins viable (using Landau theorem)
    if not is_feasible_round_robin(wins := sorted(prms * 2 + s)): continue
    # frequency of scores
    freq = sorted(((wins.count(w), w) for w in set(wins)))
    # calculate most common scores
    mcs = [str(y) for (x, y) in freq if x == freq[-1][0]] 
    print(f"answer: {n} players,  most common score = {' or '.join(mcs)}")

LikeLike

Alex.T.Sutherland 6:58 pm on 12 June 2026 Permalink | Reply

The method used is as follows:-
Iterate from N = 10:2:26 (does not get to the end).
Calculate Cartesian Products to find all combinations (cp).
Extract those vectors with a first digit 2 or 5 together with
sum of cp*primes = games played.
(primes are those relevant to N).
Test each of these vectors against Landau’s Tournament Theorem
until there is only one vector left that satisfies it.
This gives the number of players who have played which primes.
The vector is unique. Hence the answer to the question.
Break when single vector found.
My Landau’s function is similar to a python Landau function.
Run time from N=10:? is ~ 4ms.
My answer : Product of the Landau’s output vector = 240.

LikeLike
Tony Smith 10:59 am on 15 June 2026 Permalink | Reply

An algorithm in which teams starting from the bottom beat the correct number of the lowest available teams can be used to construct a valid tournament from the single candidate score sequence.

Team 16 beats 15 and 14.
15 beats 14 and 13
14 beats 13, 12,11
13 beats 16, 12,11
12 beats 16,15,11,10,9
11 beats 16,15,,10,9,8
10 beats16,15,14,13,9 etc

LikeLike

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
- Ruud 6:53 am on 6 June 2026 Permalink | Reply
  Extreme brute force:
```
import peek
import istr
for t, i, m, e, s, a, g, o, d, r in istr.permutations(range(10), 10):
    if t and a and g and r and istr('=ti') < 24 and m < 6 and istr("=times") == a + istr("=good") + istr("=read"):
        peek(istr("=time"))
```
  LikeLike
Jim Randell 8:20 am on 3 June 2026 Permalink | Reply
Tags: by: Nick MacKinnon ( 60 )
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, without additional analysis, 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 in the bottom 3 (nor 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:
      return (d['B'] < d['C'])
    except KeyError:
      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
  - Jim Randell 10:57 am on 6 June 2026 Permalink | Reply
    
    Here is some additional analysis that can be used to eliminate some of the cases under consideration, or provide a complete manual solution (also outlined below by John Crabtree).
    
    The positions of the teams in both years are 1 .. n, and the movement of each team is the difference in the positions.
    
    The sum of the n (signed) movements is therefore 0, so the upward movements must be balanced by the downward movements. (i.e. they have the same (absolute) sum).
    
    The largest possible movement is (n − 1) places, and no team moves the same (absolute) number of places. So with n teams all possible gaps from 0 to (n − 1) must be used, each exactly once.
    
    And these gaps can be collected into the “ups” and “downs”, each of which must have the same (absolute) sum. That value is then:
    
    t = tri(n − 1) / 2
    
    So, of the n values under consideration we can discard any where tri(n − 1) is not even.
    
    This leaves the following (n, t) values to consider:
    
    n = 9 → t = 18
    n = 12 → t = 33
    n = 21 → t = 105
    n = 24 → t = 138
    
    But we only have n / 3 “ups” we can use, one of which is the bottom team moving up (n − 1) places to the top to make the largest possible movement.
    
    We can try and see what the largest possible total for collection of n / 3 “ups” is.
    
    The second largest is achieved if the second to bottom team moves up to second place, this is a move of (n − 3) places.
    
    And the next largest is if the third to bottom moves up to third place, a move of (n − 5) places. And so on.
    
    So for each of our values the maximum possible sum of the “ups” (m) is:
    
    n = 9 → m = 8 + 6 + 4 = 18
    n = 12 → m = 11 + 9 + 7 + 5 = 32
    n = 21 → m = 20 + 18 + 16 + 14 + 12 + 10 + 8 = 98
    n = 24 → m = 23 + 21 + 19 + 17 + 15 + 13 + 11 + 9 = 128
    
    So, only n = 9 can achieve the required total, and then only by making the maximum possible arrangement of “up” moves.
    
    (More generally, the maximum possible sum is given by (2/9)n². And we need this to be at least as much as the required total tri(n − 1)/2. This is only possible when n ≤ 9).
    
    Hence any solution must involve 9 teams (A – I), where:
    
    I moves from 9th place to 1st place; a move of +8 positions
    H moves from 8th place to 2nd place; a move of +6 positions
    G moves from 7th place to 3rd place; a move of +4 positions
    
    This gives the required 18 “up” moves, which must be balanced by the remaining 6 teams with moves of: 0, −1, −2, −3, −5, −7 (which sum to −18).
    
    B must finish below C, but not in the bottom 3, which means B must drop 3 positions (to 5th), and C must drop 1 position (to 4th).
    
    A is the only remaining team that can drop 7 positions (to 8th).
    
    F is now the only team that can keep its position (remains 6th).
    
    And D is the only remaining team that drop 5 positions (to 9th), leaving E to drop 2 positions (to 7th).
    
    This provides a complete manual solution of the puzzle.
    
    LikeLike
- 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: The distance from T’zer to the sun is 65 light-chrons.
  
  And the distances from the other 8 planets to the sun are: 16, 25, 33, 39, 52, 56, 60, 63 light-chrons.
  
  These correspond to the following 4 Pythagorean triangles with a shared hypotenuse of 65:
  
  (16, 63, 65)
  (25, 60, 65)
  (33, 56, 65)
  (39, 52, 65)
  
  The next set of triangles that would provide a solution has a hypotenuse of 85:
  
  (13, 84, 85)
  (36, 77, 85)
  (40, 75, 85)
  (51, 68, 85)
  
  Hence the limit of the hypotenuse to less than 80.
  
  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 ( 60 )

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 ( 148 )
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 ( 148 )

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 ( 148 )
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

	Tony Smith on Teaser 3324: Prime tourna…
	Ruud on Teaser 3325: Olive and Do…
	Jim Randell on Teaser 3325: Olive and Do…
	Alex.T.Sutherland on Teaser 3324: Prime tourna…
	Ruud on Teaser 2421: [Silver penn…
	Jim Randell on Teaser 2421: [Silver penn…
	Ruud on Teaser 2424: [Five-pointed…
	Jim Randell on Teaser 2424: [Five-pointed…

Search

Recent Posts

Recent Comments

Archives

Categories

Subscribe

RSS Links

Site Stats

Meta

Recent Updates Toggle Comment Threads | Keyboard Shortcuts

Jim Randell 6:00 am on 14 June 2026 Permalink | Reply Tags: by: John Owen ( 34 )

Rate this:

Share:

Jim Randell 6:17 am on 14 June 2026 Permalink | Reply

Ruud 11:37 am on 14 June 2026 Permalink | Reply

Reply Cancel reply

Jim Randell 8:44 am on 12 June 2026 Permalink | Reply Tags: by: Derek Emley ( 2 )

Rate this:

Share:

Jim Randell 8:44 am on 12 June 2026 Permalink | Reply

Ruud 11:06 am on 12 June 2026 Permalink | Reply

Jim Randell 8:36 am on 10 June 2026 Permalink | Reply Tags: by: Nick MacKinnon ( 60 )

Rate this:

Share:

Jim Randell 8:38 am on 10 June 2026 Permalink | Reply

Ruud 1:31 pm on 10 June 2026 Permalink | Reply

Jim Randell 6:56 am on 7 June 2026 Permalink | Reply Tags: by: Victor Bryant ( 148 )

Rate this:

Share:

Jim Randell 9:23 am on 7 June 2026 Permalink | Reply

Jim Randell 12:47 pm on 7 June 2026 Permalink | Reply

Ruud 3:23 pm on 7 June 2026 Permalink | Reply

Frits 8:01 pm on 8 June 2026 Permalink | Reply

Alex.T.Sutherland 6:58 pm on 12 June 2026 Permalink | Reply

Tony Smith 10:59 am on 15 June 2026 Permalink | Reply

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

Ruud 6:53 am on 6 June 2026 Permalink | Reply

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

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

Jim Randell 10:57 am on 6 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 ( 60 )

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:

Jim Randell 6:00 am on 14 June 2026 Permalink | Reply
Tags: by: John Owen ( 34 )

Jim Randell 8:44 am on 12 June 2026 Permalink | Reply
Tags: by: Derek Emley ( 2 )

Jim Randell 8:36 am on 10 June 2026 Permalink | Reply
Tags: by: Nick MacKinnon ( 60 )

Jim Randell 6:56 am on 7 June 2026 Permalink | Reply
Tags: by: Victor Bryant ( 148 )

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 ( 60 )

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 ( 60 )

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 ( 148 )

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 ( 148 )

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