S2T2 | Solving Sunday Times Teasers

Recent Updates Toggle Comment Threads | Keyboard Shortcuts

Jim Randell 9:58 am on 23 September 2026 Permalink | Reply
Tags: by: Alfred Moritz ( 3 )
Brainteaser 1042: Playing with matches
From The Sunday Times, 18th July 1982 [link]

In a matchplay golf tournament, each match is decided as soon as the margin between the two players (in terms of holes won) exceeds the number of holes remaining to be played. The loser drops out of the tournament, the winner going forward to play someone else. This continues until only one person remains. He wins the tournament.

One consequence of this arrangement is that the course gets very uneven wear, with some greens being played much more often than others.

In one such tournament, played over 18 holes, the matches decided on one green could be counted on the toes of one foot.

But the 14th hole came into play in twice as many matches as the 17th, and in half as many as the 10th. The 9th was played three times as often as the 16th, and the 16th three times as often is the 18th.

No rounds was tied.

How many competitors entered this tournament? How many of these were eliminated at the 17th green?

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

[teaser1042]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 9:59 am on 23 September 2026 Permalink | Reply
  If there are (n + 1) competitors, each match reduces the count by 1, so after n matches the winner is decided. (I am assuming n ≥ 1, so at least 1 match is played).
  
  With 18 holes, a match cannot be decided after the 9th hole (as even if X wins all 9, Y could win the remaining 9 for a draw), but can be decided on the 10th to 18th hole (if X wins the first 10 holes, there is no way Y can come back with only 8 holes remaining).
  
  So, the deciding holes of all the n matches must all occur in the 10th – 18th holes. And the number of matches decided at any one hole can be counted on the toes on one foot (i.e. is less than or equal for 5 (at least for most of us)).
  
  Meaning that the 10th (and all previous holes) must be played in n (i.e. all) of the matches, and the remaining (11th – 18th) holes may be played in fewer matches.
  
  Suppose the number of matches decided on the 10th – 18th hole is A .. I, then we have:
  
  A + B + C + D + E + F + G + H + I = n
  
  And the number of matches played on holes 1 to 10 are n.
  
  On hole 11 matches that are decided on hole 10 are not played, so the total is (n − A) = (B + C + D + E + F + G + H + I).
  
  And so we get the following list for the number of times holes are played:
  
  1st – 10th = A + B + C + D + E + F + G + H + I
  11th = B + C + D + E + F + G + H + I
  12th = C + D + E + F + G + H + I
  13th = D + E + F + G + H + I
  14th = E + F + G + H + I
  15th = F + G + H + I
  16th = G + H + I
  17th = H + I
  18th = I
  
  The following run file executes in 91ms. (Internal runtime of the generated code is 5.4ms).
```
#! python3 -m enigma -rr

SubstitutedExpression

# matches decided on each hole, and [number of times the hole is played]
#
#  9th = 0  [N = A + B + C + D + E + F + G + H + I]
# 10th = A  [N = A + B + C + D + E + F + G + H + I]
# 11th = B  [N - A = B + C + D + E + F + G + H + I]
# 12th = C  [N - A - B = C + D + E + F + G + H + I]
# 13th = D  [N - A - B - C = D + E + F + G + H + I]
# 14th = E  [N - A - B - C - D = E + F + G + H + I]
# 15th = F  [N - A - B - C - D - E = F + G + H + I]
# 16th = G  [N - A - B - C - D - E - F = G + H + I]
# 17th = H  [N - A - B - C - D - E - F - G = H + I]
# 18th = I  [N - A - B - C - D - E - F - G - H = I]
# sum  = N

# values may be repeated
--distinct=""

# no hole has decided more than 5 matches
--base=6  # allows digits 0-5

# number of matches played on hole 14 is 2x that on hole 17
"E + F + G == H + I"

# number of matches played on hole 10 is 2x that on hole 14
"A + B + C + D == E + F + G + H + I"

# number of matches played on hole 9 is 3x that on hole 16
"A + B + C + D + E + F == 2 * (G + H + I)"

# number of matches played on hole 16 is 3x that on hole 18
"G + H == 2 * I"

# assume N >= 1
--macro="@N = (A + B + C + D + E + F + G + H + I)"
"@N > 0"

# answer is:
# number of competitors = N + 1
# number of matches decided on the 17th green = H
--answer="(@N + 1, H)"

# neaten up output
--template=""
```
  Solution: There were 37 competitors in the tournament. And 5 of them were eliminated on the 17th hole.
  
  There are 50 ways to assign the numbers, possible values are:
  
  A = {3, 4, 5}
  B = {3, 4, 5}
  C = {3, 4, 5}
  D = {3, 4, 5}
  E = {1, 2, 3, 4, 5}
  F = {1, 2, 3, 4, 5}
  G = 3
  H = 5
  I = 4
  
  So we can be sure of the numbers eliminated on the 16th, 17th, 18th holes.
  
  LikeLike
Reply Cancel reply
Required fields are marked *

Name *

Email *

Website

Notify me of new comments via email.
Notify me of new posts via email.
Δ
Jim Randell 7:00 am on 20 September 2026 Permalink | Reply
Tags: by: Peter Good ( 31 )
Teaser 3339: Squaring up
From The Sunday Times, 20th September 2026 [link] [link]

Farmer Giles had a square-shaped field, which he divided into nine paddocks by building four straight fences in symmetrical fashion, as shown in the diagram (not to scale). The fence from the SW corner meets the northern edge of the field a two-digit whole number of feet from the NW corner and a three-digit whole number of feet from the NE corner, these two numbers having no common factors.

The area of the central paddock divided by the area of the field was a fraction with a perfect square numerator and a perfect fourth power denominator.

What were the two distances mentioned above?

[teaser3339]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell and Frits are discussing. Toggle Comments
- Jim Randell 7:02 am on 20 September 2026 Permalink | Reply
  This is similar to Routh’s Theorem, but with a square instead of a triangle. (See: Teaser 2444, Teaser 3021).
  
  If the distances along the top are a (a 2-digit number) and b (a 3-digit number), then:
  
  f = a / (a + b)
  
  And the area of the central paddock A (as a fraction of the entire square) is given by:
  
  A = (1 − f)² / (1 + f²)
  ⇒
  A = b² / (a² + (a + b)²)
  
  So we are looking for coprime values for a and b, such that (a² + (a + b)²) is a fourth power.
  
  Since a is a 2-digit number and b a 3-digit number the fourth power must be in the range [12200..1215405], i.e. [11⁴..33⁴].
  
  The following Python program considers possible fourth powers for the denominator (q) and then looks for squares that sum to this number to determine a and b.
  
  It runs in 71ms. (Internal runtime is 1.3ms).
```
from enigma import (irange, sum_of_squares, gcd, printf)

# consider possible 4th powers for the denominator
for n in irange(11, 33):
  q = n**4
  # split q into the sum of two squares (= a^2 + (a + b)^2)
  for (a, c) in sum_of_squares(q, 2, min_v=10):
    if a > 99: break
    b = c - a
    if b < 100 or b > 999 or gcd(a, b) > 1: continue
    # output solution
    printf("a={a} b={b} -> A = {p}/{q} = {b}^2/{n}^4", p=b*b)
```
  Note that the program finds the (unique) solution where the formula for the area given above results directly in a fraction of the form x² / y⁴. (Which is what I expect the setter is after).
  
  However it is not the only solution that can be expressed as a fraction of the form x² / y⁴.
  
  Solution: [To Be Revealed]
  
  LikeLike
  - Jim Randell 2:16 pm on 20 September 2026 Permalink | Reply
    Assuming that the fractional area, when expressed as a fraction in lowest terms, is of the form x² / y⁴, then the solution is unique.
    
    A straightforward approach finds the solution in an acceptable time. (Internal runtime is 131ms):
```
from enigma import (irange, gcd, cproduct, fraction, is_square, is_power, printf)

# consider co-prime a (2-digit) and b (3-digit) values
for (a, b) in cproduct([irange(10, 99), irange(100, 999)]):
  if gcd(a, b) > 1: continue
  # calculate the fraction (in lowest terms)
  (p, q) = fraction(b*b, a*a + (a + b)*(a + b))
  # is it of the form x^2 / y^4 ?
  (x, y) = (is_square(p), is_power(q, 4))
  if x is None or y is None: continue
  # output solution
  printf("a={a} b={b} -> A = {p}/{q} = {x}^2/{y}^4")
```
    But we can also use a bit of analysis to adapt my original program:
    
    In the formula (for coprime a, b):
    
    A = b² / (a² + (a + b)²)
    
    If b is odd, then the formula is already in lowest terms, so we just need to check that the denominator is a fourth power.
    
    If b is even, then the numerator and denominator in the formula can be reduced by dividing by 2 exactly once. But this leaves a numerator that can never be reduced to a perfect square.
    
    So all we need to do is reject even b values:
```
from enigma import (irange, sum_of_squares, gcd, printf)

# consider possible 4th powers for the denominator
for n in irange(11, 33):
  q = n**4
  # split q into the sum of two squares (= a^2 + (a + b)^2)
  for (a, c) in sum_of_squares(q, 2, min_v=10, sep=100):
    if a > 99: break
    b = c - a
    if b < 100 or b > 999 or b % 2 == 0 or gcd(a, b) > 1: continue
    # output solution
    printf("a={a} b={b} -> A = {p}/{q} = {b}^2/{n}^4", p=b*b)
```
    LikeLike
    - Jim Randell 8:08 am on 23 September 2026 Permalink | Reply
      Here is a faster version of the program for the revised puzzle that uses Pythagorean triples.
      
      It has an internal runtime of just 311µs.
      
      from enigma import (irange, sq, pythagorean_triples, gcd, printf) # consider possible 4th powers for the denominator sqs = dict((sq(n), n) for n in irange(11, 33)) for (a, c, z) in pythagorean_triples(max(sqs.keys())): if z not in sqs: continue if a < 10 or a > 99: continue b = c - a if b < 100 or b > 999 or b % 2 == 0 or gcd(a, b) > 1: continue # output solution printf("a={a} b={b} -> A = {p}/{q} = {b}^2/{n}^4", p=sq(b), q=sq(z), n=sqs[z])
      
      And we can argue that only primitive Pythagorean triples need to be examined, which further reduces the runtime to 130µs (and removes the need for the gcd() check).
      
      LikeLike
  - Frits 4:34 pm on 21 September 2026 Permalink | Reply
    Using Euclid’s formula (something that was mentioned lately in an internal discussion).
```
from enigma import (gcd, printf)

def pythagorean_triples_exact(num, min_v=10):
  # solve: a^2 + b^2 = c^2 where num = c^2 using Euclid's formula
  for m in range(2, num + 1):
    m2 = m * m
    # "... not both odd..."
    for n in range(1 + m % 2, m, 2):
      # "... with m and n coprime ..."
      if gcd(m, n) == 1:
        n2 = n * n
        c = m2 + n2
        if c > num: 
          break
        a = m2 - n2
        b = 2 * m * n
        if b < a:
          a, b = b, a

        k, r = divmod(num, c)
        if not r:
          if a * k >= min_v:
            yield (a * k, b * k)
            
# consider possible 4th powers for the denominator
for n in range(11, 34):
  q2 = n * n
  # split q2 * q2 into the sum of two squares (= a^2 + (a + b)^2)
  for (a, c) in pythagorean_triples_exact(q2, min_v=10):
    if a > 99: continue
    b = c - a
    if b < 100 or b > 999 or b % 2 == 0 or gcd(a, b) > 1: continue
    # output solution
    printf("a={a} b={b} -> A = {p}/{q4} = {b}^2/{n}^4", p=b*b, q4=q2*q2)
```
    LikeLike
- Frits 1:30 pm on 20 September 2026 Permalink | Reply
  The program runs reasonably fast under PyPy.
  Weak spot is the upper limit for “q” and the assumption that the fraction is minimal (numerator and denominator are broken down as much as possible).
```
from math import gcd

is_square = lambda n: None if (rt := round(n**.5))**2 != n else rt

# small and larger distances 
for x in range(10, 100):
  x2, x4 = x * x, x * x * x * x
  for y in range(100, 1000):
    if gcd(x, y) > 1: continue
    # consider the smallest triangle with it's angle <t>
    # sin(t)^2 = b^2 / x^2 = x^2 / (2x^2 + 2xy + y^2)
    b2 = x4 / ((2 * x2 + (xy2 := 2 * x * y) + (y2 := y**2)))
    # calculate the sides of the small triangle
    a = (x2 - b2)**.5
    b = b2**.5
    # C^2  is the area of the central paddock
    c2 = y2 - x2 + 2 * a * b
    # area of the central paddock divided by the area of the field
    f = c2 / (x2 + xy2 + y2)
    
    # can we write f as p^2 / q^4
    for q in range(1, 100):
      p2 = f * q**4
      # is p2 an integer?
      if abs(p2 - round(p2)) < 1e-13:
        p2 = round(p2)
        if gcd(p2, q) == 1 and (p := is_square(p2)):
          print(f"answer: {x} and {y}")
          break
```
  LikeLike

Jim Randell 2:43 pm on 18 September 2026 Permalink | Reply
Tags: by: Graham Smithers ( 90 )

Teaser 2410: [Cube numbers]

From The Sunday Times, 30th November 2008 [link]

Ollie was given a cube together with 15 labels, numbered 1 to 15. He put a different label on each edge of the cube so that, if you chose any vertex and added up the numbers on the three edges meeting there, you got the same “vertex sum” for each vertex.

Furthermore, if you chose any face and added up the four numbers on edges around the face, you got the same “face sum” for each face. Ollie was left with three unused numbers; they were not a mixture of odd and even.

What were Ollie’s unused numbers?

This puzzle was originally published with no title.

[teaser2410]

Jim Randell 2:44 pm on 18 September 2026 Permalink | Reply
This Python program labels the 12 edges of the cube, and then uses the [[ SubstitutedExpression ]] solver from the enigma.py library, to assign different values from 1 to 15 to each edge. We then look at the 3 unused numbers, and check they have the same parity.

It runs in 247ms. (Internal runtime is 173ms).
```
from enigma import (
  SubstitutedExpression, irange, subsets, intersect,
  diff, join, sprintf as f, map2str, printf
)

# label the edges A .. L
vertices = "ABE BCF CDG DAH ELI FIJ GJK HKL".split()
faces = "ABCD BEFI CFGJ DGHK AHEL".split()

# collect expressions
exprs = list()
fsum = lambda xs: join(xs, sep=" + ")

# find vertices/faces that share an edge
for xs in [vertices, faces]:
  for (x1, x2) in subsets(xs, size=2):
    es = intersect([x1, x2])
    if not es: continue
    exprs.append(f("{x1} == {x2}", x1=fsum(diff(x1, es)), x2=fsum(diff(x2, es))))

# remove equivalent rotations/reflections
exprs.extend(["A < min(B, C, D, E, F, G, H, I, J, K, L)", "B < min(D, E, H)"])

# construct a solver
digits = list(irange(1, 15))
p = SubstitutedExpression(exprs, base=16, digits=digits)
for s in p.solve(verbose=0):
  # find unused digits
  xs = diff(digits, s.values())
  # all unused digits have the same parity
  if len({x % 2 for x in xs}) > 1: continue
  # output solution (unused values and labelling of edges)
  printf("unused values = {xs}")
  printf("-> {s}", s=map2str(s))
```
Solution: The unused numbers are: 2, 8, 14.

The (incorrect) solution published in the paper was: “2, 8 and 15”.

Here is a diagram showing the labelling of the edges of the cube:

(Rotations/reflections of this arrangement also give viable solutions).

The 3 numbers around each vertex sum to V = 24. And the 4 numbers around each face sum to F = 32.

It is straightforward to show that if the sum of all numbers used is T then:

V = T/4
F = T/3

Hence T must be a multiple of 12.

In this case we have T = 96.

There are also 5 essentially different ways to label the cube where the unused numbers have a mix of even and odd parities. In these labellings the unused numbers are:

(1, 2, 9), V = 27, F = 36
(1, 8, 15), V = 24, F = 32
(3, 8, 13), V = 24, F = 32
(5, 8, 11), V = 24, F = 32
(7, 14, 15), V = 21, F = 28

These can be seen by removing the condition at line 31 of the program.

LikeLike

Frits 4:01 pm on 19 September 2026 Permalink | Reply

tri = lambda n: n * (n + 1) // 2

'''  T = tri(15) = 120

we have 6 faces where each edge is used twice: 2.T = 6.face_sum
vertices ABE, HKL, CDG and FIJ cover all edges so T = 4.vertex_sum
--> T is a multiple of 12 and thus even
that means Ollie's unused numbers were all even '''
#       A  
# --------------
# |\          /|    
# | \B      C/ |
# |  \______/  |
# |  |  D   |  |   
# |E |F    G| H|  
# |  |__I___|  |
# |  /      \  |
# | /J      K\ |
# |/    L     \| 
# --------------

# decompose <t> into <k> increasing numbers from <ns>
def decompose(t, k, ns, s=[]):
  if k == 1:
    if t in ns:
      yield tuple(s + [t])
  else:
    for i, n in enumerate(ns):
      # make sure we don't overshoot
      if 2 * t < (2 * n + k - 1) * k: break
      yield from decompose(t - n, k - 1, ns[i + 1:], s + [n])
        
# decompose <t> into <k> numbers from set <ns> with sum first 2 numbers = <m>
def decompose2(t, k, m, ns, s=[]):
  if k == 1:
    if t in ns:
      yield s + [t]
  else:
    for n in ns:
      # make sure we don't overshoot
      if t - n > 0 and (m == 0 or k != 3 or s[0] + n == m):
        yield from decompose2(t - n, k - 1, m, ns - {n}, s + [n])          

sols = set()
T = tri(15)
# try multiples of 12
for m in range(1, 99):
  t = T - (u := m * 12)
  if m * 12 > 15 + 14 + 13: break
  # face sum and vertex sum
  fs, vs = t // 3, t // 4
  
  # pick 3 even label numbers that sum to <u>
  for unused in decompose(u, 3, range(2, 15, 2)):
    ns = set(range(1, 16)).difference(unused)
    # choose face ABCD where A = 1
    for A, B, C, D in decompose2(fs - 1, 3, 0, ns - {1}, [1]):
      if C < B: continue  # remove a rotation/reflection
      rest8 = ns - {A, B, C, D}
      E, H = vs - A - B, vs - A - C
      if E == H or E not in rest8 or H not in rest8: continue
      # choose I, J, K, L so that A + D + I + L = <fs>
      for I, L, J, K in decompose2(fs, 4, fs - A - D, rest8 - {E, H}):
        F, G = fs - B - E - J, fs - C - H - K
        if {E, H, I, L, J, K, F, G} != rest8: continue
        
        vertices = {A + B + E, A + C + H, B + D + F, C + D + G, 
                    G + I + K, F + I + J, H + K + L, E + J + L}
        if vertices != {vs}: continue

        faces = {A + B + C + D, A + E + H + L, C + G + H + K, 
                 B + E + F + J, D + F + G + I, I + J + K + L}
        if faces != {fs}: continue
        
        sols.add(unused)

print("answer:", ' or '.join(str(x) for x in sols))

LikeLike

Jim Randell 3:24 pm on 16 September 2026 Permalink | Reply
Tags: by: B T Izzard ( 4 )
Brain-Teaser 895: Sum mistake
From The Sunday Times, 1st October 1978 [link]

Margaret was demonstrating the use of a pocket calculator to her grandfather. (Keyboard shown above). It was of the type having algebraic logic, which does continuous mixed calculations (e.g. 5 + 2 × 3 = 21). She also demonstrated that keying two consecutive operations results in the second taking preference (e.g. 5 +× 2 = 10).

Margaret asked grandfather to calculate 80 × 5 + 40 − 10; but unfortunately grandfather’s hands were a little shaky and he was prone to strike keys horizontally oг vertically adjacent to the correct one.

Having entered the sum grandfather was about to press the = key (fortunately he hadn’t pressed it before) when Margaret stopped him.

“You have made just two errors so far, and they were consecutive”, she said, “but don’t worry, if you divide by your age on your next birthday, then press the = key, you will get the correct answer to the calculation”.

Grandfather completed the calculation and correctly pressed the = key.

“Wrong again”, said Margaret, “interesting answer though — if you deduct grandmother’s age, and take the cube root of the remainder, you will get the sum of your age, and mine, on our last birthdays”.

How old are Margaret, grandmother and grandfather?

Another early calculator-based puzzle.

This puzzle is included in the book The Sunday Times Book of Brain-Teasers: Book 2 (1981). The puzzle text above is taken from the book.

[teaser895]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell and Frits are discussing. Toggle Comments
- Jim Randell 3:25 pm on 16 September 2026 Permalink | Reply
  The following Python program codes an evaluator for the rules obeyed by the calculator, and then determines which two consecutive errors in the original sum would result in a the specified correction (which gives the grandfather’s age). It then looks for additional errors entered during the correction, and from viable results determines the ages for grandmother and Margaret.
  
  It runs in 69ms. (Internal runtime is 1.1ms).
```
import re
from enigma import (defaultdict, irange, subsets, tuples, cproduct, update, fdiv, iroot, snapf, printf)

# return (icbrt(n), remainder)
def icbrtrem(n):
  r = iroot(n, 3)
  return (r, n - r * r * r)

# an evaluator for a sequence of key presses on the calculator:

# operators and functions implementing them
ops = {
  '+': (lambda x, y: x + y),
  '-': (lambda x, y: x - y),
  '*': (lambda x, y: x * y),
  '/': fdiv,
}

# evaluate the sequence of keys in <s>
def evaluate(s, r=0):
  # split the string on operators
  bits = re.split(r"([\+\-\*\/]+)", s)
  # evaluate the bits
  op = None
  while bits:
    b = bits.pop(0)
    if not b: continue
    fn = ops.get(b[-1])
    if fn:
      op = fn
    else:
      # b is a number
      b = float(b)
      # apply any pending operation
      r = (op(r, b) if op else b)
      op = None
  return (r if not op else None)

# check the given expressions
assert evaluate("5+2*3") == 21
assert evaluate("5+*2") == 10

# target expression, and value
tgt = "80*5+40-10"
val = evaluate(tgt)


# 4x4 layout of the keys (bottom to top)
layout = ["0.-=", "123+", "456/", "789*"]

# map keys to potential misses
miss = defaultdict(set)
for (i, j) in subsets(irange(4), size=2, select='M'):
  k = layout[i][j]
  if i > 0: miss[k].add(layout[i - 1][j])
  if i < 3: miss[k].add(layout[i + 1][j])
  if j > 0: miss[k].add(layout[i][j - 1])
  if j < 3: miss[k].add(layout[i][j + 1])

# make 2 errors in the target expression
for (i, j) in tuples(irange(len(tgt)), 2):
  for (x, y) in cproduct(miss[tgt[k]] for k in (i, j)):
    expr = update(tgt, [i, j], [x, y])
    # '=' is not pressed until the end
    if '=' in expr: continue
    try:
      r = evaluate(expr)
      # compute required age to correct the sum
      age = snapf(fdiv(r, val))
    except ValueError:
      continue
    if not (40 < age < 125): continue

    printf("{expr} -> {r}; age = {age}")

    # keys to correct expr
    extra = "/" + str(age)

    # additional mistakes are made in the extra keys
    for ks in subsets(irange(len(extra)), min_size=1):
      for vs in cproduct(miss[extra[k]] for k in ks):
        expr2 = expr + update(extra, ks, vs)
        try:
          r2 = evaluate(expr2)
          r2 = snapf(r2)
        except ValueError:
          continue

        # find the perfect cube, and calculate the ages
        (x, gm) = icbrtrem(r2)
        gf = age - 1
        m = x - gf
        if not (0 < m < gm < 125): continue
        printf("  {expr2} -> {r2} -> gf = {gf}, gm = {gm}, m = {m}")
```
  Solution: Margaret is 53. Grandmother is 99. Grandfather is 96.
  
  The correct result of the sum is:
  
  80 × 5 + 40 − 10 → 430
  
  The sequence initially entered by grandfather was:
  
  80 × 5 + 41310 → 41710
  
  The consecutive errors (underlined) being “0” → “1”, “−” → “3” (in both cases striking the key above the intended one).
  
  The result of this calculation would be 41710, which when divided by 97 gives the original result of 430.
  
  So grandfathers age at his next birthday is 97, hence his current age is 96.
  
  Three additional mistakes are made in entering “÷ 97” giving the following sum:
  
  80 × 5 + 413106 × 8 → 3308048
  
  The additional errors (also underlined) are “÷” → “6”, “9” → “×”, “7” → “8”.
  
  The result of the completed sum (on pressing =) is 3308048.
  
  And calculating the closest perfect cube below this gives:
  
  3308048 = 149³ + 99 = (96 + 53)³ + 99
  
  Hence grandmother is 99, and Margaret’s age is (149 − 96) = 53.
  
  LikeLike
  - Frits 11:07 am on 17 September 2026 Permalink | Reply
    
    Who is Martha?
    
    LikeLike
  - Frits 12:12 pm on 17 September 2026 Permalink | Reply
    
    If grandfathers age at his next birthday would have been 61 then the program would have given a ZeroDivisionError.
    
    LikeLike
    - Jim Randell 12:42 pm on 17 September 2026 Permalink | Reply
      
      @Frits: Yes. I checked what errors needed to be caught, and in this situation was only ValueError. But in the general case we might also need to catch ArithmeticError. (If we want to catch all errors we could catch Exception).
      
      LikeLike
Jim Randell 7:10 am on 13 September 2026 Permalink | Reply
Tags: by: Howard Williams ( 47 )
Teaser 3338: Any way but back
From The Sunday Times, 13th September 2026 [link] [link]

For her research on insect migration, Sophie has constructed a rectangular flat box in which insects travel from the SW corner to the NE corner. Inside are obstacles, arranged in rows and columns running from West to East and South to North, that the insects have to travel around, moving North or East, or (via a tunnel) diagonally through, moving NE. On each obstacle there is the option of closing the tunnel.

The total number of possible pathways across the box, with all tunnels open, is too big for Sophie’s purposes, but closing just one of the obstacles’ diagonal passages reduces the total number of possible routes by seven eighty-ninths (7/89).

What is the smallest number of obstacles that can be in the box?

[teaser3338]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell and Frits are discussing. Toggle Comments
- Jim Randell 7:12 am on 13 September 2026 Permalink | Reply
  (See also: Tantalizer 457 et al).
  
  The following Python program calculates numbers of paths constructively in rectangles of increasing area, until it finds an area where blocking of just one of the tunnels produces the required reduction in the number of paths.
  
  We only check for obstacles in the left-hand half of the grid, as paths are reversible, so the path counts in the right-hand side of the grid are just a rotation of those in the left-hand side.
  
  The program runs in 67ms. (Internal runtime is 706µs).
```
from enigma import (irange, inf, divisors_pairs, div, cproduct, divc, uniq, cache, printf)

# count the paths from (x, y) to (0, 0) in a grid
# with an optional obstacle at <block>
@cache
def npaths(x, y, block=None):
  if x == 0 or y == 0: return 1
  k = (x1, y1) = (x - 1, y - 1)
  r = npaths(x1, y, block) + npaths(x, y1, block)
  if k != block: r += npaths(x1, y1, block)
  return r

# consider increasing area rectangles
for A in irange(1, inf):
  s = 0
  # consider possible width <w> and height <h>
  for (h, w) in divisors_pairs(A):
    # count number of paths with no blocks
    n0 = npaths(w, h)
    # target number of paths = (82/89) n0
    n1 = div(n0 * 82, 89)
    if n1 is None: continue

    # block the diagonal path in one of the cells
    for (x, y) in cproduct([irange(divc(w, 2)), irange(h)]):
      # have we achieved the target?
      if npaths(w, h, (x, y)) == n1:
        for (x, y) in uniq([(x, y), (w - x - 1, h - y - 1)]):
          printf("{w} x {h} (area = {A}) -> {n0} paths; block @ ({x}, {y}) -> {n1} paths")
          s += 1

  if s:
    printf("[{s} solutions]")
    break
```
  An 8×4 box has 3649 possible paths. And blocking the (3, 1) → (4, 2) tunnel (or, equivalently, the (4, 2) → (5, 3) tunnel) reduces this by 287 paths, 287/3649 = 7/98.
  
  And this is the smallest area rectangle that gives the required reduction.
  
  I am assuming that the question is asking for the area of the smallest possible box (where each cell contains an obstacle).
  
  Solution: The smallest possible box has 32 obstacles.
  
  LikeLike
  - Jim Randell 5:22 pm on 13 September 2026 Permalink | Reply
    With some analysis:
    
    For a w by h box the number of paths with no blocks is given by the Delannoy Number [@wikipedia]:
    
    D(w, h) = sum(C(w, k) × C(h, k) × (2^k) for k = 0..min(w, h))
    
    And the number of paths that include a blocked diagonal crossing at (x, y) → (x + 1, y + 1) is given by:
    
    X = D(x, y) × D(w − x − 1, h − y − 1)
    
    (i.e. we choose a path to the start of the tunnel, and then a path from the end of the tunnel to the final destination).
    
    So we can look for the specific reduction we need.
    
    This gives a slightly faster program. It has an internal runtime of 305µs.
```
from enigma import (irange, inf, divisors_pairs, div, cproduct, divc, uniq, cache, printf)

# calculate Delannoy number D(w, h) iteratively
@cache
def D(w, h):
  n = min(w, h)
  if n == 0: return 1
  s = t = 1
  for k in irange(n):
    t *= 2 * (w - k) * (h - k)
    k += 1
    t //= k * k
    s += t
  return s

# consider increasing area rectangles
for A in irange(1, inf):
  s = 0
  # consider possible width <w> and height <h>
  for (h, w) in divisors_pairs(A):
    # count number of paths with no blocks
    n0 = D(w, h)
    # target number of excluded paths = (7/89) n0
    nx = div(n0 * 7, 89)
    if nx is None: continue

    # block the diagonal path in one of the cells
    for (x, y) in cproduct([irange(divc(w, 2)), irange(h)]):
      # have we achieved the target?
      (x1, y1) = (w - x - 1, h - y - 1)
      if D(x, y) * D(x1, y1) == nx:
        for (x, y) in uniq([(x, y), (x1, y1)]):
          printf("{w} x {h} (area = {A}) -> {n0} paths; block @ ({x}, {y}) -> {n1} paths", n1= n0 - nx)
          s += 1

  if s:
    printf("[{s} solutions]")
    break
```
    LikeLike
    - Frits 11:28 am on 18 September 2026 Permalink | Reply
      
      @Jim, very nice.
      
      How did you come up with this iterative formula?
      NB it also works with “for k in irange(n – 1):” as the last iteration adds zero to “s”.
      
      LikeLike
      - Jim Randell 3:26 pm on 18 September 2026 Permalink | Reply
        
        @Frits: Instead of computing each term in the sum from scratch, the next term is computed from the previous term.
        
        irange(n) generates n values from 0 to n - 1, so it is already shorthand for irange(0, n - 1), and the final zero term is not computed.
        
        LikeLike

Jim Randell 9:58 am on 11 September 2026 Permalink | Reply
Tags: by: Victor Bryant ( 152 )

Brain-Teaser 871: Space-age numbers

From The Sunday Times, 16th April 1978 [link]

My son has just learnt to recognise numbers and so he takes great interest in my calculator, even though the numbers are straightened-up electronic versions of the ones he’s used to.

I entered a large number on the calculator to show my son. Then there was great excitement as he noticed the reflection of the calculator in a mirror.

“Look Dad, that calculator in there has also got a number on it, and it’s different from yours”, he exclaimed (and he was right.

Then I used the calculator to divide the number I’d just put in by three. The answer was a five-digit whole number in which each of the five digits was different. This time my son remarked: “Hey Dad, when I hold the calculator upside-down I can see another five-digit number”; and again he was right.

I then used the calculator to work out the difference between the number in the calculator the right way up and the number my son had seen by holding the calculator upside-down. Again the answer was a five-digit number with all of its digits different. And yet again my son held the calculator upside-down and saw another number.

What number did he see this time?

This puzzle is included in the book The Sunday Times Book of Brain-Teasers: Book 2 (1981). Where it is noted that this is one of the earliest Teaser puzzles to involve a calculator.

The puzzle text above is taken from the book.

[teaser871]

Jim Randell 9:59 am on 11 September 2026 Permalink | Reply
The set of reflected digits is different depending on whether they are reflected about a horizontal or vertical axis. The diagram in the solution given in the book shows the author was considering a vertical axis (left↔︎right)). Although if a horizontal axis (top↔︎botton) is used, the set of viable reflected digits is the same, with the addition of 3 → 3. However, if this alternative set of reflections is used the answer to the puzzle is the same).

The following Python solution starts by looking for a 5-digit number, consisting of 5 different digits that can be rotated to give a viable number. It then looks at the difference between these numbers, and checks that it is also a 5-digit rotatable number, with 5 different digits. And then it considers the original number in the puzzle, which is 3 times the number we started with, and checks to see if this is reflectable to give a different number. If all the conditions are met, the answer is the rotation of the calculated difference.

It runs in 87ms. (Internal runtime is 12.1ms)
```
from enigma import (subsets, nconcat, rev, nsplit, printf)

# 7-segment display digits that can be reflected (horizontally) to give a valid digit
refl = { 0: 0, 1: 1, 2: 5, 5: 2, 8: 8 }

# 7-segment display digits that can be rotated to give a valid digit
rot = { 0: 0, 1: 1, 2: 2, 5: 5, 6: 9, 8: 8, 9: 6 }

# consider a rotatable number composed of 5 different digits
for ds in subsets(rot.keys(), size=5, select='P'):
  if ds[0] == 0 or ds[-1] == 0: continue

  # construct the number, and its rotation
  n = nconcat(ds)
  r = nconcat(rot[d] for d in rev(ds))
  # calculate the difference
  diff = abs(n - r)
  dds = nsplit(diff)
  # should be 5-digits all different
  if len(dds) != 5 or len(set(dds)) != 5: continue
  # and also rotatable
  rds = list(rot.get(d) for d in rev(dds))
  if None in rds: continue

  # the original number is 3n
  n1 = 3 * n
  # the number is reflectable (to give a different number)
  r1ds = list(refl.get(d) for d in nsplit(n1, reverse=1))
  if None in r1ds: continue
  r1 = nconcat(r1ds)
  if r1 == n1: continue

  # output solution
  rd = nconcat(rds)
  printf("first number = {n1} -> mirrored = {r1}")
  printf("second number = {n} -> rotated = {r}, diff = {diff} -> rotated = {rd}")
  printf()
```
Solution: The final number seen by the son was 29601.

There are 3 possible starting numbers:

first number = 255288 (mirrored = 885225)
second number = 85096 (rotated = 96058); difference = 10962 (rotated = 29601)

first number = 255588 (mirrored = 882225)
second number = 85196 (rotated = 96158); difference = 10962 (rotated = 29601)

first number = 255888 (mirrored = 888225)
second number = 85296 (rotated = 96258); difference = 10962 (rotated = 29601)

But, in each case the difference between the second number and its rotation is 10962, and when rotated this reads as 29601.

LikeLike
- Ruud van der Ham 5:52 pm on 11 September 2026 Permalink | Reply
  I had to look up Jim’s solution o see that the differnce is actually between the upside-down mirror number and the original number and not -as the problem description says- between the original nmber and the upside-down number.
  Here’s my solution:
```
import peek
import istr

def mirror(x):
    return istr.join(str({0: 0, 1: 1, 2: 5, 5: 2, 8: 8}.get(int(i), "x")) for i in reversed(x))


def upside_down(x):
    return istr.join(str({0: 0, 1: 1, 2: 2, 5: 5, 6: 9, 8: 8, 9: 6}.get(int(i), "x")) for i in reversed(x))


for n1 in istr.range(length=5):
    if n1.all_distinct():
        n0 = 3 * n1
        if "x" not in mirror(n0) and n0 != mirror(n0):
            if "x" not in upside_down(n1) and n1 != upside_down(n1):
                n2 = upside_down(n1) - n1
                if n2 > 0 and len(n2) == 5 and n2.all_distinct():
                    if "x" not in upside_down(n2) and n2 != upside_down(n2):
                        peek(n0, n1, n2, mirror(n0), upside_down(n1), upside_down(n2))
```
  LikeLike

Frits 2:50 pm on 12 September 2026 Permalink | Reply

Starting with the 6-digit number and assuming that all numbers mentioned in the teaser may not start with a zero digit.

from itertools import product
from functools import reduce

d2n = lambda *s: reduce(lambda x,  y: 10 * x + y, s)
n2d = lambda n: list(int(x) for x in str(n))

# 7-segment display digits that can be reflected (horizontally) 
# to give a valid digit
refl = [0, 1, 2, 5, 8]
 
# 7-segment display digits that can be rotated to give a valid digit
rot = { 0: 0, 1: 1, 2: 2, 5: 5, 6: 9, 8: 8, 9: 6 }
notrot = {i for i in range(10) if i not in rot}

# dictionary of complementing digits to get to a multiple of 3
# exclude k = 0 as it may not be used as 6th digit
comp3 = {i: [k for k in refl if k and (k + i) % 3 == 0] for i in range(3)}

sols = set()
# a 6-digit number (d1, d2, ..., d6) divided by 3 gives a 5-digit number
for d1 in [k for k in refl if k and not (10 * k) >= 30]: 
  # avoid <notrot> digits 3, 4, 7 if you divide by 3
  for d2 in [x for x in refl if (10 * d1 + x) // 3 not in notrot]:
    for d3_5 in product(refl, repeat=3):
      # choose last digit so 6-digit number is a multiple of 3
      for d6 in comp3[(d1 + d2 + sum(d3_5)) % 3]:
        n5 = d2n(d1, d2, *d3_5, d6) // 3
        # each of the five digits was different  
        if len(set(dgts5 := n2d(n5))) < 5: continue
        
        # each digit must be rotatable
        if not notrot.isdisjoint(dgts5): continue
        diff5 = abs(n5 - d2n(*[rot[n] for n in dgts5[::-1]]))
        if diff5 < 10000 or diff5 % 10 == 0: continue
        
        # each of the five digits was different  
        if len(set(dgtsdiff5 := n2d(diff5))) != 5: continue
        # each digit must also be rotatable
        if not notrot.isdisjoint(dgtsdiff5): continue
        
        # store solution
        sols.add(d2n(*[rot[n] for n in n2d(diff5)[::-1]]))
        
print("answer:", ' or '.join(str(s) for s in sols))

LikeLike

Ruud van der Ham 3:49 am on 13 September 2026 Permalink | Reply

How do you know that the starting number has 6 digits?
We only know that a third of it has 5 digits.

LikeLike

Frits 9:57 am on 14 September 2026 Permalink | Reply

Thanks, you are right. I had forgotten about this (mainly focussing on Jim’s possible starting numbers output).

from itertools import product
from functools import reduce

d2n = lambda *s: reduce(lambda x,  y: 10 * x + y, s)
n2d = lambda n: list(int(x) for x in str(n))

# 7-segment display digits that can be reflected (horizontally) 
# to give a valid digit
refl = [0, 1, 2, 5, 8]
 
# 7-segment display digits that can be rotated to give a valid digit
rot = { 0: 0, 1: 1, 2: 2, 5: 5, 6: 9, 8: 8, 9: 6 }
notrot = {i for i in range(10) if i not in rot}

# dictionary of complementing digits to get to a multiple of 3
# exclude k = 0 as it may not be used as 6th digit
comp3 = {i: [k for k in refl if k and (k + i) % 3 == 0] for i in range(3)}

sols = set()
# large number must have 5 or 6 digits
for m in (5, 6):
  # a <m>-digit number (d1, d2, ...) divided by 3 gives a 5-digit number
  # 5 --> 10 < 3k < 100,  6 --> 0 < 3k < 10
  for d1 in [k for k in refl if k and 10 * (6 - m) < 3 * k < 10 ** (7 - m)]: 
    # avoid <notrot> digits 3, 4, 7 if you divide by 3
    for d2 in [x for x in refl if notrot.isdisjoint(n2d((10 * d1 + x) // 3))]:
     for middle in product(refl, repeat=m - 3):
        # choose last digit so large number is a multiple of 3
        for d_last in comp3[(d1 + d2 + sum(middle)) % 3]:
          n5 = d2n(d1, d2, *middle, d_last) // 3
          # each of the five digits was different  
          if len(set(dgts5 := n2d(n5))) < 5: continue
          
          # each digit must be rotatable
          if not notrot.isdisjoint(dgts5): continue
          
          diff5 = abs(n5 - d2n(*[rot[n] for n in dgts5[::-1]]))
          if diff5 < 10000 or diff5 % 10 == 0: continue

          # each of the five digits was different  
          if len(set(dgtsdiff5 := n2d(diff5))) != 5: continue
          # each digit must also be rotatable
          if not notrot.isdisjoint(dgtsdiff5): continue

          # store solution
          sols.add(d2n(*[rot[n] for n in n2d(diff5)[::-1]]))
        
print("answer:", ' or '.join(str(s) for s in sols))

LikeLike

Jim Randell 6:10 am on 6 September 2026 Permalink | Reply
Tags: by: Andrew Skidmore ( 94 )
Teaser 3337: Hidden PINs
From The Sunday Times, 6th September 2026 [link] [link]

Richard has opened a bank account. The bank has issued him with a telephone PIN and a debit card PIN; both PINs consist of four digits. The telephone PIN is a perfect square; its square root can be obtained from the card PIN if the first two digits are deleted from the card PIN. The card PIN is composed of four different digits in decreasing order; none of these digits occur in the telephone PIN.

If I told you whether the telephone PIN has any repeated digits (or not), you would be able to find both PINs.

What is the debit card PIN?

[teaser3337]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Ruud van der Ham and Jim Randell are discussing. Toggle Comments
- Jim Randell 6:12 am on 6 September 2026 Permalink | Reply
  This Python program uses the [[ SubstitutedExpression ]] solver from the enigma.py library to generate possible candidate PINs directly from the conditions given in the puzzle text. And then uses the [[ filter_unique() ]] function to determine which of the candidates provides the answer to the puzzle.
  
  It runs in 69ms. (Internal runtime is 3.8ms)
```
from enigma import (SubstitutedExpression, filter_unique, fcompose, item, is_duplicate, printf)

# generate candidate PINs
def generate():
  # construct a solver to find the PINs; tel PIN = ABCD; card PIN = EFGH
  exprs = [
    # tel PIN is a perfect square (= (GH)^2)
    "sq(GH) = ABCD",
    # card PINs digits are in decreasing order
    "E > F", "F > G", "G > H",
  ]
  # none of the card PINs digits appear in the tel PIN
  distinct = ["AEFGH", "BEFGH", "CEFGH", "DEFGH"]

  p = SubstitutedExpression(exprs, d2i=dict(), distinct=distinct, answer="(ABCD, EFGH)")
  # output and return candidates
  for (t, c) in p.answers(verbose=""):
    printf("[tel = {t:04d}, card = {c:04d}]")
    yield (t, c)

# if we knew whether the tel PIN had repeated digits, we could work out both PINs
frep = fcompose(item(0), is_duplicate)
for (t, c) in filter_unique(generate(), frep).unique:
  printf("(repeat = {f}) -> tel = {t:04d}, card = {c:04d}", f=frep((t, c)))
```
  Solution: The debit card PIN is 9762.
  
  There are three viable candidates:
  
  tel = 3844; card = 9762
  tel = 2809; card = 7653
  tel = 2916; card = 8754
  
  If we are told the telephone PIN does not have repeated digits, then we cannot work out which of the last two candidates gives the correct PINS.
  
  But if we are told that it does have a repeated digit, then we can see that only the first candidate survives, and gives us a unique answer to the puzzle.
  
  The same 3 candidates can also be found manually:
  
  The final 2 digits of the card PIN must consist of 2 descending digits.
  
  The largest possible card PIN is 9876, and the smallest is 3210, giving possible final 2 digits to be different descending digits between 76 and 10.
  
  But this 2-digit number cannot share any digits with its square (expressed using 4 digits). This immediately rules out any number ending in 0, 1, 5, 6.
  
  And this leaves just 12 numbers to check (final 2 digits of card PIN → tel PIN):
  
  74 → 5476 (shared digits)
  73 → 5329 (shared digits)
  72 → 5184
  64 → 4096 (shared digits)
  63 → 3969 (shared digits)
  62 → 3844
  54 → 2916
  53 → 2809
  52 → 2704 (shared digits)
  43 → 1849 (shared digits)
  42 → 1764 (shared digits)
  32 → 1024 (shared digits)
  
  This gives 4 candidates for which we can try to complete the card PIN without reusing any of the digits from the 2-digit number (final 2 digits → tel PIN → card PIN):
  
  72 → 5184 → (not possible)
  62 → 3844 → 9762
  54 → 2916 → 8754
  53 → 2809 → 7653
  
  This leaves the 3 candidate pairs of PINs mentioned above.
  
  LikeLike
- Ruud van der Ham 7:42 am on 6 September 2026 Permalink | Reply
```
import peek
import istr

for tel_pin in istr.squares(length=4):
    for card_pin01 in istr.range(length=2):
        card_pin = card_pin01 | tel_pin.sqrt()
        if card_pin.all_distinct() and card_pin.is_decreasing() and len(set(tel_pin) & set(card_pin)) == 0 and not tel_pin.all_distinct():
            peek(tel_pin, card_pin)
```
  LikeLike
- Ruud van der Ham 12:20 pm on 6 September 2026 Permalink | Reply
  I misread the last clause and thought it said that the telephone pin HAS any repeated digits.
  
  This is an updated version:
```
import istr

collect_telephone_pin_has_repeating = {False: [], True: []}
for telephone_pin in istr.squares(length=4):
    for card_pin01 in istr.range(length=2):
        card_pin = card_pin01 | telephone_pin.sqrt()
        if card_pin.all_distinct() and card_pin.is_decreasing() and len(set(telephone_pin) & set(card_pin)) == 0:
            collect_telephone_pin_has_repeating[not telephone_pin.all_distinct()].append((telephone_pin, card_pin))
for has_repeating, solutions in collect_telephone_pin_has_repeating.items():
    if len(solutions) == 1:
        print("telephone pin=", solutions[0][0], "card pin=", solutions[0][1])
```
  LikeLike

Jim Randell 4:55 pm on 4 September 2026 Permalink | Reply
Tags: by: Andrew Skidmore ( 94 )

Teaser 2365: [Madison’s square garden]

From The Sunday Times, 20th January 2008 [link]

Madison has a square front garden with sides a whole number of metres long. It contains a square lawn with sides a whole number of metres long. The rest of the garden consists of a border that Madison wishes to treat with fertiliser before planting.

To work out the area to be treated, Madison has written down the area of the garden, the area of the lawn and the difference between the two. These three numbers between them use each of the digits 0 to 9 exactly once.

What, in square metres, is the area of the border?

This puzzle was originally published with no title.

So I have changed the name to facilitate a weak pun.

[teaser2365]

Jim Randell 4:55 pm on 4 September 2026 Permalink | Reply

This Python program collects increasing square numbers with distinct digits, and attempts to pair each one up with a smaller such square, so that the digits of the squares and the difference give 10 different distinct digits between them.

It runs in 73ms. (Internal runtime is 2.8ms).

from enigma import (irange, inf, seq_is_distinct, printf)

digits = str  # convert integer to digits (could use enigma.nsplit)

# record squares without repeating digits
sqs = list()
for n in irange(1, inf):
  sq1 = n * n
  ds1 = digits(sq1)
  if len(ds1) > 5: break
  if not seq_is_distinct(ds1): continue

  # look for a smaller square to go with this one
  for (sq2, ds2) in sqs:
    d = sq1 - sq2
    ds = ds1 + ds2 + digits(d)
    if len(ds) == 10 and seq_is_distinct(ds):
      # output solution
      printf("{sq1} - {sq2} = {d}")

  # add this (<square>, <digits>)
  sqs.append((sq1, ds1))

Solution: The area of the border is 765 sq m.

The garden has area 1089 (= 33²) sq m, and the lawn has area 324 (= 18²) sq m.

LikeLike

Ruud van der Ham 6:29 pm on 4 September 2026 Permalink | Reply

print(
    *[
        (a1, a2, a3)
        for l1 in range(1, 100)
        for l2 in range(1, l1)
        if "".join(sorted(str(a1 := l1 * l1) + str(a2 := l2 * l2) + str(a3 := l1 * l1 - l2 * l2))) == "0123456789"
    ]
)

LikeLike

Frits 10:58 am on 5 September 2026 Permalink | Reply

flat = lambda group: [x for g in group for x in g]

# 4-digit squares with different digits
sqs3 = [(n * n, s) for n in range(31, 9, -1)
       if len(set(s := str(n * n))) == 3]

# 4-digit squares with different digits
sqs4 = [(n * n, s)  for n in range(32, 100)
       if len(set(s := str(n * n))) == 4]

# check if three strings all have different digits with length 10
def check(*s):
  t = flat(s)
  return len(t) == 10 and len(set(t)) == 10

# 5-4-1 is impossible with different digits
  
# check if 4-4-2 is possible
for i, (n1, ds1) in enumerate(sqs4):
  for n2, ds2 in sqs4[:i][::-1]:
    if n1 - n2 >= 100: break
    if not check(ds1, ds2, str(n1 - n2)): continue
    print(f"answer: {n1 - n2} square meters")
    
# check if 4-3-3 is possible   
for n1, ds1 in sqs4:
  if n1 > 1839: break  # 975 + 864
  for n2, ds2 in sqs3:
    if n1 - n2 >= 1000: break
    if not check(ds1, ds2, str(n1 - n2)): continue
    print(f"answer: {n1 - n2} square meters")

LikeLike

Jim Randell 11:15 am on 2 September 2026 Permalink | Reply
Tags: by: B T Izzard ( 4 )
Brain-Teaser 870: Think of a number
From The Sunday Times, 9th April 1978 [link]

Think of a two-digit whole number”, said Martin.

“Right”, said Sue.

“Double it, add 10, divide by the number you first thought of, subtract 2, divide by 10 and take the reciprocal — what did you get?”

“A positive finite number greater than one”, said Sue.

“Don’t be difficult”, said Martin, “what was your answer?”

Sue told him — precisely.

“It can’t be”, said Martin.

“You’re right”, laughed Sue, “I missed out one step!”

Martin thought: “It’s still impossible for me to tell you the number you started with.”

“I’ll help you”, said Sue. “If I had missed out two steps, including the one already missed out, the answer could have been one hundredth of the number I first thought of.”

What was the number?

This puzzle is included in the book The Sunday Times Book of Brain-Teasers: Book 2 (1981). The puzzle text above is taken from the book.

[teaser870]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Frits and Jim Randell are discussing. Toggle Comments
- Jim Randell 11:16 am on 2 September 2026 Permalink | Reply
  If the procedure is followed correctly, the series of operations results in a value that is the same as the input value.
  
  Martin says: “It can’t be”, so we are interested in results that can be made by missing out one of the steps, but are not 2-digit whole numbers (10 – 99).
  
  The following Python program examines possible input numbers and missing steps to find situations where the results is a finite number, greater than one, that is not a possible start number.
  
  It then looks to situations where knowing the result of the process is not enough information to determine the starting number. And from the remaining candidates it looks for situations where also missing out an additional step can give a result that is 1/100th the starting number.
  
  It runs in 78ms. (Internal runtime is 1.5ms).
```
from enigma import (Rational, irange, filter_unique, unpack, empty, seq2str, printf)

Q = Rational()

# process number <n>, missing out steps <xs>
def process(n, xs=empty):
  r = Q(n)
  try:
    if 1 not in xs: r *= 2   # double it
    if 2 not in xs: r += 10  # add 10
    if 3 not in xs: r /= n   # divide by the number you first thought of
    if 4 not in xs: r -= 2   # subtract 2
    if 5 not in xs: r /= 10  # divide by 10
    if 6 not in xs: r = Q(1, r)  # take the reciprocal
    return r
  except ArithmeticError:
    return None

# possible start numbers (2-digit)
starts = set(irange(10, 99))

# record possible (<start number>, <missing step>, <result>) values>
ss = list()
# consider the missing step
for k in irange(1, 6):
  # start with a 2-digit number
  for n in starts:
    r = process(n, {k})
    if r is None or not (r > 1) or r in starts: continue
    #printf("{k}: {n} -> {r}")
    # record (<missing step>, <start number>) by result
    ss.append((n, k, r))

# knowing the result is not enough to determine the start number
ss = filter_unique(ss, unpack(lambda n, k, r: r), unpack(lambda n, k, r: n)).non_unique

for (n, k, r) in ss:
  printf("[start {n}, miss {k} -> result {r}]")

  # look for an additional step to miss that gives a result of n/100
  for k1 in irange(1, 6):
    if k1 == k: continue
    r1 = process(n, {k, k1})
    if r1 is not None and 100 * r1 == n:
      printf("-> start {n}; miss {ks}; result {r1}", ks=seq2str([k, k1], sort=1, enc=""))

  printf()
```
  Solution: Sue’s starting number was 20.
  
  There are only 4 candidates where missing a step will lead to a viable result:
  
  20 → (miss 4) → 4
  40 → (miss 5) → 4
  45 → (miss 4) → 4.5
  45 → (miss 5) → 4.5
  
  So Sue told Martin “4”, or “4.5”.
  
  If he had been told “4.5” he would know that the starting number was 45 (although not which step was missed).
  
  So he must have been told “4” and the starting number was 20 or 40.
  
  Starting with 20 and missing steps 3 and 4, gives a result of 0.2 = 20/100.
  
  LikeLike
- Frits 11:14 am on 5 September 2026 Permalink | Reply
  
  Starting with two missing steps and using the golden section search method to find the n’s (20 and 45) is slightly less efficient.
  
  LikeLike
Jim Randell 7:25 am on 30 August 2026 Permalink | Reply
Tags: by: Phil Jackson ( 3 ), flawed ( 58 )
Teaser 3336: Gardener’s canes
From The Sunday Times, 30th August 2026 [link] [link]

A gardener had two pairs of bamboo canes, one pair 70 inches long and one pair 94 inches long. Well, he had until his wife ran over them in her car and broke both of the 94-inch canes into 2 pieces. Remarkably all of the broken pieces ended up a whole number of inches long. Even more remarkably when he connected the longest and shortest pieces to one of the 70-inch canes and the two medium pieces to the other 70-inch cane, he was able to make two triangles with enclosed areas a whole number of square inches. He worked out that the enclosed areas differed by exactly 504 square inches.

What was the length of the shortest broken piece?

As published there is no solution to this puzzle.

However there is a solution if the longer canes are 98 inches long.

An apology was published with Teaser 3337.

[teaser3336]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Alex.T.Sutherland, Frits, Jim Randell, and 1 other are discussing. Toggle Comments
- Jim Randell 7:26 am on 30 August 2026 Permalink | Reply
  Using some useful routines from the enigma.py library, I was able to write a short program for this puzzle.
  
  Unfortunately I was not able to find a solution using the values given in the puzzle text.
  
  However, if we make the long rods 98 inches long (instead of 94 inches long), then there is a viable solution. (Perhaps the car extruded the canes, so the two pieces together ended up longer than the original cane).
  
  The longest and shortest pieces must come from the same cane, and likewise the remaining pieces. This Python program considers what integer sided triangles could be made from a broken rod of length L, and a complete rod of length S, that have an integer area. And then looks for two such triangles that differ by the required amount D.
  
  It runs in 80ms. (Internal runtime is 232µs).
```
from enigma import (decompose, triangle_iarea, subsets, printf)

# lengths of the long rod, short rod, required difference in area
#(S, L, D) = (70, 94, 504)  # published formulation
(S, L, D) = (70, 98, 504)  # alternative formulation

# record the lengths of the broken rod, and the triangle area
r = dict()
# break a long rod in to two integer parts
for (a, b) in decompose(L, 2, increasing=1, sep=0, min_v=1):
  # make a triangle using these pieces and a short rod
  A = triangle_iarea(a, b, S)
  if not A: continue
  # record possible triangles
  r[(a, b)] = A
  printf("[tri({a}, {b}, {S}) -> area {A}]")

# now look for 2 breaks with the required difference in area
for ((k1, A1), (k2, A2)) in subsets(r.items(), size=2):
  if not (abs(A1 - A2) == D): continue
  # output solution
  bits = sorted(k1 + k2)
  printf("bits = {bits} [{L} = {k1} -> {A1}; {L} = {k2} -> {A2}]")
```
  In my alternative formulation of the puzzle, the solution is:
  
  Solution: The shortest piece was 20 inches long.
  
  The breaks are:
  
  98 = 20 + 78 → (20, 78, 70) triangle = area 672
  98 = 42 + 56 → (42, 56, 70) triangle = area 1176
  
  The (42, 56, 70) triangle = 14×(3, 4, 5).
  
  LikeLike
- Frits 10:51 am on 30 August 2026 Permalink | Reply
  Using 98 inches and the constant semi-perimeter 84 in the analysis.
```
from collections import defaultdict

is_square = lambda n: None if (rt := round(n**.5))**2 != n else rt

target = 504 
long, short = 98, 70

def triangle_area(a, b, c):
  # semiperimeter, Heron's formula
  s = (a + b + c) // 2   # a + b + c is even in this case
  
  # calculate and check integer area 
  area2 = s * (s - a) * (s - b) * (s - c)
  if area2 <= 0: 
    return None
  else:
    return is_square(area2)

# area2 = s.(s - 70).(s - a).(s - b) 
# area2 = 84.14.(84 - a).(84 - b) = 14^2.6.(84 - a).(84 - b)
# a or b must be a multiple of 3 to make area2 a multiple of 3^2
# and at least one of (84 - a) and (84 - b) must be even
# so a and b may not be both odd, as a + b is even this means both a and b
# must be even

d = defaultdict(list)
# break longest cane into two integer pieces, starting with a multiple of 6
for p in range(6, long, 6):
  q = long - p
  a = triangle_area(p, q, short)
  if a is None: continue
  d[a] += [(p, q)]

sols = set()
for k, vs in d.items():
  if (n := k + target) in d:
    for v1 in vs:
      for v2 in d[n]:
        sols.add(tuple(sorted(v1 + v2)))

print("answer:", ' or '.join(str(min(s)) for s in sols), "inches")
```
  LikeLike
- Ruud 12:23 pm on 30 August 2026 Permalink | Reply
  Assuming 98 instead of 94 (as suggested by Jim)
```
import peek
import istr

def area(a, b, c):
    s = (a + b + c) / 2
    s2 = s * (s - a) * (s - b) * (s - c)
    return istr(s2).sqrt() if s2 > 0 else 0


n1 = 98
n2 = 70
for l1, l2 in istr.combinations(range(1, n1 // 2 + 1), 2):
    lengths = sorted((l1, n1 - l1, l2, n1 - l2))
    area1 = area(n2, lengths[0], lengths[3])
    area2 = area(n2, lengths[1], lengths[2])
    if abs(area1 - area2) == 504:
        peek(l1, l2, lengths)
```
  LikeLike
- Frits 11:06 am on 31 August 2026 Permalink | Reply
```
import pells

target = 504

# 14^2 * 6 * (84 - a) * (a - 14)) = area^2
# -6 * a**2 + 588 * a - 7056 - p^2 = 0  with area = 14p

# discriminant D = (588**2 - 24 * (7056 + p**2)) 
# D + 24 * p^2 = 176400

d = dict()
# find solutions to: x^2 + 24 * p^2 = 176400
for (x, p) in pells.diop_quad(1, 24, 176400):
  if not p or x % 12: continue
  # store integer solutions for a of the quadratic equation
  d[14 * p] = ((588 + x) // 12, (588 - x) // 12)
  
sols = set()
for k, v in d.items():
  if (n := k + target) in d:
     sols.add(min(v + d[n]))

print("answer:", ' or '.join(str(s) for s in sols), "inches")
```
  LikeLike
  - Jim Randell 11:57 am on 31 August 2026 Permalink | Reply
    Ha!
    
    I’d just written a program to look for triangles using a Pell’s equation. But it just ends up doing a brute force search.
    
    If L is split into (L/2 − x, L/2 + x) then the area of the triangle with S is given by:
    
    (4A)² = (L + S)(L − S)(S + 2x)(S − 2x)
    16A² = (L² − S²)(S² − 4x²)
    ⇒
    16A² + 4(L² − S²)x² = (L² − S²)S²
    
    which is a form of Pell’s equation.
```
from enigma import (ediv, sq, printf)
import pells

(S, L, D) = (70, 98, 504)
hL = ediv(L, 2)  # only works for even L

# solve the Pell's equation a.X^2 + b.Y^2 = c
d = sq(L) - sq(S)
(a, b, c) = (16, 4 * d, d * sq(S))
printf("[a={a} b={b} c={c}]")

# find solutions for L = (hL + x, hL - x)
for (A, x) in pells.diop_quad(a, b, c):
  if not (A > 0): continue
  (L1, L2) = (hL - x, hL + x)
  printf("tri({L1}, {L2}, {S}) -> area {A}")
```
    Even if we set [[ pells.cornacchia_threshold = 0 ]], if we set the environment variable PY_ENIGMA=v we see:
```
% PY_ENIGMA=v python3 teaser3336pells.py
[a=16 b=18816 c=23049600]
[pells] brute forcing 33 values
tri(20, 78, 70) -> area 672
tri(24, 74, 70) -> area 840
tri(30, 68, 70) -> area 1008
tri(42, 56, 70) -> area 1176
```
    LikeLike
    - Frits 1:15 pm on 1 September 2026 Permalink | Reply
      Using A = 14p my formula changes to:
      
      for (x, A) in pells.diop_quad(49, 6, 8643600): if not (A > 0): continue ......
      
      It generates the same 4 cases.
      
      LikeLike
- Alex.T.Sutherland 1:57 pm on 1 September 2026 Permalink | Reply
  
  This puzzle reminds me of Heronian triangles (triangles with integer sides
  and integer area).
  Method :-
  Create a list of pairs of integer sides (a,b) each pair summing to 98.
  (49 pairs each pair-sum is even.This is a requirement.The periphery must be even).
  Append the 70″ side (c) to each pair. (a b c).
  Calculate the half periphery for each triangle (s) (if possible).
  Calculate the area of each triangle (again if possible) using Heron’s formula.
  Area = sqrt(s*(s-a)*(s-b)*(s-c)).
  Extract those that are integer.
  With the previous data I have obtained 4 such triangles with two fitting
  the 504 requirement Hence the answer for the shortest piece of cane.
  Curiosity:- The sum of the digits in each of the areas was the same.
  Time : – < 1ms
  
  LikeLike

Jim Randell 4:36 pm on 28 August 2026 Permalink | Reply
Tags: by: W S Graff-Baker ( 4 )

Teaser 2385: [Lucky numbers]

From The Sunday Times, 8th June 2008 [link]

Anne is one year older than Brenda, who is one year older than Connie. Each of them wants to find a “lucky number”, namely a three-digit number that is a multiple of their age and whose digits add to their age.

One of them is very lucky and has a choice of lucky numbers; one is unlucky and there is no such number; for the other girl, there is a unique lucky number.

What is that unique lucky number?

This puzzle was originally published with no title.

[teaser2385]

Jim Randell 4:37 pm on 28 August 2026 Permalink | Reply
The following Python program finds candidate 3-digit lucky numbers, and groups them by age. It then looks for ages with a unique lucky number, and examines the neighbourhood of these to find viable solutions.

It runs in 75ms. (Internal runtime is 731µs).
```
from enigma import (irange, dsum, group, item, printf)

# generate lucky numbers
def generate():
  # consider 3-digit numbers
  for n in irange(100, 999):
    # that are multiples of their digit sum
    d = dsum(n)
    if n % d == 0:
      yield (n, d)

# collect lucky numbers by digit sum
g = group(generate(), by=item(1), f=item(0))

# check for 3 ages; k is unique, one of x, y has no values; the other has many
def check(k, x, y):
  (ks, xs, ys) = (g.get(z, []) for z in (k, x, y))
  if len(ks) != 1: return
  if len(xs) == 0 and len(ys) > 1:
    printf("one = {k} {ks}; none = {x} {xs}; many = {y} {ys}")
  if len(ys) == 0 and len(xs) > 1:
    printf("one = {k} {ks}; none = {y} {ys}; many = {x} {xs}")

# look for unique lucky numbers
for k in sorted(g.keys()):
  # and check the neighbours
  check(k, k + 1, k + 2)
  check(k, k - 1, k + 1)
  check(k, k - 2, k - 1)
```
There are three possible sets of ages:

Anne = 2 (2 lucky numbers = {110, 200})
Brenda = 1 (1 lucky number = {100})
Connie = 0 (no lucky number)

Anne = 21 (4 lucky numbers = {399, 588, 777, 966})
Brenda = 20 (no lucky number)
Connie = 19 (1 lucky number = {874})

Anne = 20 (no lucky number)
Brenda = 19 (1 lucky number = {874})
Connie = 18 (25 lucky numbers = {
198, 288, 378, 396, 468, 486, 558, 576, 594, 648, 666, 684, 738, 756, 774, 792, 828, 846, 864, 882, 918, 936, 954, 972, 990
})

Presumably we are to discard the first of these sets as the girls are too young to be interested in lucky numbers (or at least some of them are). (But you could argue that “100” is an acceptable answer to the puzzle).

And so we are left with the final two sets, and in either case the unique lucky number is the same.

Solution: The unique lucky number is 874.

LikeLike

Ruud 7:21 am on 29 August 2026 Permalink | Reply

import istr


def luckynumbers(age):
    return [n3 for n3 in istr.range(istr.ceil(100, age), 1000, age) if sum(n3) == age] if age else []


for age0 in range(100):
    if len({min(len(luckynumbers(age)), 2) for age in range(age0, age0 + 3)}) == 3:
        for age, name in enumerate("Anna Brenda Connie".split(), age0):
            print(f"{name:>7}", "age=", age, "lucky numbers=", *luckynumbers(age))
        print()

LikeLike

Jim Randell 9:28 am on 29 August 2026 Permalink | Reply

@Ruud: There are some simple changes you could make to improve your program.

1. Anne is the eldest and Connie is the youngest, you should swap the names round to match.

2. The maximum possible age with a lucky number is 9+9+9 = 27, so you only need to check ages up to 28.

3. The code recalculates the same lucky numbers multiple times, you could cache the results (e.g. using the [[ @cache ]] decorator).

Together these give the correct output for the puzzle and reduce the internal runtime from 370ms to 86ms.

Or, the same approach using the enigma.py library has an internal runtime of just 2.5ms:

from enigma import (irange, dsum, seq2str, cache, printf)

# calculate lucky numbers for a particular age
@cache
def lucky(n):
  if n == 0: return []
  # look for 3-digit multiples of n with a digit sum of n
  return list(x for x in irange.round(100, 999, step=n, rnd='I') if dsum(x) == n)

for k in irange(0, 26):
  ages = (k + 2, k + 1, k)  # (A, B, C)
  # look for 3 consecutive ages that give 0, 1, many lucky numbers
  ns = set(len(lucky(n)) for n in ages)
  if not (len(ns) == 3 and ns.issuperset({0, 1})): continue
  # output solution
  for (a, name) in zip(ages, ["Anna", "Brenda", "Connie"]):
    ns = lucky(a)
    printf("{name}: age {a} -> {n} lucky numbers {ns}", n=len(ns), ns=seq2str(ns, enc="{}"))
  printf()

LikeLike

Ruud 1:59 pm on 29 August 2026 Permalink | Reply

With Jim’s performance improvement suggestions:

import istr
import functools


@functools.cache
def luckynumbers(age):
    return [n3 for n3 in istr.range(istr.ceil(100, age), 1000, age) if sum(n3) == age] if age else []


for age0 in range(28):
    if len({min(len(luckynumbers(age)), 2) for age in range(age0, age0 + 3)}) == 3:
        for age, name in enumerate("Connie Brenda Anne".split(), age0):
            print(f"{name:>7}", "age=", age, "lucky numbers=", *luckynumbers(age))
        print()

Thanks, Jim

LikeLike

Frits 6:18 pm on 29 August 2026 Permalink | Reply

from enigma import SubstitutedExpression

# the alphametic puzzle
p = SubstitutedExpression(
  [
    # three ages AB, CD and EF (also allow for age 28)
    "3 <= AB <= 26",
    "AB + 1 = CD",
    
    # three-digit numbers 
    "(p := len(s := [x for x in range(4 * AB, 1000, AB)" + 
    " if x > 99 and x // 100 + (x % 100) // 10 + x % 10 == AB])) >= 0",
    "(q := len(t := [x for x in range(4 * CD, 1000, CD)" +
    " if x > 99 and x // 100 + (x % 100) // 10 + x % 10 == CD])) >= 0",
    "not {p, q}.isdisjoint({0, 1})",
    
    "CD + 1 = EF",
    "(r := len(u := [x for x in range(4 * EF, 1000, EF)" +
    " if x > 99 and x // 100 + (x % 100) // 10 + x % 10 == EF])) >= 0",
    
    "{0, 1}.issubset({p, q, r})",
    # one has a choice of lucky numbers
    "p + q + r >= 3",  
  ],
  answer="(AB, CD, EF), (p, q, r), sorted((s, t, u), key=len)", 
  d2i=dict([(k, "A") for k in range(3, 10)]),
  distinct="",
  reorder=0,
  verbose=0,    # use 256 to see the generated code
)

sols = set()
# print answers
for _, _, ans in p.answers():
  sols.add(str(ans[1][0]))

print("answer:", ' or '.join(sols))

LikeLike

Frits 7:26 pm on 29 August 2026 Permalink | Reply

from math import ceil

# digit sum
dsum = lambda n: sum(int(x) for x in str(n))

d = dict()

for age in range(3, 28):
  # valid three digit numbers
  for n in range(age * ceil(100 / age), 1000, age):
     if dsum(n) == age:
       if age in d:
         d[age] = 2
         break # 2 three digit numbers is enough
       else:  
         d[age] = n

sols = set()
for age, v in d.items():
  if v < 3: continue
  # check if ages of connected girls have counts 0 and 2
  for connie in range(age - 2, age + 1):
    # check for an unlucky girl
    if all(n in d for n in range(connie, connie + 3)): continue
    # check for a lucky girl
    if all(n not in d or d[n] != 2 for n in range(connie, connie + 3)): 
      continue
    
    sols.add(str(d[age]))
    
print("answer:", ' or '.join(sols))

LikeLike

Jim Randell 6:51 am on 23 August 2026 Permalink | Reply
Tags: by: John Owen ( 35 )
Teaser 3335: Trish tries triathalon
From The Sunday Times, 23rd August 2026 [link] [link]

The first two legs of our non-standard Triathlon comprise a run across a field then a swim across a lake. The lake’s parallel shores run from west to east; the starting point for the run is a whole number of metres north of the lake’s northern shore and 1,600 metres north of the lake’s southern shore. The exit from the lake is at a fixed point (a whole number of metres further east than the starting point), but competitors may choose their point of entry to the lake.

Trish chooses her entry point so as to minimise the time she will take for the two legs, knowing that she runs six times as fast as she swims. Interestingly, this makes the two legs the same whole number of metres long.

How long?

[teaser3335]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Alex.T.Sutherland, Frits, and Jim Randell are discussing. Toggle Comments
- Jim Randell 7:39 am on 23 August 2026 Permalink | Reply
  This Python program considers possible triangles for the leg through the field, and then finds a corresponding triangle for the leg through the lake, and checks that the choice of entry point to the lake gives a (locally) minimal total time.
  
  I am assuming X, Y, x₁, x₂, y₁, y₂, h₁, h₂ are all (non-negative) integer distances (we know at least some of them are, and we do find a single solution with this assumption).
  
  It runs in 78ms. (Internal runtime is 4.7ms).
```
from enigma import (pythagorean_triples, hypot, printf)

# collect pythagorean triples
d = dict()
for (a, b, c) in pythagorean_triples(3000):
  d[(c, a)] = b
  d[(c, b)] = a

# consider possible triangles for the field
for ((h, y1), x1) in d.items():
  # find a correspondong triangle for the lake
  y2 = 1600 - y1
  x2 = d.get((h, y2))
  if x2 is None: continue

  # check (x1, x2) split gives the minimum time, by moving the split slightly
  t = 7 * h
  if hypot(x1 + 1, y1) + 6 * hypot(x2 - 1, y2) < t: continue
  if hypot(x1 - 1, y1) + 6 * hypot(x2 + 1, y2) < t: continue

  # output solution
  printf("h={h} [x1={x1} x2={x2} (X={X}); y1={y1} y2={y2} (Y={Y})]", X=x1 + x2, Y=y1 + y2)
```
  Solution: The first two legs were 1450 metres each.
  
  The actual distances being:
  
  x₁ = 1440, y₁ = 170, h₁ = 1450
  x₂ = 240, y₂ = 1430, h₂ = 1450
  X = x₁ + x₂ = 1680, Y = y₁ + y₂ = 1600
  
  LikeLike
  - Jim Randell 10:07 am on 23 August 2026 Permalink | Reply
    Paths with minimal time obey Snell’s Law / Fermat’s Principle of Least Time [@wikipedia], so:
    
    sin(𝛉₁) / sin(𝛉₂) = 6
    ⇒
    x₁ / h₁ = 6 . x₂ / h₂
    
    And in this case the leg distances (h₁ and h₂) are the same, so:
    
    x₁ = 6 . x₂
    
    The following Python program has an internal runtime of 5ms.
```
from enigma import (pythagorean_triples, union, printf)

# collect pythagorean triples (<side>, <other-side>, <hypotenuse>)
tris = union({(a, b, c), (b, a, c)} for (a, b, c) in pythagorean_triples(3000))

# consider possible triangles for the lake
for (x2, y2, h) in tris:
  # find a corresponding triangle for the field
  (x1, y1) = (6 * x2, 1600 - y2)
  # is it a valid triangle?
  if (x1, y1, h) in tris:
    # output solution
    printf("h={h} [x1={x1} x2={x2} (X={X}); y1={y1} y2={y2} (Y={Y})]", X=x1 + x2, Y=y1 + y2)
```
    Manually:
    
    Using the equations:
    
    y₁ + y₂ = 1600
    x₁ = 6 x₂
    (x₁)² + (y₁)² = (x₂)² + (y₂)²
    
    we derive:
    
    y₂ = (7/640)(x₂)² + 800
    
    For y₂ to be an integer (required), x₂ must be an integer multiple of 80 (and all the values assumed to be integers must be integers):
    
    x₂ = 80 ⇒ y₂ = 870; h is not an integer
    x₂ = 160 ⇒ y₂ = 1080; h is not an integer
    x₂ = 240 ⇒ y₂ = 1430; h = 1450
    x₂ = 320 ⇒ y₂ = 1920; y₂ is too big, so we can stop
    
    Just one of these gives a viable solution to the puzzle.
    
    Or programatically (with an internal runtime of 130µs):
```
# consider possible x2 values
for x2 in irange(80, inf, step=80):
  # calculate x1, y2, y1, h
  x1 = 6 * x2
  y2 = ediv(7 * sq(x2), 640) + 800
  y1 = 1600 - y2
  if y1 < 0: break
  h = ihypot(x1, y1)
  if h is None: continue
  assert (h == ihypot(x2, y2))
  # output solution
  printf("h={h} [x1={x1} x2={x2} (X={X}); y1={y1} y2={y2} (Y={Y})]", X=x1 + x2, Y=y1 + y2)
```
    LikeLike
- Frits 10:40 pm on 23 August 2026 Permalink | Reply
  
  Like manual solver John Crabtree I have also ended up with just 3 cases to check (in my case the squares lower than 11). Maybe later I can get it down to only 1 case.
  
  LikeLiked by 1 person
- Alex.T.Sutherland 12:59 pm on 26 August 2026 Permalink | Reply
  
  Using J.Randell’s diagram previously given.
  Start = [0 1600].
  [x y] are the co-ords of the lake entry point (These are integers )
  From the the two triangles the following expression can be derived :-
  35*(x^2) + 3200*y – 1600^2 = 0.
  Solving this gives 3 possible sets for [x y].
  Only one set allows an equal integer value for the hypotenuses
  Answer :- The sum of the 1st two digits = 3rd digit.
  Time :- < 2ms
  
  LikeLike

Jim Randell 3:25 pm on 19 August 2026 Permalink | Reply
Tags: by: Grok

Brain-Teaser 806: Mad tea-party

From The Sunday Times, 2nd January 1977

There was a large table set out under a tree in front of the house, and the March Hare and the Hatter were having tea at it; a Dormouse was sitting between them.

“Why are there so many tea things put out here?” asked Alice.

“Because it’s always tea-time” said the Hatter with a sigh, “and we’ve no time to wash the things between whiles”.

“Then you keep moving round, I suppose?” said Alice.

“Exactly so” said the Hatter. “When the things are used up, each of us moves a different number of spaces, clockwise, although each keeps his own number for all the moves”.

“No one moves more than half-way round, of course, and no one occupies a place that has already been used. On each occasion, the March Hare moves twice as many places as the Dormouse and myself put together”.

“Unfortunately”, he added, “when we make the next move, we’ll all be back where we started, having used up every place”.

What is the minimum possible total number of places at the table?

This puzzle was included in the book The Sunday Times Book of Brain-Teasers: Book 2 (1981, edited by Victor Bryant and Ronald Postill).

This puzzle is missing from The Sunday Times digital archive, so the puzzle text is taken from the book.

[teaser806]

Jim Randell 3:26 pm on 19 August 2026 Permalink | Reply

The number of place settings must be a multiple of 3. And the number of places jumped by the March Hare must be a multiple of 2 (at least 6).

This Python program considers possible numbers of place settings, and then looks for possible jumps for the March Hare (MH), Hatter (H) and Dormouse (D), such that their paths take them around non-overlapping collections of place settings.

It runs in 72ms. (Internal runtime is 0.8ms).

from enigma import (Enumerator, irange, inf, divf, decompose, seq_all_different, printf)

# calculate positions
pos = lambda n, start, jump: list((start + i * jump) % n for i in irange(n // 3))

# solve for a table with <n> places
def solve(n):
  # choose jumps for the March Hare (less than 1/2 way; multiple of 2)
  for MH in irange(6, divf(n, 2), step=2):
    psMH = pos(n, 0, MH)
    if not seq_all_different(psMH): continue
    # jumps of the Dormouse and Hatter (together are half MH)
    for (D, H) in decompose(MH // 2, 2, increasing=0, sep=1, min_v=1):
      # calculate sequences for each
      psD = pos(n, 1, D)
      psH = pos(n, 2, H)
      # check all positions are used
      if not seq_all_different(psD, psH, psMH): continue
      yield ((MH, D, H), (psMH, psD, psH))

# consider the total number of places (must be a multiple of 3)
for n in irange(6, inf, step=3):
  # look for viable scenarios
  ss = Enumerator(solve(n))
  for ((MH, D, H), (psMH, psD, psH)) in ss:
    # output solution
    printf("n={n}")
    printf("  MH: {MH:+3d} {psMH}")
    printf("  D : {D:+3d} {psD}")
    printf("  H : {H:+3d} {psH}")
    printf()
    break  # only need one example
  if ss.count: break  # only need smallest viable n

Solution: The smallest possible table has at 39 places.

For example (numbering the place settings from 0 to 38):

The March Hare starts at place 18 and advances 18 places each turn, so visits (18, 36, 15, 33, 12, 30, 9, 27, 6, 24, 3, 21, 0).

The Hatter starts at place 8 and advances 6 places each turn, so visits (8, 14, 20, 26, 32, 38, 5, 11, 17, 23, 29, 35, 2).

The Dormouse starts at place 4 and advances 3 places each turn, so visits (4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 1).

And so Alice encounters them in positions 0, 1, 2, and on the next turn they will return to their starting positions, having used up every place setting on the table.

LikeLike

Frits 3:21 pm on 20 August 2026 Permalink | Reply

nums, sols = set(range(3)), set()

# number of moves <k> in order to get back to start_ing position
# and having used up every place (k = n // 3)
for k, _ in enumerate(iter(bool, 1), start=2): # infinite loop
  # total number of places at the table
  n = k * 3
  nums |= {n - 3, n - 2, n - 1}
  # possible number of spaces to move for (k, n)
  spaces = [i for i in range(1, (n + 1) // 2) if (i * k) % n == 0]
  # we have three tea drinkers
  if len(spaces) < 3: continue
  # viable combinations for March Hare, Hatter/Dormouse (2 * (h + d) = m)
  mhd = {m: [(h, m // 2 - h) for h in spaces[:i] if (m // 2 - h) in spaces and
             4 * h < m] for i, m in enumerate(spaces[2:], 2) if m % 2 == 0}
  
  # check al combinations of March Hare, Hatter/Dormouse (order not important)
  for m, vs in mhd.items():
    if not vs: continue
    # let March Hare start_ at position 0, <k> different spaces at the table
    if len(ms := {(i * m) % n for i in range(k)}) != k: continue
    rest_m = nums - ms
    for h, d in vs:
      seenh = set()
      # let Hatter start_ at another position 
      for start_h in rest_m:
        if start_h in seenh: continue
        # <k> different spaces at the table
        hs = {(start_h + i * h) % n for i in range(k)}
        seenh |= hs
        if not len(rest_h := (rest_m - hs)) == k: continue
        # let Dormouse start_ at another position
        start_d = min(rest_h)
        # <k> different spaces at the table
        if {(start_d + i * d) % n for i in range(k)} != rest_h: continue
        sols.add(n)
      
  if sols: 
    print("answer:", ' or '.join(str(s) for s in sols))  
    break # we only need the minimum possible total number

LikeLike

Jim Randell 7:09 am on 16 August 2026 Permalink | Reply
Tags: by: Victor Bryant ( 152 )
Teaser 3334: All square
From The Sunday Times, 16th August 2026 [link] [link]

The diagram shows a grid of three rows and five columns of identical small squares. Within that grid one can also spot some larger squares giving a grand total of 26 squares (namely fifteen 1×1 squares, eight 2×2 and three 3×3).

Now I have drawn a larger such grid (with fewer than 50 columns and even fewer rows). Within this new grid there is a grand total of exactly 10,000 squares.

How many rows and how many columns does this new grid have?

[teaser3334]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Hugo, Jim Randell, Frits, and 1 other are discussing. Toggle Comments
- Jim Randell 7:13 am on 16 August 2026 Permalink | Reply
  Here is a straighforward constructive solution, that just counts the number of squares in each candidate grid.
  
  The following Python program runs in 71ms. (Internal runtime is 1ms).
```
from enigma import (irange, printf)

# calculate the number of squares on an <a> by <b> grid
def nsquares(a, b):
  t = 0
  for k in irange(min(a, b)):
    t += (a - k) * (b - k)
  return t

# check the given arrangement
assert (nsquares(3, 5) == 26)

# target number of squares
T = 10000

# consider number of cols
for nc in irange(1, 49):
  # and number of rows
  for nr in irange(1, nc - 1):
    t = nsquares(nr, nc)
    if t < T: continue
    if t > T: break
    # output solution
    printf("rows = {nr}, cols = {nc} -> nsquares = {t}")
```
  Solution: The new grid has 24 rows and 41 columns.
  
  LikeLike
  - Jim Randell 7:38 am on 16 August 2026 Permalink | Reply
    See also: Teaser 1995, Enigma 1086.
    
    Analytically, we can show that for a grid with a rows and b columns (where a ≤ b), then the number of squares in the grid is:
    
    S(a, b) = a (a + 1) (3b − a + 1) / 6
    
    (See: OEIS A082652).
    
    So we can look for solutions to the equation:
    
    S(a, b) = 10000
    or:
    a (a + 1) (3b − a + 1) = 60000
    
    The following Python program implements a generic solver to find candidate grid dimensions given the total number of squares required. And then solves this particular puzzle by looking for grids that give exactly 10000 squares, and selecting those that meet the remaining requirements of the puzzle.
    
    It has an internal runtime of just 76µs.
```
from enigma import (divisor, tuples, printf)

# find (a, b) grids with a total of <t> squares
def solve(t):
  n = 6 * t
  # look for consecutive divisors of 6t
  for (a, a1) in tuples(divisor(n)):
    if a1 - a != 1: continue
    (b, r) = divmod(a - 1 + n // (a * a1), 3)
    if b < a: break
    if r == 0:
      yield (a, b)

# solve the puzzle
for (a, b) in solve(10000):
  if a < b < 50:
    printf("rows = {a}, cols = {b}")
```
    LikeLike
    - Frits 11:00 pm on 16 August 2026 Permalink | Reply
      
      @Jim, it doesn’t seem to happen but a check for b > a wouldn’t hurt.
      
      LikeLike
      - Jim Randell 7:41 am on 17 August 2026 Permalink | Reply
        
        @Frits: Good point. I’ve added in a check for that.
        
        LikeLike
- Ruud 7:46 am on 16 August 2026 Permalink | Reply
  Brute force:
```
for ncols in range(1, 50):
    for nrows in range(1, ncols):
        if sum((nrows - size + 1) * (ncols - size + 1) for size in range(1, nrows + 1)) == 10000:
            print(f'{nrows=} {ncols=}')
```
  LikeLike
- Hugo 11:19 am on 23 August 2026 Permalink | Reply
  
  When b = a = n, the expression becomes n(n + 1)(2n + 1)/6
  which is the sum of the squares of the integers from 1 to n.
  
  LikeLike
Jim Randell 3:14 pm on 14 August 2026 Permalink | Reply
Tags: by: Danny Roth ( 92 )
Teaser 2388: [Policy number]
From The Sunday Times, 29th June 2008 [link]

George and Martha run a large insurance company, turning over thousands of policies regularly. “This policy number is an interesting one”, commented George as he thumbed through them. “It is an N-digit number, the last of which is N“.

“That’s not all”, responded Martha. “It is also a perfect Nth power”.

What is the policy number?

This puzzle was originally published with no title.

[teaser2388]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Ruud and Jim Randell are discussing. Toggle Comments
- Jim Randell 3:14 pm on 14 August 2026 Permalink | Reply
  This Python program looks for numbers of the form n = x^N that have N digits, and the final digit is N.
  
  It runs in 62ms. (Internal runtime is 79µs).
```
from enigma import (irange, inf, powers, ifirst, lt, printf)

# consider (single digit) values for N
for N in irange(2, 9):
  # look for values x^N that are N digits with final digit N
  (nmin, nmax) = (10**(N - 1), 10**N)
  for n in ifirst(powers(1, inf, N), skip=lt(nmin), count=lt(nmax)):
    if n % 10 == N:
      printf("N={N}: n={n}")
```
  There are 2 candidate solutions:
  
  N=3: n = 7^3 = 343
  N=9: n = 9^9 = 387420489
  
  As we are told they “regularly turn over thousands of policies”, I assume we are to take the second of these as the solution.
  
  Solution: The policy number is: 387420489.
  
  LikeLike
- Ruud 4:05 pm on 14 August 2026 Permalink | Reply
```
import istr

print(*(policy for n in range(1, 10) for policy in istr.power_ofs(n, length=n) if policy[-1] == n))
```
  Result:
  LikeLike

Jim Randell 8:14 am on 11 August 2026 Permalink | Reply
Tags: by: Graham Smithers ( 90 )

Teaser 2390: [Near miss]

From The Sunday Times, 13th July 2008 [link]

Sam enjoys “alphanumeric” puzzles, which are sums where different letters consistently represent different digits. So I challenged him to find an addition sum where letter substitutions gave:

SUNDAY + TIMES = TEASER

I knew that this was impossible, but Sam found a near miss. He found the sum of two five-digit numbers where the letter substitutions gave:

SUND* + TIMES = TEASER

The * indicates where I have missed out a consonant.

What was that consonant?

This puzzle was originally published with no title.

[teaser2390]

Jim Randell 8:15 am on 11 August 2026 Permalink | Reply
Here is a solution using the [[ SubstitutedExpression.split_sum ]] solver from the enigma.py library.

We solve the alphametic expression:

SUNDX + TIMES = TEASER

where each letter stands for a different digit, except X is the same as one of D, M, N, R, S, T.

We then determine which of the consonants X is the same as and output the solution(s).

It runs in 68ms. (Internal runtime is 5.4ms).
```
from enigma import (SubstitutedExpression, peek, printf)

# the alphametic sum to solve
expr = "SUNDX + TIMES = TEASER"

p = SubstitutedExpression.split_sum(
  expr,
  # symbols other than X are distinct
  distinct="ADEIMNRSTU",
  # X is the same as one of the other consonants
  extra=["X in {D, M, N, R, S, T}"],
)

for s in p.solve(verbose=0):
  X = s['X']
  k = peek(k for k in "DMNRST" if s[k] == X)
  printf("{s}; X={k}", s=p.substitute(s, expr))
```
Solution: The consonant replaced by the * is S.

The four possible solutions to the sum SUNDS + TIMES = TEASER are:

85498 + 17308 = 102806
87498 + 15308 = 102806
85398 + 17408 = 102806
87398 + 15408 = 102806

U and I are {5, 7} (in some order), and N and M are {3, 4} (in some order). So UN + IM = 127.

LikeLike

Ruud 10:54 am on 11 August 2026 Permalink | Reply

import istr

for t, i, m, e, s, a, r in istr.permutations(range(10), 7):
    if len(sund_ := istr(":=teaser") - istr(":=times")) == 5:
        sund_.decompose("SundX")
        if t and s == S and istr("=timesarund").all_distinct() and X in (t, m, s, r, n, d):
            for letter in "tmsrnd":
                if istr(f"={letter}") == X:
                    print(f"*={letter.upper()}   {sund_} + {times} = {teaser}")

LikeLike

Frits 7:03 pm on 11 August 2026 Permalink | Reply

Optimizing code lead to a manual solution.

'''
 SUNDX
 TIMES
 ----- +
TEASER 
'''

T = 1 # obvious
E = 0 # as carry + S + T >= 10 and T = 1
D = 9 # if X + S < 10 then D would have to be 0 as well
S = 8 # S can be 8 or 9 (carry + S + T >= 10) but D is already 9

# 1 + M + N = S or M + N = 7 
# U + I + A must be even as A = U + I, M + N = 7 so T + E + S + R + D 
# must be even as well (sum symbols = 45) meaning R has to be even 
# --> X has to be even as well, now we know value 7 must be in {U, I, A}
# U + I >= 10 (as S = 8 and a carry is needed)
# if sorted(U, I, A) = [x, y, 7] then y + 7 = 10 + x or y - x = 3 and 
# y >= 5 as x >= 2 so [x, y, 7] is [3, 6, 7] or [2, 5, 7] 
# that means R can only be resp. 45 - 18 - 7 - 16 and 45 - 18 - 7 - 14 or 
# resp. 4 or 6. 
# if R = 4 (and X is 6) then value 6 is not used by symbols S, T, D, E and R
# so consonants M or N must have value 6. This is not possible as M + N = 7 
# and T = 1.
# What remains is R = 6 (and X is 8) so {U, I, A, M, N} = {2, 3, 4, 5, 7}
# a valid solution is {M, N} = {3, 4}, A = 2 and {U, I} = {5, 7}
#
# answer: consonant S

LikeLike

Jim Randell 6:47 am on 9 August 2026 Permalink | Reply
Tags: by: Stephen Hogg ( 66 )
Teaser 3333: Hey, diddle, diddle …
From The Sunday Times, 9th August 2026 [link] [link]

Kat and Fidel each held an investment bond. They were over the moon when these matured with different four-digit values (whole numbers of dollars). Unfortunately, a fraction (equivalent to under ten per cent, and the same for both bonds) was deducted as fees, leaving four-digit whole-number nett values. “Fees, what a diddle!” complained Kat. Fidel agreed, adding that in another sense each maturity value was a DIDDLE. Kat was puzzled. Fidel explained that a DIDDLE was a whole number with Different Increasing Digits (left to right) that is DivisibLe Exactly by each digit.

Later, walking his little dog, Fidel stopped at Withespoon’s “Prancing Cow” pub, where he told his friend, Dishran, these things, but no values. Dishran, an accountant, knew the “fees” fraction and calculated the values with certainty.

Find the nett values.

[teaser3333]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Frits, Ruud, and Jim Randell are discussing. Toggle Comments
- Jim Randell 7:03 am on 9 August 2026 Permalink | Reply
  This Python program runs in 70ms. (Internal runtime is 900µs).
```
from enigma import (irange, subsets, nconcat, divf, fraction, group, item, printf)

# generate possible k-digit DIDDLEs
def diddles(k):
  # consider 4 different increasing digits
  for ds in subsets(irange(1, 9), size=k, select='C'):
    # form the number
    n = nconcat(ds)
    # check it is divisible by each of the digits
    if not all(n % d == 0 for d in ds): continue
    # return the number
    yield n

# generate possible (<gross>, <net>, <fee-fraction>) values
def generate():
  # consider possible gross values (= 4-digit DIDDLEs)
  for G in diddles(4):
    # consider possible fee amounts (less than 10% of G)
    for F in irange(1, divf(G - 1, 10)):
      # return (<gross>, <net>, <fee-fraction)>)
      yield (G, G - F, fraction(F, G))

# group possible values by fee fraction
g = group(generate(), by=item(2), f=item(0, 1))

# look for a fraction that gives exactly 2 values
for ((a, b), vs) in g.items():
  if len(vs) == 2:
    printf("fee = {a}/{b} -> vs = {vs}")
```
  Solution: The net values received were: $ 1196 and $ 1311.
  
  The fees deducted amounted to 1/24 of the maturity value (so the net value was 23/24 of the maturity value).
  
  And the values of the 2 bonds were:
  
  gross = $ 1248 → net = $ 1196
  gross = $ 1368 → net = $ 1311
  
  There are only 3 candidate maturity values: 1236, 1248, 1368.
  
  And possible fractional fees are 1/12 (≈ 8.33%) and 1/24 (≈ 4.17%) which give the following values:
  
  fee = 1/12: (1236 → 1133), (1248 → 1144), (1368 → 1254)
  fee = 1/24: (1248 → 1196), (1368 → 1311)
  
  Only the second of these allows the 2 values to be deduced with certainty.
  
  LikeLike
- Ruud 8:08 am on 9 August 2026 Permalink | Reply
```
import peek
import istr
import collections

collect = collections.defaultdict(list)

for gross in istr.range(length=4):
    if gross.is_increasing() and all(gross.divided_by(c) for c in gross):
        for fraction in range(11, int(gross)):
            if gross.is_divisible_by(fraction):
                collect[fraction].append(gross)
for fraction, grosses in collect.items():
    if len(grosses) == 2:
        peek(fraction)
        for gross in grosses:
            nett = gross - gross // fraction
            peek(nett, gross)
```
  LikeLike
  - Ruud 8:12 am on 9 August 2026 Permalink | Reply
    
    `divided_by` could also read `is_divisible_by` which is arguably a bit more clear.
    
    LikeLike
  - Frits 9:01 am on 12 August 2026 Permalink | Reply
    
    @Ruud, you only seem to consider unit fractions.
    
    LikeLike
- Frits 12:45 pm on 9 August 2026 Permalink | Reply
  I didn’t want to publish a similar solution.
```
from math import gcd
from itertools import combinations
from functools import reduce

d2n = lambda s: reduce(lambda x,  y: 10 * x + y, s)

# 4-digit maturity values for Kat and Fidel
mvs = [mv for c in combinations(range(1, 10), 4) 
        if all((mv := d2n(c)) % dgt == 0 for dgt in c)]

# assume (minimal) fraction is a / b then k % b = 0 and f % b = 0
# collect all valid denominators <b> that can be factors of <k> and <f>
for b in {gcd(k, f) for k, f in combinations(mvs, 2)}:
  # check all fractions a / b
  for a in range(1, b):
    nett = [v - dm[0] for v in mvs if (dm := divmod(a * v, b))[1] == 0 and
                                       dm[0] <= v // 10]
    if len(nett) == 2:
       print("answer:", nett)  
```
  LikeLike

Jim Randell 3:23 pm on 7 August 2026 Permalink | Reply
Tags: by: Andrew Skidmore ( 94 )

Teaser 2389: [Piles of cards]

From The Sunday Times, 6th July 2008 [link]

Dan takes a standard pack of playing cards and divides them into three unequal piles. From the first he picks a card at random. It turns out to be black, and indeed the ratio of black to red in that pile was 2 to 1. If he placed that black card in the second (smaller) pile, then the ratio of red to black in that pile would be 4 to 1. If, instead, he placed it in the third pile (more black than red), then the ratio of black to red would be some other whole number to 1.

How many cards were there in each pile?

This puzzle was published in The Sunday Times using the style that continued until 26th January 2014 (Teaser 2679).

This puzzle was originally published with no title.

[teaser2389]

Jim Randell 3:24 pm on 7 August 2026 Permalink | Reply

Here is a straightforward programmed solution.

This Python program runs in 70ms. (Internal runtime is 65µs).

from enigma import (irange, div, printf)

N = 26  # number of red/black cards

# consider the number of red cards in pile 1
for r1 in irange(1, N):
  # pile 1 is black:red = 2:1
  b1 = 2 * r1
  if b1 > N: break

  # consider the number of black cards in pile 2
  for b2 in irange(0, N - b1):
    # if a black card is added to pile 2, the ratio is black:red = 1:4
    r2 = 4 * (b2 + 1)
    # pile 1 has more cards than pile 2
    (n1, n2) = (b1 + r1, b2 + r2)
    if not (n1 > n2): break

    # calculate the number of cards in pile 3
    (b3, r3) = (N - b1 - b2, N - r1 - r2)
    # pile 3 has more black cards than red
    if not (b3 > r3 > 0): continue
    # the numbers of cards in the piles are not equal
    n3 = b3 + r3
    if n3 == n1 or n3 == n2: continue

    # if a black card is added to pile 3, the ratio is black:red = k:1
    k = div(b3 + 1, r3)
    # but k is not 4
    if k is None or k == 4: continue

    # output solution
    printf("1: {n1} ({b1}b + {r1}r); 2: {n2} ({b2}b + {r2}r); 3: {n3} ({b3}b + {r3}r); k={k}")

Solution: The first pile had 27 cards. The second pile had 19 cards. The third pile had 6 cards.

The piles are:

pile 1 = 18 black + 9 red = 27 cards (ratio = 2:1)
pile 2 = 3 black + 16 red = 19 cards (+ 1 black, ratio = 1:4)
pile 3 = 5 black + 1 red = 6 cards (+ 1 black, ratio = 6:1)

There is a second candidate solution:

pile 1 = 16 black + 8 red = 24 cards (ratio = 2:1)
pile 2 = 3 black + 16 red = 19 cards (+ 1 black, ratio = 1:4)
pile 3 = 7 black + 2 red = 9 cards (+ 1 black, ratio = 4:1)

But this is disqualified as adding a black card to pile 3 brings the black:red ratio to 8:2 = 4:1, but this ratio has to be different from the red:black ratio of pile 2.

LikeLike

Jim Randell 9:38 pm on 7 August 2026 Permalink | Reply

And using the [[ SubstitutedExpression ]] solver from the enigma.py library gives a run-file that executes in 80ms (and the internal runtime of the generated code is 180µs).

#! python3 -m enigma -rr

SubstitutedExpression

--base=27  # allows values = 1 - 26
--distinct=""

# pile 1 = A black + B red
# pile 2 = C black + D red
# pile 3 = E black + F red

# all cards are used
"A + C + E == 26"
"B + D + F == 26"

# pile 1 is 2 black to 1 red
"2 * B = A"

# pile 2 + 1 black is 4 red to 1 black
"4 * (C + 1) = D"

# pile 3 has more black than red
"E > F"

# pile 3 + 1 black is k black to 1 red; but k != 4
"ediv(E + 1, F) != 4"

# pile 1 is bigger than pile 2
"A + B > C + D"

# and pile 3 is different from 1 and 2
"E + F not in { A + B, C + D }"

# answer is the size of the piles
--answer="(A + B, C + D, E + F)"

# [optional] neaten up output
--template=""

LikeLike

Ruud 3:57 pm on 7 August 2026 Permalink | Reply

Very brute force, but still running in milliseconds …

import peek

for p1 in range(3, 52, 3):
    red1 = p1 // 3
    black1 = p1 * 2 // 3
    for p2 in range(4, 52, 5):
        red2 = (p2 + 1) * 4 // 5
        black2 = (p2 + 1) // 5
        for ratio in range(52):
            if ratio not in (2, 4):
                for p3 in range(ratio, 52, ratio + 1):
                    red3 = (p3 + 1) * 1 // (ratio + 1)
                    black3 = (p3 + 1) * ratio // (ratio + 1)
                    if p1 + p2 + p3 == 52 and p2 < p1 and black3 - 1 > red3 and len({p1, p2, p3}) == 3 and red1 + red2 + red3 == black1 + black2 + black3 - 2:
                        peek(ratio, p1, p2, p3, red1, black1, red2, black2, red3, black3)

LikeLike

Frits 7:21 pm on 8 August 2026 Permalink | Reply

'''
E + 1 = k . F (k != 4) 
27 - A - C = k . (26 - B - D)
k =  (27 - 2B - C) / (22 - B - 4C) 

so B < 22 - 4C and B < (26 - C) / 2 as k > 1

E > F
26 - A - C > 26 - B - D  or  -2B - C > -B - 4C - 4  or  B < 3C + 4

5C + 4 < 3B < 3.(22 - 4C)
5C + 4 equals 66 - 12C if C = 62/17 = 3.65
'''
for C in range(1, 4):
  D = 4 * (C + 1)
  # A + B > C + D  or 3B > 5C + 4  
  mnB = (5 * C + 4) // 3 + 1 
  mxB = min((3 * C + 4, 22 - 4 * C, ceil((26 - C) / 2)))
  
  # C even -> B odd (results from k formula)
  if (stpB := 2 -  C % 2) == 2:
    mnB += (mnB % 2 == 0)
  for B in range(mnB, mxB, stpB):
    # E + 1 = k.F        (k != 4) 
    k, r = divmod(27 - (A := 2 * B) - C, 22 - B - 4 * C)
    if r or k == 4 or k < 2: continue
    E = 26 - A - C
    F = 26 - B - D
    if not (E > F > 0): continue
    # three unequal piles
    if (p3 := E + F) in {p1 := A + B, p2 := C + D}: continue
    print(f"answer: {p1}, {p2} and {p3}")

LikeLike

Jim Randell 2:35 pm on 5 August 2026 Permalink | Reply
Tags: by: Nick MacKinnon ( 61 )

Teaser 2396: [Consecutive numbers]

From The Sunday Times, 24th August 2008 [link]

Consider the numbers 24 and 25. The first has an even number of factors (8) and the second has an odd number (3).

Today you need to find a higher pair of consecutive numbers (each less than a million), such that once again the sum of their numbers of factors is odd; the number of factors of their sum is odd; the odd number has an odd number of odd digits; the even number has an even number of even digits.

What is the odd number of the pair?

This puzzle was originally published with no title.

[teaser2396]

Jim Randell 2:36 pm on 5 August 2026 Permalink | Reply

We can attack the problem in a straightforward fashion, by just searching for a viable pair of consecutive numbers, but it is not very efficient.

The following Python program runs in 1.47s (using PyPy).

from enigma import (irange, tau, tuples, nsplit, printf)

# generate (number, tau) pairs
def generate(a, b):
  for n in irange(a, b):
    yield (n, tau(n))

# check parity constraint for numbers <ns>
def check(ns):
  for n in ns:
    # parity of n
    p = n % 2
    # count the number of digits in n, with parity p
    k = sum(1 for d in nsplit(n) if d % 2 == p)
    # the number of digits should have parity p
    if k % 2 != p: return
  # looks good
  return True

# consider consecutive pairs of numbers
for ((a, ta), (b, tb)) in tuples(generate(25, 999999), 2):
  # the sum of their numbers of factors is odd
  if not ((ta + tb) % 2 == 1): continue
  # the number of factors of their sum is odd
  if not (tau(a + b) % 2 == 1): continue
  # the odd number has an odd number of odd digits
  # the even number has an even number of even digits
  if not check((a, b)): continue

  # output solution
  printf("({a}, {b})")

But with a bit of analysis we can do better:

Divisors of a number come in pairs, so most numbers have an even number of divisors. The exception is when one of the divisor pairs is repeated, (i.e. (d, d)) and so the number itself is a perfect square (i.e. d²).

The sum of the number of divisors of the numbers is odd, so one of the numbers (n or (n + 1)) must be a perfect square.

So the numbers are either (x², x² + 1) or (x² − 1, x²).

And the sum of the numbers must also have an odd number of divisors, so must be an odd perfect square.

So we either have:

(n, n + 1) = (x², x² + 1) and
2x² + 1 = (2y + 1)²
⇒
x² = 2y(y + 1)

or:

(n, n + 1) = (x² − 1, x²) and
2x² − 1 = (2y + 1)²
⇒
x² = 2y(y + 1) + 1

The following Python program starts by considering increasing y values, and calculates corresponding x values.

It has an internal runtime of just 548µs.

from enigma import (irange, inf, isqrt, sq, nsplit, printf)

# check parity constraint for numbers <ns>
def check(ns):
  for n in ns:
    # parity of n
    p = n % 2
    # count number of digits in n with parity p
    k = sum(1 for d in nsplit(n) if d % 2 == p)
    # the number of digits should also have parity p
    if k % 2 != p: return False
  # looks good
  return True

# consider increasing y values
for y in irange(1, inf):
  Y = 2 * y * (y + 1)
  # calculate viable x^2 values
  x2 = sq(isqrt(Y + 1))
  if x2 > 999999: break
  # calculate the numbers we are interested in
  if x2 == Y + 1: ns = (x2 - 1, x2)
  elif x2 == Y: ns = (x2, x2 + 1)
  else: continue
  # check and output solution
  if check(ns):
    printf("{ns}")

Solution: The odd number in the pair is 970225.

The pair of numbers is: (970224, 970225) = (985² − 1, 985²).

970224 (even) has 4 even digits, and 80 divisors.

970225 (odd) has 3 odd digits, and 9 divisors.

The sum of the numbers of divisors is 89 (odd)

The sum of the numbers, 1940449, also has 9 divisors (odd).

We can use even more analysis to find larger solutions with the required property efficiently:

By writing X = 2x, Y = 2y + 1 we can rewrite the equations as:

X² − 2Y² = ±2

These are forms of Pell’s equation, that can be solved using the pells.py library [link].

The following Python program can be used to find much larger solutions to the puzzle (default is the first 10).

from enigma import (sq, nsplit, merge, first, fail, arg, printf)
import pells

# check parity constraint for numbers <ns>
def check(ns):
  for n in ns:
    # parity of n
    p = n % 2
    # count number of digits in n with parity p
    k = sum(1 for d in nsplit(n) if d % 2 == p)
    # the number of digits should also have parity p
    if k % 2 != p: return False
  # looks good
  return True

def solve():
  # consider solutions to the pells equation: X^2 - 2.Y^2 = [+2, -2]
  for (X, Y) in merge(pells.diop_quad(1, -2, k) for k in [+2, -2]):
    # recover the k value (+2 or -2)
    k = X*X - 2*Y*Y
    # calculate the numbers we are interested in
    x2 = sq(X//2)
    if k == -2: ns = (x2, x2 + 1)
    elif k == +2: ns = (x2 - 1, x2)
    else: fail()
    # check and return solution
    if check(ns): yield ns

# find the smallest N solutions
N = arg(10, 0, int)
for ns in first(solve(), N):
  printf("{ns}")

LikeLike

Ruud 8:01 am on 6 August 2026 Permalink | Reply

from functools import cache


@cache
def number_of_digits_with_parity(n, parity):
    return sum(c in '13579' for c in str(n)) if parity else sum(c in '02468' for c in str(n))


@cache
def number_of_factors(n):
    return len(set(x for tup in ([i, n // i] for i in range(1, int(n**0.5) + 1) if n % i == 0) for x in tup))


for i1, i2 in zip(range(25, 1000000), range(26, 1000000)):
    if (
        (number_of_factors(i1) + number_of_factors(i2)) % 2 == 1
        and number_of_factors(i1 + i2) % 2 == 1
        and number_of_digits_with_parity(i1, 0) % 2 == 0
        and number_of_digits_with_parity(i2, 1) % 2 == 1
    ):
        print(i1, i2)

LikeLike

Jim Randell 10:13 am on 6 August 2026 Permalink | Reply
@Ruud: How do you know the smaller number is the even one?

Perhaps the tests should be:
```
number_of_digits_with_parity(i1, i1 % 2) % 2 == i1 % 2 and
number_of_digits_with_parity(i2, i2 % 2) % 2 == i2 % 2
```
(In fact, from the recurrence relations for solutions to the corresponding Pell’s equations we can show that solution pairs are always (<even>, <odd>), so a brute force approach won’t miss solutions if it just consider these pairs).

LikeLike
- ruudvanderham 10:15 am on 6 August 2026 Permalink | Reply
  
  Yes, you are right. I had the test originally, but removed it later by mistake.
  
  LikeLike

Jim Randell 6:41 am on 2 August 2026 Permalink | Reply
Tags: by: Colin Vout ( 40 )
Teaser 3332: As easy as one, two, three
From The Sunday Times, 2nd August 2026 [link] [link]

“telladom shoodlat quoz veedku quoz” means 87.

“rimjy veedku rimjy ump telladom” means 50.

Counting is quite easy in this traditional dialect. Words mean different positive whole numbers called “minor” or “major”. All minors have lower values than all majors. In the counting name for a number, two minors never occur in succession, and the majors occur in order of strictly decreasing value (so majors cannot be repeated). A minor followed by a major means the product of those two values (although 1 is never used as a minor here). The value of the whole expression is the sum of all products and all the other individual values.

So an English-ish example, with all “majors” underlined, would be “thousand six ten six” for 1066.

What are the values of quoz, rimjy, shoodlat, telladom, ump, veedku (in that order)?

[teaser3332]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Alex.T.Sutherland, Jim Randell, and Frits are discussing. Toggle Comments
- Jim Randell 8:03 am on 2 August 2026 Permalink | Reply
  Here is a Python solution that finds the required answer.
  
  It does, however, make the assumption that the minor values are no more than 10, and that the major values are no more than 20. (Which are not unreasonable, given the numbers specified).
  
  It first determines which symbols can be minor and major, using the sequences given, and then assigns values to each symbol such that the required values are made.
  
  The following Python program runs in 190ms. (Internal runtime is 108ms).
```
from enigma import (
  irange, subsets, tuples, diff, seq_all_different, is_increasing, rev, map2str, printf
)

# symbols used
syms = "QRSTUV"

# numbers and their values
nums = { "TSQVQ": 87, "RVRUT": 50 }

# evaluate <num> using minor/major values from <vm> and <vM>
def evaluate(num, vm, vM):
  (r, p) = (0, 0)
  for k in num:
    # is it a minor?
    v = vm.get(k)
    if v is not None:
      assert (not p) # can't have 2 minors in a row
      # this is a minor, just remember it
      p = v
    else:
      # this is a major
      v = vM.get(k)
      # if there is a previous minor, multiply it up
      if p: v *= p
      r += v
      p = 0
  # is there is a standalone minor at the end?
  if p: r += p
  return r

# check given example
assert (evaluate('M6X6', { '6': 6 }, { 'M': 1000, 'X': 10 }) == 1066)

# find min/maj values that give assignments in <nums>
def solve(mins, majs, nums, u_min=10, u_maj=20):
  # consider possible increasing max minor values
  for m in irange(len(mins) + 1, u_min):
    # allocate the remaining minor values
    for ss in subsets(irange(2, m - 1), size=len(mins) - 1, fn=list):
      ss.append(m)
      # allocate minor values
      for ms in subsets(ss, size=len, select='P'):
        vm = dict(zip(mins, ms))

        # now choose major values
        for Ms in subsets(irange(m + 1, u_maj), size=len(majs)):
          vM = dict(zip(majs, Ms))
          # check the sums
          if not all(evaluate(num, vm, vM) == n for (num, n) in nums.items()): continue
          # return the minor/major values
          yield (vm, vM)

# check minor/major assignments are compatible with the specified numbers nums
def check(num, mins, majs):
  # there are never 2 minor symbols together
  if any(mins.issuperset(t) for t in tuples(num, 2)): return False
  # majors appear in order
  if not seq_all_different(diff(num, mins)): return False
  # looks OK
  return True

# choose which of the symbols are minor
for mins in subsets(sorted(set(syms)), fn=set):
  majs = diff(syms, mins)
  # check for viable minor/major assignment
  if not all(check(num, mins, majs) for num in nums.keys()): continue

  # choose an ordering for the major values (largest to smallest)
  for mvs in subsets(majs, size=len, select='P'):
    # check that majors appear in order in each sum
    if not all(is_increasing((mvs.index(x) for x in diff(num, mins)), strict=1) for num in nums.keys()): continue
    # find values for minor/major symbols
    for (vm, vM) in solve(sorted(mins), rev(mvs), nums):
      # output solution
      printf("minor = {vm}; major = {vM}", vm=map2str(vm), vM=map2str(vM))
```
  Solution: The values are: quoz = 5, rimjy = 3, shoodlat = 16, telladom = 2, ump = 6, veedku = 10.
  
  The minors are: quoz, rimjy, telladom (values: 5, 3, 2).
  
  The majors are: shoodlat, ump, veedku (values: 16, 6, 10).
  
  The numbers are then:
  
  “telladom shoodlat quoz veedku quoz” = (2 × 16) + (5 × 10) + 5 = 87.
  “rimjy veedku rimjy ump telladom” = (3 × 10) + (3 × 6) + 2 = 50.
  
  With some analysis we can show that the above is the only solution.
  
  For the sequences TSQVQ and RVRUT, using the fact that majors cannot be repeated in a sequence we see Q and R must be minors, and we cannot have 2 consecutive minors, so S, U, V must be majors. Which only leaves T.
  
  If T is a major, then, as majors are strictly decreasing in each sequence we have:
  
  T > S > V > U > T
  
  which is not possible, and so T must be a minor.
  
  (In my program above, these assignments are determined by considering the symbol sequences given).
  
  The numbers are therefore:
  
  (T×S) + (Q×V) + Q = 87
  (R×V) + (R×U) + T = 50
  
  From these we can determine that T ∈ [2..8], and so we can perform an exhaustive search to find the required answer.
  
  The following Python program has an internal runtime of 210µs.
```
from enigma import (irange, divisors_pairs, decompose, div, printf)

# minor = QTR; major = S > V > U
#
# R(V + U) + T = 50
# T.S + Q(V + 1) = 87

# solve: R(V + U) + T = 50
for T in irange(2, 8):
  for (R, UV) in divisors_pairs(50 - T):
    if R < 2 or R == T: continue
    for (U, V) in decompose(UV, 2, increasing=1, sep=1, min_v=max(T, R) + 1):

      # solve T.S + Q(V + 1) = 87
      for Q in irange(2, U - 1):
        if Q == T or Q == R: continue
        N = 87 - Q * (V + 1)
        if N < T * (V + 1): break
        S = div(N, T)
        if S is None or not (S > V): continue

        # output solution
        printf("minor = (T={T}, R={R}, Q={Q}); major = (S={S}, V={V}, U={U})")
```
  LikeLike
  - Frits 10:47 am on 3 August 2026 Permalink | Reply
    
    @Jim,
    
    “(although 1 is never used as a minor here)”. I read this to only count when dealing with a product. This leaves value 1 still possible for a trailing minor (although in this teaser after a little analysis this is also impossible)
    
    LikeLike
    - Jim Randell 11:21 am on 3 August 2026 Permalink | Reply
      
      @Frits: Could be. I just read it as meaning that 1 does not occur as a minor in this puzzle. (Although you would presumably have to have a minor that corresponds to 1 if you want to be able to start counting at 1). But as you say, in this puzzle there is no minor that does not appear as part of a product, so we know none of the minors under consideration can be 1.
      
      LikeLike
- Alex.T.Sutherland 6:52 pm on 7 August 2026 Permalink | Reply
  
  Method:-
  1. Define minor = 0 and major =1. Pattern = binary order of the minor/major
  2. Generate a 32×5 binary matrix for numbers 0 to 31.
  3. Remove the rows containing adjacent zeros to give a matrix B (13×5).
  4. Considering the number 50.
  It must have the pattern 0 1 0 1 x.
  (The 1st and 3rd values are equal therefore cannot be a major hence are minors.
  The 2nd and 4th must be a major ,can’t be adjacent to a minor.
  The ‘x’ could be either but is less than the forth value.)
  5. Using this pattern find the list of 5 numbers (using the appropriate rules)
  that give 50. (I have a list of 20).Only needs to be calculated once.(List_50)
  
  6. Considering The number 87.
  The matrix B can be reduced by keeping only those where with the third and
  fifth digits are equal.
  B is reduced to 8×5 patterns from the 13×5.
  7. Iterate each of the 8 pattern lists with the List_50 using the numbers common to both
  as the matching criteria . ie N87(1) = N50(5) & N87(4)= N50(2).
  A unique solution is found on the first iteration.
  
  8. The answer gives the sum of the digits in both 50 & 87 as 62.
  The maximum minor value is a single digit.
  Time:- ~ 26ms
  
  LikeLike

	Jim Randell on Brainteaser 1042: Playing with…
	Jim Randell on Teaser 3339: Squaring up
	Frits on Teaser 3339: Squaring up
	Jim Randell on Teaser 3339: Squaring up
	Frits on Teaser 3339: Squaring up
	Jim Randell on Teaser 3339: Squaring up
	Frits on Teaser 2410: [Cube number…
	Jim Randell on Teaser 3338: Any way but …

Search

Recent Posts

Recent Comments

Archives

Categories

Subscribe

RSS Links

Site Stats

Meta

Recent Updates Toggle Comment Threads | Keyboard Shortcuts

Jim Randell 9:58 am on 23 September 2026 Permalink | Reply Tags: by: Alfred Moritz ( 3 )

Rate this:

Share:

Jim Randell 9:59 am on 23 September 2026 Permalink | Reply

Reply Cancel reply

Jim Randell 7:00 am on 20 September 2026 Permalink | Reply Tags: by: Peter Good ( 31 )

Rate this:

Share:

Jim Randell 7:02 am on 20 September 2026 Permalink | Reply

Jim Randell 2:16 pm on 20 September 2026 Permalink | Reply

Jim Randell 8:08 am on 23 September 2026 Permalink | Reply

Frits 4:34 pm on 21 September 2026 Permalink | Reply

Frits 1:30 pm on 20 September 2026 Permalink | Reply

Jim Randell 2:43 pm on 18 September 2026 Permalink | Reply Tags: by: Graham Smithers ( 90 )

Rate this:

Share:

Jim Randell 2:44 pm on 18 September 2026 Permalink | Reply

Frits 4:01 pm on 19 September 2026 Permalink | Reply

Jim Randell 3:24 pm on 16 September 2026 Permalink | Reply Tags: by: B T Izzard ( 4 )

Rate this:

Share:

Jim Randell 3:25 pm on 16 September 2026 Permalink | Reply

Frits 11:07 am on 17 September 2026 Permalink | Reply

Frits 12:12 pm on 17 September 2026 Permalink | Reply

Jim Randell 12:42 pm on 17 September 2026 Permalink | Reply

Jim Randell 7:10 am on 13 September 2026 Permalink | Reply Tags: by: Howard Williams ( 47 )

Rate this:

Share:

Jim Randell 7:12 am on 13 September 2026 Permalink | Reply

Jim Randell 5:22 pm on 13 September 2026 Permalink | Reply

Frits 11:28 am on 18 September 2026 Permalink | Reply

Jim Randell 3:26 pm on 18 September 2026 Permalink | Reply

Jim Randell 9:58 am on 11 September 2026 Permalink | Reply Tags: by: Victor Bryant ( 152 )

Rate this:

Share:

Jim Randell 9:59 am on 11 September 2026 Permalink | Reply

Ruud van der Ham 5:52 pm on 11 September 2026 Permalink | Reply

Frits 2:50 pm on 12 September 2026 Permalink | Reply

Ruud van der Ham 3:49 am on 13 September 2026 Permalink | Reply

Frits 9:57 am on 14 September 2026 Permalink | Reply

Jim Randell 6:10 am on 6 September 2026 Permalink | Reply Tags: by: Andrew Skidmore ( 94 )

Rate this:

Share:

Jim Randell 6:12 am on 6 September 2026 Permalink | Reply

Ruud van der Ham 7:42 am on 6 September 2026 Permalink | Reply

Ruud van der Ham 12:20 pm on 6 September 2026 Permalink | Reply

Jim Randell 4:55 pm on 4 September 2026 Permalink | Reply Tags: by: Andrew Skidmore ( 94 )

Rate this:

Share:

Jim Randell 4:55 pm on 4 September 2026 Permalink | Reply

Ruud van der Ham 6:29 pm on 4 September 2026 Permalink | Reply

Frits 10:58 am on 5 September 2026 Permalink | Reply

Jim Randell 11:15 am on 2 September 2026 Permalink | Reply Tags: by: B T Izzard ( 4 )

Rate this:

Share:

Jim Randell 11:16 am on 2 September 2026 Permalink | Reply

Frits 11:14 am on 5 September 2026 Permalink | Reply

Jim Randell 7:25 am on 30 August 2026 Permalink | Reply Tags: by: Phil Jackson ( 3 ), flawed ( 58 )

Rate this:

Share:

Jim Randell 7:26 am on 30 August 2026 Permalink | Reply

Frits 10:51 am on 30 August 2026 Permalink | Reply

Ruud 12:23 pm on 30 August 2026 Permalink | Reply

Frits 11:06 am on 31 August 2026 Permalink | Reply

Jim Randell 11:57 am on 31 August 2026 Permalink | Reply

Frits 1:15 pm on 1 September 2026 Permalink | Reply

Alex.T.Sutherland 1:57 pm on 1 September 2026 Permalink | Reply

Jim Randell 4:36 pm on 28 August 2026 Permalink | Reply Tags: by: W S Graff-Baker ( 4 )

Rate this:

Share:

Jim Randell 9:58 am on 23 September 2026 Permalink | Reply
Tags: by: Alfred Moritz ( 3 )

Jim Randell 7:00 am on 20 September 2026 Permalink | Reply
Tags: by: Peter Good ( 31 )

Jim Randell 2:43 pm on 18 September 2026 Permalink | Reply
Tags: by: Graham Smithers ( 90 )

Jim Randell 3:24 pm on 16 September 2026 Permalink | Reply
Tags: by: B T Izzard ( 4 )

Jim Randell 7:10 am on 13 September 2026 Permalink | Reply
Tags: by: Howard Williams ( 47 )

Jim Randell 9:58 am on 11 September 2026 Permalink | Reply
Tags: by: Victor Bryant ( 152 )

Jim Randell 6:10 am on 6 September 2026 Permalink | Reply
Tags: by: Andrew Skidmore ( 94 )

Jim Randell 4:55 pm on 4 September 2026 Permalink | Reply
Tags: by: Andrew Skidmore ( 94 )

Jim Randell 11:15 am on 2 September 2026 Permalink | Reply
Tags: by: B T Izzard ( 4 )

Jim Randell 7:25 am on 30 August 2026 Permalink | Reply
Tags: by: Phil Jackson ( 3 ), flawed ( 58 )

Jim Randell 4:36 pm on 28 August 2026 Permalink | Reply
Tags: by: W S Graff-Baker ( 4 )

Jim Randell 6:51 am on 23 August 2026 Permalink | Reply
Tags: by: John Owen ( 35 )

Jim Randell 3:25 pm on 19 August 2026 Permalink | Reply
Tags: by: Grok

Jim Randell 7:09 am on 16 August 2026 Permalink | Reply
Tags: by: Victor Bryant ( 152 )

Jim Randell 3:14 pm on 14 August 2026 Permalink | Reply
Tags: by: Danny Roth ( 92 )

Jim Randell 8:14 am on 11 August 2026 Permalink | Reply
Tags: by: Graham Smithers ( 90 )

Jim Randell 6:47 am on 9 August 2026 Permalink | Reply
Tags: by: Stephen Hogg ( 66 )

Jim Randell 3:23 pm on 7 August 2026 Permalink | Reply
Tags: by: Andrew Skidmore ( 94 )