Recent Updates Toggle Comment Threads | Keyboard Shortcuts

  • Unknown's avatar

    Jim Randell 11:29 am on 23 October 2026 Permalink | Reply
    Tags:   

    Teaser 2343: [Video recording] 

    From The Sunday Times, 19th August 2007 [link]

    In the standard three-hour video cassette, the tape moves past the playing head at a constant speed from the stock spool to the take-up spool, which are the same size. The empty spool has a diameter of 2cm and the full spool has external diameter 8cm.

    When I started to record an item recently, the speed of rotation of the take-up spool was 40% less than that of the stock spool and the recording ended exactly at the end of the tape.

    How long was the recording?

    This puzzle was originally published with no title.

    [teaser2343]

     
    • Jim Randell's avatar

      Jim Randell 11:30 am on 23 October 2026 Permalink | Reply

      If the tape moves across the head at a constant linear speed of v.

      And at the start of recording the stock spool has a radius of s and the take up spool has a radius of t.

      Using the angular velocities 𝛚s (stock spool) 𝛚t (take-up spool), the constant velocity of the tape is given by:

      v = s . 𝛚s = t . 𝛚t

      But:

      𝛚t = 0.6 𝛚s

      Hence:

      s = 0.6 t
      ⇒
      s² = 0.36 t²

      And the total amount of tape on a full spool is:

      (4² − 1²) = 15

      And this is distributed between the spools at the start of the recording, so:

      (s² − 1²) + (t² − 1²) = 15
      ⇒
      s² + t² = 17
      ⇒
      1.36 t² = 17
      t² = 17/1.36 = 12.5

      So the proportion of tape on the take up spool at the start of the recording is:

      (t² − 1²) / 15
      = (12.5 − 1) / 15
      = 11.5 / 15
      = 138 / 180

      i.e. there is 42/180 of the tape remaining on the stock spool, and this is the tape that is used for the recording.

      The entire tape runs for 3 hours = 180 minutes, so:

      Solution: The length of the recording is 42 minutes.

      Like

  • Unknown's avatar

    Jim Randell 2:46 pm on 21 October 2026 Permalink | Reply
    Tags:   

    Brainteaser 1343: Mecca bound 

    From The Sunday Times, 29th May 1988 [link]

    When Sheik Abdul heard that some pilgrims were leaving the district and travelling south to Mecca he immediately offered his well-appointed bus so that they could travel in comfort. Unfortunately, there were just too many pilgrims to travel comfortably. Abdul asked them to form a straight line facing south towards Mecca. He explained that he would carry out an operation that would result in some pilgrims facing north. These pilgrims would not go on the bus. Just then, Abdul noticed that his nephews were in the line-up. They occupied the end positions and the centre position.

    Abdul went along the line asking each man to make a half-turn. Then he went along the line asking every second man to make a half-turn and so face south again. Next he asked every third man to make a half-turn; if he was facing north, he was to face south, and if he was facing south, he was to face north. And so on, When Abdul went along the line for the last time only the man at the end was asked to make a half-turn. Abdul found that his nephews were all facing north.

    “That is only half of the operation”, he announced hastily. We continue and do the same again”. When it was pointed out that all the pilgrims would then be facing south, he said that this time he would start at the other end.

    How many of the pilgrims went on the bus to Mecca?

    [teaser1343]

     
    • Jim Randell's avatar

      Jim Randell 2:48 pm on 21 October 2026 Permalink | Reply

      See also: Teaser 3131, Puzzle #08.

      This Python program runs in 66ms. (Internal runtime is 379µs).

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

# apply the process to <ss>
def process(n, ss):
  for k in irange(1, n):
    # flip every k'th item
    for i in irange(k, n, step=k):
      ss[i - 1] ^= 1
  return ss

# consider odd numbers of participants (so there is a "centre")
for n in irange(3, inf, step=2):
  # start with everyone facing south (= 1)
  ss = [1] * n
  # run the process in the forward direction
  ss = process(n, ss)
  # all the nephews are now facing north (= 0)
  if not all(ss[i - 1] == 0 for i in [1, n, (n + 1) // 2]): continue
  # run the process in the reverse direction
  ss = rev(process(n, rev(ss)))
  # count number facing south
  printf("n={n}: S={S}\n-> {ss}\n", S=sum(ss))
  break

      Solution: 41 pilgrims went on the bus to Mecca.

      There were 49 pilgrims in the queue.

      At the end of both operations the pilgrims in positions: 4th, 9th, 14th, 16th, 34th, 36th, 41st, 46th positions are facing north.

      These can be paired as follows to give sums of 50 (= 49 + 1):

      4th & 46th
      9th & 41st
      14th & 36th
      16th & 34th

      Where one position (underlined) in each pair is a square number (counting from the start). The other position corresponds to a square number position counting from the end.

      The 25th (centre) position, is paired with itself, and so ends up facing south.

      The next solutions occur with 1681 pilgrims, and 57121 pilgrims:

      n = 49 = 7²; 49 + 1 = 2 × 5² (with 8 facing north)
      n = 1681 = 41²; 1681 + 1 = 2 × 29² (with 76 facing north)
      n = 57121 = 239²; 57121 + 1 = 2 × 169² (with 468 facing north)

      If we consider solutions to the Pell’s equation: X² − 2Y² = −1, the we get solutions of the form:

      n = X²; X² + 1 = 2 × Y² 

      % run pells.py 1 -2 -1  
solving: 1.X^2 + -2.Y^2 = -1
[1] X=1 Y=1 -> -1
[2] X=7 Y=5 -> -1
[3] X=41 Y=29 -> -1
[4] X=239 Y=169 -> -1
[5] X=1393 Y=985 -> -1
[6] X=8119 Y=5741 -> -1
[7] X=47321 Y=33461 -> -1
[8] X=275807 Y=195025 -> -1
[9] X=1607521 Y=1136689 -> -1
[10] X=9369319 Y=6625109 -> -1
[11] X=54608393 Y=38613965 -> -1
[12] X=318281039 Y=225058681 -> -1
[13] X=1855077841 Y=1311738121 -> -1
[14] X=10812186007 Y=7645370045 -> -1
[15] X=63018038201 Y=44560482149 -> -1
[16] X=367296043199 Y=259717522849 -> -1
[17] X=2140758220993 Y=1513744654945 -> -1
[18] X=12477253282759 Y=8822750406821 -> -1
[19] X=72722761475561 Y=51422757785981 -> -1
[20] X=423859315570607 Y=299713796309065 -> -1
[first 20 solutions]

      See: OEIS A002315 [@oeis], OEIS A001653 [@oeis].

      Like

    • Ruud van der Ham's avatar

      Ruud van der Ham 3:29 pm on 21 October 2026 Permalink | Reply 

      import itertools

for n in itertools.count(5, 2):
    p = [True for _ in range(n)]
    for i in range(n):
        for j in range(i, n, i + 1):
            p[j] = not p[j]
    if p[0] == p[n // 2] == p[n - 1]:
        for i in range(n):
            for j in range(i, n, i + 1):
                p[n - j - 1] = not p[n - j - 1]
        print("number in line:", n)
        print("number of pilgrims on the bus:", sum(p))
        print("line:", "".join(map(lambda x: "NS"[x], p)))
        break

      Like

  • Unknown's avatar

    Jim Randell 6:43 am on 18 October 2026 Permalink | Reply
    Tags:   

    Teaser 3343: Cartesian darts 

    From The Sunday Times, 18th October 2026 [link] [link]

    An AI app is learning to play a game of virtual darts. The board is a square, subdivided into nine squares. The resulting central square is divided in the same way, and the process continues ad infinitum.

    The value of each outer square is 1. Each smaller square has the same constant prime multiple of the value of the next larger square. A dart landing in a given square scores the average value of all squares of the same size or smaller, weighted by area. Thus, the closer the dart lands to the centre, the higher the score.

    At first, the app sometimes got a non-integer score, but after improving always got an integer score.

    What was the non-integer score (as a fraction)?

    [teaser3343]

     
    • Jim Randell's avatar

      Jim Randell 6:44 am on 18 October 2026 Permalink | Reply

      Let the score for a dart in level k be S[k]. The outer squares (value 1) are level 0.

      Then:

      S[0] = 8/9 + S[1]/9
      S[1] = (8/9)p + S[2]/9
      S[2] = (8/9)p^2 + S[3]/9
      …
      S[k] = (8/9)p^k + S[k + 1]/9

      So:

      S[0] = (8/9)(1 + p/9 + p^2/9^2 + p^3/9^3 + …)

      The infinite geometric sum has a common ratio of p/9, so will converge if p < 9, and will converge to: 9/(9 − p).

      Hence:

      S[0] = (8/9)(9/(9 − p)) = 8/(9 − p)
      S[k + 1] = 9 S[k] − 8 p^k

      Where p is a prime less than 9, i.e. p = 2, 3, 5, 7.

      This Python program considers possible primes for p, and calculates the first 11 terms of the sequence S[]. It then looks for sequences that start off with non-integer scores, but after a certain point give only integer scores. (The puzzle can be read to require only S[0] to give a non-integer score, but my code does not require that).

      It runs in 81ms. (Internal runtime is 246µs).

      from enigma import (Rational, primes, first, clump, seq2str, printf)

Q = Rational()
N = 11  # number of terms to consider

# calculate terms in the sequence
# S[k + 1] = 9 S[k] - 8 p^k
def seq(p, s0):
  (s, d) = (s0, 8)
  while True:
    yield s
    s = 9*s - d
    d *= p

# consider primes < 9
for p in primes.between(2, 8):
  # calculate S(0)
  S0 = Q(8, 9 - p)
  # calculate N terms of S[]
  S = list(first(seq(p, S0), N))
  # look for a sequence that starts with non-integer values
  # but then settles down to integer values
  zs = list(clump(x % 1 == 0 for x in S))
  sol = (len(zs) == 2 and zs[0][0] is False and zs[1][0] is True)
  # output solution
  printf(
    "p = {p}: S = {S} {x}" ,
    S=seq2str(S, enc=("[", ", ...]")),
    x=("-> [*** SOLUTION ***]" if sol else "")
  )

      Solution: [To Be Revealed]

      [details − to be revealed]

      Like

  • Unknown's avatar

    Jim Randell 11:15 am on 15 October 2026 Permalink | Reply
    Tags:   

    Brainteaser 1342: Balancing trick 

    From The Sunday Times, 22nd May 1988 [link]

    The other day Harry visited me and he produced eight boxes each of which contained five new golf balls, and, on producing them, he picked out one ball from one of the boxes, and he said that he knew that that ball was of regulation weight, and he added that he also knew that 38 of the other balls were also of regulation weight, but there was one ball amongst the other 39 that was either heavier or lighter than the regulation ball. On saying this he handed me a simple set of scales, one square tray on one side balanced against a similar tray on the other side, each tray being large enough to hold up to 14 of the balls in a pyramid. The scales had no weights attached to them, and Harry asked me how many weighings of the balls it would take me to discover for certain, in all eventualities, which was the maverick ball, and also to tell whether it was lighter or heavier than the others.

    He told me that he would give me one box of balls for each weighing less than eight that it took me in order to achieve this.

    How many boxes of balls was I able to win from this wager?

    [teaser1342]

     
    • Jim Randell's avatar

      Jim Randell 11:17 am on 15 October 2026 Permalink | Reply

      See also: Teaser 1952-04-13, Teaser 2500, Enigma 1589.

      This is a “type 2” problem – “how to determine the counterfeit coin from 39 with an extra known good coin”.

      I have adapted the program given in my comment for Teaser 2500 that generates decision trees for several types of problems as below (also [link]):

      #! python3

# this program can output the decision tree for 4 kinds of coin
# weighing puzzle, where we have a collection of <n> coins, one of
# which is counterfeit and is either lighter or heavier than the
# remaining coins (which all weigh the same), and we must determine by
# comparative weighings which of the coins is counterfeit, and whether
# it is heavier or lighter.
#
# type 1 = find the suspect coin from a collection of <n> coins.
#
# type 2 = find the suspect coin from a collection of <n> coins, where
# an additional known good reference coin is provided.
#
# type 3 = find the suspect coin from a collection of <n> coins, where
# some of the coins are red, and some of the coins are black. there is
# either 1 or 2 more red coins than black coins. if the suspect coin
# is red it is heavy, and if it is black it is light.
#
# type 4 = find the suspect lighter coin from a collection of <n> coins.
#
# additionally we can also solve the following problem:
#
# type 1* = find the suspect coin from a collection of <n> coins, but
# we don't need to know if it is heavier or lighter.
#
# this is solved by putting one of the coins aside and treating the
# remaining <n-1> coins as a "type 1" problem. if all weighings
# balance (and we reach the "impossible" leaf of the decision tree),
# then all the coins are good, apart from the one set aside, so it
# must be counterfeit. and so this problem is the same as solving a
# "type 1" problem with <n-1> coins.
#
# the program is run as:
#
#  % python3 coin-weighing.py <n> <p>
#
# where <n> is the number of coins/weighings, and <p> is the problem number (1-4)
#
# if the <n> parameter is given as "w<k>" then the maximum number of
# coins for <k> weighings is used to construct the decision tree.
#
# similarly the <n> parameter can be specified as "n<n>" for the number of coins

from enigma import (irange, divc, arg, nl, printf)

IMP = "(impossible)"

# divide a list into thirds
# such that the first two thirds are equal size
def thirds(ss):
  (i, r) = divmod(len(ss), 3)
  if r == 2: i += 1
  j = 2*i
  return (ss[:i], ss[i:j], ss[j:])

def output_weighing(p, w, A, B):
  printf("{p}[{w}] weighing {w}:")
  printf("{p}[{w}] A = {A}", A=sorted(A))
  printf("{p}[{w}] B = {B}", B=sorted(B))

# find the light suspect coin
def solve_lighter(coins, w=0, p=''):
  n = len(coins)
  if n < 1:
    printf("{p}-> {IMP}")
  elif n == 1:
    printf("{p}[{w}] -> {coins[0]}L")
  elif n == 2 or n == 3:
    w += 1
    (A, B) = ([coins[0]], [coins[1]])
    output_weighing(p, w, A, B)
    printf("{p}[{w}] A < B -> {A[0]}L")
    printf("{p}[{w}] A > B -> {B[0]}L")
    printf("{p}[{w}] A = B -> \\")
    printf("{IMP}" if n == 2 else "{coins[2]}L")
  else:
    # divide the coins into three piles
    (A, B, C) = thirds(coins)
    w += 1
    output_weighing(p, w, A, B)
    printf("{p}[{w}] A < B:")
    w1 = solve_lighter(A, w, p + "  ")
    printf("{p}[{w}] A > B:")
    w2 = solve_lighter(B, w, p + "  ")
    printf("{p}[{w}] A = B:")
    w3 = solve_lighter(C, w, p + "  ")
    w = max(w1, w2, w3)
  return w

# find suspect coin in reds (if heavier), or in blacks (if lighter)
def solve_red_black(reds, blacks, red='H', black='L', good=-1, w=0, p=''):
  ns = (nr, nb) = (len(reds), len(blacks))
  assert nr - nb in {1, 2}
  if ns == (1, 0):
    printf("{p}[{w}] -> \\")
    x = reds[0]
    printf("{x}{red}" if x != good else IMP)
  elif nr == 2:
    # weigh the two reds
    w += 1
    (r0, r1) = (reds[0], reds[1])
    output_weighing(p, w, [r0], [r1])
    printf("{p}[{w}] A < B -> \\")
    x = (r1 if red == 'H' else r0)
    printf("{x}{red}" if x != good else IMP)
    printf("{p}[{w}] A > B -> \\")
    x = (r0 if red == 'H' else r1)
    printf("{x}{red}" if x != good else IMP)
    printf("{p}[{w}] A = B -> \\")
    printf("{blacks[0]}{black}" if nb == 1 and blacks[0] != good else IMP)
  else:
    # divide the reds into 3 piles
    k = divc(nr, 3)
    (r1, r2, r3) = (reds[:k], reds[k:2*k], reds[2*k:])
    # divide the blacks into 3 corresponding piles
    i = len(r1) - 1
    j = i + len(r2) - 1
    (b1, b2, b3) = (blacks[:i], blacks[i:j], blacks[j:])
    w += 1
    output_weighing(p, w, r1 + b1, r2 + b2)
    printf("{p}[{w}] A < B:")
    (rs, bs) = ((r2, b1) if red == 'H' else (r1, b2))
    w1 = solve_red_black(rs, bs, red, black, good, w, p + "  ")
    printf("{p}[{w}] A > B:")
    (rs, bs) = ((r1, b2) if red == 'H' else (r2, b1))
    w2 = solve_red_black(rs, bs, red, black, good, w, p + "  ")
    printf("{p}[{w}] A = B:")
    if len(b3) > len(r3):
      w3 = solve_red_black(b3, r3 , black, red, good, w, p + "  ")
    else:
      # increase the reds with a known good red
      gd = r1[0]
      w3 = solve_red_black([gd] + r3, b3, red, black, gd, w, p + "  ")
    w = max(w1, w2, w3)
  return w

# find suspect coin with extra known good coin
def solve_test_coin(coins, good, w=0, p=''):
  n = len(coins)
  if n < 1:
    printf("{p}-> {IMP}")
  elif n == 1:
    # weigh the coin against the known good coin
    w += 1
    x = coins[0]
    output_weighing(p, w, [good], [x])
    printf("{p}[{w}] A < B -> {x}H")
    printf("{p}[{w}] A > B -> {x}L")
    printf("{p}[{w}] A = B -> {IMP}")
  else:
    # divide the coins into 3 piles
    i = n // 3
    j = 2*i + 1
    (c1, c2, c3) = (coins[:i], coins[i:j], coins[j:])
    w += 1
    output_weighing(p, w, [good] + c1, c2)
    printf("{p}[{w}] A < B:")
    w1 = solve_red_black(c2, c1, 'H', 'L', -1, w, p + "  ")
    printf("{p}[{w}] A > B:")
    w2 = solve_red_black(c2, c1, 'L', 'H', -1, w, p + "  ")
    printf("{p}[{w}] A = B:")
    w3 = solve_test_coin(c3, good, w, p + "  ")
    w = max(w1, w2, w3)
  return w

# find suspect coin
def solve_general(coins, w=0, p=''):
  n = len(coins)
  if n < 3:
    printf("{p}-> {IMP}")
  else:
    # divide the coins into 3 piles
    (c1, c2, c3) = thirds(coins)
    w += 1
    output_weighing(p, w, c1, c2)
    printf("{p}[{w}] A < B:")
    w1 = solve_red_black(c1 + [c3[0]], c2, 'L', 'H', -1, w, p + "  ")
    printf("{p}[{w}] A > B:")
    w2 = solve_red_black(c1 + [c3[0]], c2, 'H', 'L', -1, w, p + "  ")
    printf("{p}[{w}] A = B:")
    w3 = solve_test_coin(c3, c1[0], w, p + "  ")
    w = max(w1, w2, w3)
  return w

# number of coins (or weighings) and problem type
n = arg("n13", 0, prompt="number of coins (n<int>; or weighings w<int>)")
p = arg("1", 1, prompt="problem type (1-4)")
printf("[arg = {n}; problem = {p} (of 1-4)]")

# parse the n parameter
def fn(n, f):
  # n<n> = <n> coins; w<n> = <n> weighings
  if n.startswith('n'): return int(n[1:])
  if n.startswith('w'): return f(int(n[1:]))
  # old style: <n> = n<n>; -<n> = w<n>
  n = int(n)
  return (f(-n) if n < 0 else n)

if p == "1":
  # solve the general case
  n = fn(n, (lambda k: (3**k - 3) // 2))
  printf("---{nl}find suspect coin from {n} coins{nl}---")
  coins = list(irange(1, n))
  printf("coins = {coins}")
  w = solve_general(coins)
  printf("---{nl}{n} coins -> {w} weighings")

if p == "2":
  # solve with a known good coin (0)
  n = fn(n, (lambda k: (3**k - 1) // 2))
  printf("---{nl}find suspect coin from {n} coins, with an extra known good coin (0){nl}---")
  coins = list(irange(1, n))
  printf("coins = {coins}")
  w = solve_test_coin(coins, 0)
  printf("---{nl}{n} coins -> {w} weighings")

if p == "3":
  # solve red/black
  n = fn(n, (lambda k: 3**k))
  r = ((n + 2) // 2 if n > 0 else 0)
  b = n - r
  printf("---{nl}find suspect coin from {n} coins, where {r} coins are red and {b} coins are black{nl}if the suspect coin is red it is heavy, if it is black it is light{nl}---")
  (reds, blacks) = (list(irange(1, r)), list(irange(r + 1, n)))
  printf("reds = {reds}{nl}blacks = {blacks}")
  w = solve_red_black(reds, blacks)
  printf("---{nl}{n} coins -> {w} weighings")

if p == "4":
  # solve lighter
  n = fn(n, (lambda k: 3**k))
  printf("---{nl}find suspect lighter coin from {n} coins{nl}---")
  coins = list(irange(1, n))
  printf("coins = {coins}")
  w = solve_lighter(coins)
  printf("---{nl}{n} coins -> {w} weighings")

      In this case we have a “type 2” problem with 39 coins/balls:

      % run coin-weighing.py n39 2        
[arg = n39; problem = 2 (of 1-4)]
---
find suspect coin from 39 coins, with an extra known good coin (0)
---
coins = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39]
[1] weighing 1:
[1] A = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
[1] B = [14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27]
...
---
39 coins -> 4 weighings

      We see that the maverick ball can always be determined in just 4 weighings, and the first weighing requires 14 balls in each pan of the balance, which is permitted. (And subsequent weighings use fewer balls).

      Solution: You can guarantee to win 4 boxes of balls.

      Although this is not the largest number of balls possible with 4 weighings:

      For a “type 2” problem with k weighings we can find the counterfeit among n = (3^k − 1) / 2 objects.

      k = 4 → n = (3^4 − 1) / 2 = 40

      So, we could solve the same puzzle if all 40 balls in the boxes are suspect, and Harry provided a separate regulation-weight ball from his pocket.

      % run coin-weighing.py w4 2 
[arg = w4; problem = 2 (of 1-4)]
---
find suspect coin from 40 coins, with an extra known good coin (0)
---
coins = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40]
[1] weighing 1:
[1] A = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
[1] B = [14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27]
...
---
40 coins -> 4 weighings

      Like

  • Unknown's avatar

    Jim Randell 6:59 am on 11 October 2026 Permalink | Reply
    Tags:   

    Teaser 3342: One dart wonder 

    From The Sunday Times, 11th October 2026 [link] [link]

    Andy and Beth play a game of darts in which each turn consists of a single dart. They use a standard dartboard where you can score any number from 1 to 20, as well as double or treble that number. Scores of 25 and 50 are also possible. Each single-dart score (SDS) will count only if it does not repeat a previous score by either player and if it has no digit in common with the opponent’s preceding SDS. Every turn, other than the final one, must attempt the highest available valid SDS. Each player must start with a double other than a bullseye (50), and the winner must finish with a double.

    In a game where the first to reach a total of 501 wins, Andy started and both players achieved the required SDS on each turn.

    Who won, and what was the loser’s total at that point?

    [teaser3342]

     
    • Jim Randell's avatar

      Jim Randell 7:00 am on 11 October 2026 Permalink | Reply

      Each throw in the game is completely determined (it is either the winning double, or the maximum permissible score), so we do not need explore multiple branches in the game tree. All we need to do is follow the instructions, and produce the sequence of scores for each player.

      I have assumed that players must finish with an exact score (and cannot exceed their remaining total), with a dart in the double ring (so 50 does not count as a double, as specified in the puzzle text). And no-one ever misses the board (scores 0). Although we can relax these conditions to allow for other reasonable interpretations of the puzzle text, and still find the same answer. The code also catches the condition where a player has no playable score (although this does not occur with the target value specified in the puzzle text).

      This Python program runs in 67ms. (Internal runtime is 476µs).

      from enigma import (irange, union, nsplit, empty, diff, fail, printf)

# possible scores, by category and collected together
singles = set(irange(1, 20))
doubles = set(2 * x for x in singles)
triples = set(3 * x for x in singles)
bull = { 25, 50 }
scores = union([singles, doubles, triples, bull]) # could also add {0}

# record digits for each possible score
digits = dict((x, set(nsplit(x))) for x in scores)

# play the game with players 0 and 1
rem = [501, 501]  # remaining totals
seq = [[], []]  # scores so far
i = 0  # index of first player
win = 0  # winning throw?
while True:
  other = 1 - i  # index of opponent
  # first go for each player must be a double
  poss = (scores if seq[i] else doubles)
  # digits to avoid
  ds = (digits[seq[other][-1]] if seq[other] else empty)
  # find possible scores (unplayed, in range, and with no digits in common with opponents last score)
  r = rem[i]
  ss = set(x for x in diff(poss, *seq) if x <= r and ds.isdisjoint(digits[x]))
  fail(not ss, "player cannot play")
  # can we finish? final throw must also be a double
  if r in ss and r in doubles:
    x = r
    win = 1
  else:
    # play the max possible score
    x = max(ss)
  # play the score
  rem[i] -= x
  seq[i].append(x)
  # are we done?
  if win: break
  # next player
  i = other

# output solution
if win: printf("player {n} wins:", n="AB"[i])
printf("-> A: {seq} = {t}", seq=seq[0], t=sum(seq[0]))
printf("-> B: {seq} = {t}", seq=seq[1], t=sum(seq[1]))

      Solution: Beth wins the game. At the end Andy’s total score is 461.

      The scores are:

      Andy: 40, 60, 48, 42, 39, 36, 33, 34, 30, 19, 18, 17, 16, 15, 14; total = 461
      Beth: 38, 57, 51, 50, 54, 45, 28, 27, 26, 32, 25, 24, 22, 20, 2; total = 501

      All single dart scores are played, except: 21, 13 .. 3, 1.

      Like

    • Ruud van der Ham's avatar

      Ruud van der Ham 5:58 pm on 11 October 2026 Permalink | Reply 

      turns = dict(A=[], B=[])
scores = {*range(1, 21), *range(2, 41, 2), *range(3, 61, 3), 25, 50}
doubles = {*range(2, 41, 2)}
last_sds = ""
player = "A"
done = False

while True:
    for score in sorted(scores, reverse=True):
        if sum(turns[player]) + score == 501:
            turns[player].append(score)
            print("winner= ", player)
            for player in "AB":
                print(player, turns[player], "total=", sum(turns[player]))
            done = True
    if done:
        break
    for score in sorted(scores, reverse=True):
        if turns[player] or score in doubles and not (set(str(score)) & set(str(last_sds))):
            scores.remove(score)
            last_sds = str(score)
            break
    turns[player].append(score)
    player = "A" if player == "B" else "B"

      Like

      • Jim Randell's avatar

        Jim Randell 9:27 pm on 11 October 2026 Permalink | Reply

        @Ruud: Consecutive scores are not allowed to share digits, so you can’t have a sequence of scores with [57, 54, 51, 50] in the middle.

        Like

        • Ruud van der Ham's avatar

          Ruud van der Ham 9:49 pm on 11 October 2026 Permalink | Reply

          @Jim
          You are right. Thanks.
          This version works as expected:

          turns = dict(A=[], B=[])
scores = {*range(1, 21), *range(2, 41, 2), *range(3, 61, 3), 25, 50}
doubles = {*range(2, 41, 2)}
last_sds = ""
player = "A"
done = False

while True:
    for score in sorted(scores, reverse=True):
        if sum(turns[player]) + score == 501:
            turns[player].append(score)
            print("winner= ", player)
            for player in "AB":
                print(player, turns[player], "total=", sum(turns[player]))
            done = True
    if done:
        break
    for score in sorted(scores, reverse=True):
        if (turns[player] or score in doubles) and not (set(str(score)) & set(str(last_sds))):
            scores.remove(score)
            last_sds = str(score)
            break
    turns[player].append(score)
    player = "A" if player == "B" else "B"

          Like

  • Unknown's avatar

    Jim Randell 8:31 am on 9 October 2026 Permalink | Reply
    Tags:   

    Brainteaser 1400: Happy families 

    From The Sunday Times, 9th July 1989 [link]

    Five families, each consisting of a mother, father, and one child, are near neighbours. The families have a lot in common, and, to give you some idea of the closeness, I will tell you that last Saturday all 15 family members went on an outing to the circus to celebrate young Laura’s 10th birthday.

    The day before that, four of the mothers, Jenny, Lorna, Margaret and Norma, had been on a shopping spree together, and two of the fathers, Ken and John, had prepared a barbecue for all the others. Three of the children, Kevin, Marion and Nigel, are learning the piano under the same teacher.

    Mike and Neil are the fathers of daughters. Young Jill, who is not Neil’s child, shares a birthday with Leo’s child (who has the same initial as Mike’s wife) and with Kate’s child (who has the same initial as Leo’s wife). The other two children share a birthday on a different date.

    If I tell you that no two members of a family have the same first name initials as each other, you should be able to work out the name of John’s wife and who it was that shared Laura’s birthday last week.

    There are now 1400 Teaser puzzles available on the site, so it seemed like an appropriate time to post Teaser 1400.

    Between S2T2 and Enigmatic Code there are now 4056 puzzles available in total.

    [teaser1400]

     
    • Jim Randell's avatar

      Jim Randell 8:32 am on 9 October 2026 Permalink | Reply

      Here is a solution that uses the [[ SubstitutedExpression ]] solver from the enigma.py library, to group the families together.

      It runs in 88ms. (Internal runtime of the generated code is 223µs).

      #! python3 -m enigma -rr

SubstitutedExpression

# assign family values 1..5 to each group

# Father:  John  [J]; Ken   [K]; Leo   [L]; Mike     [M]; Neil  [N]
# Mother:  Jenny [A]; Kate  [B]; Lorna [C]; Margaret [D]; Norma [E]
# Child:   Jill  [V]; Kevin [W]; Laura [X]; Marion   [Y]; Nigel [Z]

--digits="1-5"
# each group uses the digits 1-5 exactly once
# no two members of the same family share a first initial
--distinct="JKLMN,ABCDE,VWXYZ,JAV,KBW,LCX,MDY,NEZ"

# assign values to the fathers
--assign="J,1"
--assign="K,2"
--assign="L,3"
--assign="M,4"
--assign="N,5"

# "Mike[M] and Neil[N] are the fathers of daughters (= Jill[V], Laura[X], Marion[Y])
"{M, N}.issubset({V, X, Y})"

# "Jill[V] (who is not Neil[N]'s child)..."
# so V and N are different families
"V != N"
# "... shares a birthday with Leo[L]'s child..."
# "... and with Kate[B]'s child"
# so (V, L, B) are all distinct families (one group of birthdays)
"len({V, L, B}) == 3"

# names in alphabetical order
--macro="@wife  = (A, B, C, D, E)"
--macro="@child = (V, W, X, Y, Z)"

# "Leo[L]'s child has the same initial as Mike[M]'s wife"
"@child.index(L) == @wife.index(M)"

# "Kate[B]'s child has the same initial as Leo[L]'s wife"
"@child.index(B) == @wife.index(L)"

# output groups
--template="(J K L M N) (A B C D E) (V W X Y Z)"
--solution=""

      And here is a Python program to run the solver and turn the output into a more friendly form:

      from enigma import (SubstitutedExpression, defaultdict, join, printf)

p = SubstitutedExpression.from_file(["{dir}/teaser1400.run"])

# map symbols to names
s2n = dict(
  J="John", K="Ken", L="Leo", M="Mike", N="Neil",
  A="Jenny", B="Kate", C="Lorna", D="Margaret", E="Norma",
  V="Jill", W="Kevin", X="Laura", Y="Marion", Z="Nigel",
)

# solve the puzzle
for s in p.solve(verbose=0):
  # collect the families and birthday groups
  fams = defaultdict(list)
  for k in "JKLMNABCDEVWXYZ":
    fams[s[k]].append(s2n[k])
  # the group of 3 is {V, L, B}
  bd = dict.fromkeys((s[k] for k in "VLB"), 3)
  # output solution
  for k in sorted(fams.keys()):
    printf("{k}: {vs} [{b}]", vs=join(fams[k], sep=", "), b=bd.get(k, 2))
  printf()

      Solution: John’s wife is Lorna. Laura’s birthday is shared with Kevin.

      The families are (father, mother, child):

      John, Lorna, Kevin
      Ken, Jenny, Laura
      Leo, Margaret, Nigel
      Mike, Norma, Jill
      Neil, Kate, Marion

      And the birthday groups are: {Kevin, Laura} and {Nigel, Jill, Marion}.

      Like

  • Unknown's avatar

    Jim Randell 11:39 am on 6 October 2026 Permalink | Reply
    Tags:   

    Brain-Teaser 934: Joustin’ time 

    From The Sunday Times, 15th June 1980 [link]

    At the recent All-England Jousting Tournament, the final was between Sir Yorick and Sir Zebedee. Each knight had brought nine men to fight for him, and the final consisted of a fight between two men — one from each knight. No man fought in two or more rounds.

    At the start of the final, the two knights tossed a coin to decide the order of choosing their men for the first round. For each round after the first, the knight whose man had won the previous round chose his man first. In each round, the knight choosing second had the advantage that he knew his opponent’s choice before he made his own choice.

    Sir Yorick brought two horsemen and seven spearmen, and Sir Zebedee brought six bowmen and three footsoldiers.

    Whenever they fight:

    a horseman always beats a bowman or a footsoldier;
    a bowman always beats a spearman;
    a spearman always beats a footsoldier.

    As each knight knew the above facts beforehand, he was able to choose his man for each round so that he won as many rounds as possible.

    How many rounds did Sir Yorick win?

    [teaser934]

     
    • Jim Randell's avatar

      Jim Randell 11:39 am on 6 October 2026 Permalink | Reply

      The following Python program scores a scenario by determining the number of wins for Y minus the number of wins for Z. Y is trying to make the score as large as possible (more positive), and Z is trying to make the score as small as possible (more negative).

      If one player has only one type of combatant at their disposal, then the outcome is easily determined. But if both players have both types of combatant available then the first player can choose either type, and the second player can also choose either type in response. Y will choose the type that maximises the score of the scenario, and Z will choose the type that minimises the score of the scenario.

      We can calculate the score for the scenarios where each player makes the first choice.

      The program runs in 78ms. (Internal runtime is 124µs).

      from enigma import (ediv, cache, printf)

# labels for Y and Z
(Y, Z) = (0, 1)

# return wins (Y - Z)
@cache
def play(H, S, B, F, player):
  # if a player has only one type remaining then the outcome is determined
  # (both players have the same total number of men)
  if H == 0: return (F - B)  # Y wins against F, loses against B
  if S == 0: return (H - 0)  # Y wins with all H
  if B == 0: return (F - 0)  # Y wins against all F
  if F == 0: return (H - S)  # Y wins with H, loses with S
  # otherwise choose the best outcome for the current player
  if player == Y:
    # Y chooses H; Z responds with B or F
    rH = min(
      play(H - 1, S, B - 1, F, Y) + 1, # H vs B -> Y wins
      play(H - 1, S, B, F - 1, Y) + 1, # H vs F -> Y wins
    )
    # Y chooses S; Z responds with B or F
    rS = min(
      play(H, S - 1, B - 1, F, Z) - 1, # S vs B -> Z wins
      play(H, S - 1, B, F - 1, Y) + 1, # S vs F -> Y wins
    )
    # best outcome for Y
    return max(rH, rS)
  elif player == Z:
    # Z chooses B; Y responds with H or S
    rB = max(
      play(H - 1, S, B - 1, F, Y) + 1, # B vs H -> Y wins
      play(H, S - 1, B - 1, F, Z) - 1, # B vs S -> Z wins
    )
    # Z chooses F; Y responds with H or S
    rF = max(
      play(H - 1, S, B, F - 1, Y) + 1, # F vs H -> Y wins
      play(H, S - 1, B, F - 1, Y) + 1, # F vs S -> Y wins
    )
    # best outcome for Z
    return min(rB, rF)

# consider situations where each player chooses first
for (player, name) in zip([Y, Z], "YZ"):
  # initial set-up
  r = play(2, 7, 6, 3, player)
  # extract final scores
  y = ediv(r + 9, 2)
  z = 9 - y
  # output solution
  printf("{name} first -> Y = {y}, Z = {z}")

      Solution: Sir Yorick wins 5 of the rounds.

      It doesn’t matter which knight goes first, the result is Y=5, Z=4 in each case.

      Like

      • Jim Randell's avatar

        Jim Randell 9:36 pm on 6 October 2026 Permalink | Reply

        Or, more succinctly:

        from enigma import (ediv, cache, printf)

# labels for Y and Z
(Y, Z) = (0, 1)

# return wins (Y - Z)
@cache
def play(H, S, B, F, player):
  # if a player has only one type remaining then the outcome is determined
  if H == 0: return (F - B)  # Y wins against F, loses against B
  if S == 0: return (H - 0)  # Y wins with all H
  if B == 0: return (F - 0)  # Y wins against all F
  if F == 0: return (H - S)  # Y wins with H, loses with S
  # otherwise choose the best outcome for the current player
  HB = play(H - 1, S, B - 1, F, Y) + 1  # H vs B -> Y wins
  HF = play(H - 1, S, B, F - 1, Y) + 1  # H vs F -> Y wins
  SB = play(H, S - 1, B - 1, F, Z) - 1  # S vs B -> Z wins
  SF = play(H, S - 1, B, F - 1, Y) + 1  # S vs F -> Y wins
  if player == Y:
    # return best outcome for Y
    return max(min(HB, HF), min(SB, SF))
  elif player == Z:
    # return best outcome for Z
    return min(max(HB, SB), max(HF, SF))

# consider situations where each player chooses first
for (player, name) in zip([Y, Z], "YZ"):
  # initial set-up
  r = play(2, 7, 6, 3, player)
  # extract final scores
  y = ediv(r + 9, 2)
  z = 9 - y
  # output solution
  printf("{name} first -> Y = {y}, Z = {z}")

        Like

  • Unknown's avatar

    Jim Randell 7:01 am on 4 October 2026 Permalink | Reply
    Tags:   

    Teaser 3341: Sum of squares 

    From The Sunday Times, 4th October 2026 [link] [link]

    A seamstress is making a patchwork blanket from knitted squares of two colours, red and orange, forming a rectangular pattern. She has already sewn eight rows of seven squares each.

    For each row, the columns with red squares are:

    A: 1, 2, 4, 6, 7;
    B: 2, 3, 6, 7;
    C: 3, 4, 5, 7;
    D: 1, 2, 3, 5;
    E: 1, 2, 3, 5, 6;
    F: 1, 3, 4, 7;
    G: 2, 4, 6, 7;
    H: 4, 5, 6.

    All other squares are orange.

    She wants to assemble the rows (without reversing any left to right) into a rectangle, but choosing the order so that each column has exactly one run of exactly three consecutive reds, with all other reds having no red neighbours in the column, and with more reds in the top half than in the bottom half.

    What should be the order of rows from top to bottom?

    [teaser3341]

     
    • Jim Randell's avatar

      Jim Randell 7:02 am on 4 October 2026 Permalink | Reply

      It is straightforward to try all possible orderings of the rows, and then for orders with more reds in the top half we can look for those that give valid columns.

      The following Python program runs in 208ms (using PyPy3 8.0.0). (Internal runtime is 104ms).

      (I think this is fast enough, but for a larger problem (or a faster runtime) we could use a more complex solver that does early rejection of columns that become invalid as they are constructed).

      from enigma import (subsets, unzip, join, printf)

rows = dict(
  A="XX X XX", B=" XX  XX", C="  XXX X", D="XXX X  ",
  E="XXX XX ", F="X XX  X", G=" X X XX", H="   XXX ",
)

# check a given order
def check(ks):
  # construct the rows
  rs = list(rows[k] for k in ks)

  # check there are more reds in the first half
  if not (join(rs[:4]).count('X') > join(rs[4:]).count('X')): return

  # check each column has exactly 1 run of 3, and not other consecutive runs
  cs = map(join, unzip(rs))
  for col in cs:
    # count runs of reds
    m = list(len(x) for x in str.split(col))
    # there should be exactly one 3, no 2's, and no >3
    if not (m.count(3) == 1 and m.count(2) == 0 and max(m) == 3): return

  # looks OK
  return True

# choose an ordering for the rows
for ks in subsets(rows.keys(), size=len, select='P', fn=join):
  if check(ks):
    printf("order = {ks}")

      Solution: The order is: G D A F C E H B.

      There are 17 reds in the top half, and 16 in the bottom half.

      Like

      • Jim Randell's avatar

        Jim Randell 3:20 pm on 5 October 2026 Permalink | Reply

        I didn’t have time to look at a more efficient solution yesterday. But with a bit more work, here is a faster version, with a recursive [[ solve() ]] routine.

        We construct a list of viable columns, and make a set of their prefixes, so we can check columns as they are built. We also calculate a lower bound for “more than half the reds”, so we can check this is achieved after the first 4 rows are complete.

        The following Python program has an internal runtime of just 2.2ms.

        from enigma import (defaultdict, subsets, cslice, remove, divc, join, printf)

# construct viable columns consisting of 8 squares
# that include exactly 1 run of 3 reds, and possible other runs of 1
# record viable prefixes
(pfx, tgt) = (defaultdict(set), ['XXX'])
for col in subsets('X ', size=8, select='M', fn=join):
  m = list(x for x in str.split(col) if x != 'X')
  if m == tgt:
    for v in cslice(col):
      pfx[len(v)].add(v)

# rows for the puzzle
rows = dict(
  A="XX X XX", B=" XX  XX", C="  XXX X", D="XXX X  ",
  E="XXX XX ", F="X XX  X", G=" X X XX", H="   XXX ",
)

# map rows to content count
count = dict((k, v.count('X')) for (k, v) in rows.items())
reds = lambda ks: sum(count[k] for k in ks)

# calculate lower bound for "half the reds"
t = divc(reds(count.keys()) + 1, 2)

# find orderings of rows that give the required arrangement of reds
def solve(ks, cols, order):
  if not ks:
    yield (order, cols)
  else:
    # choose the next key
    for k in ks:
      order_ = order + k
      if len(order_) == 4 and reds(order_) < t: continue
      cols_ = list(col + x for (col, x) in zip(cols, rows[k]))
      if not pfx[len(cols_[0])].issuperset(cols_): continue
      yield from solve(remove(ks, k), cols_, order_)

# solve the puzzle
for (order, cols) in solve(list(rows.keys()), [''] * 7, ''):
  # output solution
  printf("order = {order}")

        Like

        • Frits's avatar

          Frits 5:20 am on 6 October 2026 Permalink | Reply

          @Jim, also with the latest version of enigma.py (Sep 16 11:01:53) the program doesn’t find a solution.

          Like

          • Jim Randell's avatar

            Jim Randell 7:43 am on 6 October 2026 Permalink | Reply

            @Frits: Oops! There was a mistake in the [[ first4 ]] stuff (which should have used [[ ordered(*...) ]]). But I’ve streamlined that test now, so we don’t need to sort the keys for the currently selected rows.

            Like

    • Frits's avatar

      Frits 11:00 am on 4 October 2026 Permalink | Reply

      isdisjoint() apparently also accepts a generator as argument.

      from itertools import permutations

labels = "ABCDEFGH"

g = ((1, 1, 0, 1, 0, 1, 1),
     (0, 1, 1, 0, 0, 1, 1),
     (0, 0, 1, 1, 1, 0, 1),
     (1, 1, 1, 0, 1, 0, 0),
     (1, 1, 1, 0, 1, 1, 0),
     (1, 0, 1, 1, 0, 0, 1),
     (0, 1, 0, 1, 0, 1, 1),
     (0, 0, 0, 1, 1, 1, 0))
   
# solve by adding new rows
def solve(k, g, ss):
  if k == 0:
    # check columns again
    for c in zip(*ss):
      if c[-3:] == (0, 1, 1): return
      # each column has exactly one run of exactly three consecutive reds
      if sum(c[i:i+3] == (1, 1, 1) for i in range(6)) != 1: return
    yield ss
  else:
    for r in g:
      # check columns for the last four rows
      if {(0, 1, 1, 0), (1, 1, 1, 1)}.isdisjoint(zip(*(ss[-3:] + (r, )))):
        yield from solve(k - 1, tuple(x for x in g if x != r), ss + (r, ))

# minimal number of reds needed in top half
mn_reds_th = (sum(sum(r) for r in g) + 1) // 2     

# forbidden columns for first four rows
fb = {(1, 1, 0, 1), (1, 1, 0, 0), (0, 1, 1, 0), (1, 1, 1, 1)}

# first select the first 4 rows
for r4 in permutations(g, 4):
  # top half must have more reds than bottom half
  if sum(sum(r) for r in r4) < mn_reds_th: continue  
  # check the columns
  if not fb.isdisjoint(zip(*r4)): continue
  # add 4 more rows
  for s in solve(4, tuple(r for r in g if r not in r4), r4):
    print("answer:", ''.join(labels[g.index(r)] for r in s))

      Like

      • Frits's avatar

        Frits 1:58 pm on 4 October 2026 Permalink | Reply

        A bit less efficient.

        from itertools import permutations

labels = "ABCDEFGH"

g = ((1, 1, 0, 1, 0, 1, 1),
     (0, 1, 1, 0, 0, 1, 1),
     (0, 0, 1, 1, 1, 0, 1),
     (1, 1, 1, 0, 1, 0, 0),
     (1, 1, 1, 0, 1, 1, 0),
     (1, 0, 1, 1, 0, 0, 1),
     (0, 1, 0, 1, 0, 1, 1),
     (0, 0, 0, 1, 1, 1, 0))
   
# solve by adding new rows
def solve(k, g, ss=tuple()):
  if k == 0:
    # check columns again
    for c in zip(*ss):
      if c[-3:] == (0, 1, 1): return
      # each column has exactly one run of exactly three consecutive reds
      if sum(c[i:i+3] == (1, 1, 1) for i in range(6)) != 1: return
    yield ss
  else:
    if k == 5 and (1, 1, 0) in zip(*ss): return
    if k == 4:
      # top half must have more reds than bottom half
      if sum(sum(r) for r in ss) < mn_reds_th: return
    
    for r in g:
      # check columns for the last four rows
      if k > 4 or {(0, 1, 1, 0), (1, 1, 1, 1)}.isdisjoint(zip(*(ss[-3:] + (r, )))):
        yield from solve(k - 1, tuple(x for x in g if x != r), ss + (r, ))

# minimal number of reds needed in top half
mn_reds_th = (sum(sum(r) for r in g) + 1) // 2     

# select rows
for s in solve(8, g):
  print("answer:", ''.join(labels[g.index(r)] for r in s))

        Like

    • Ruud van der Ham's avatar

      Ruud van der Ham 11:06 am on 4 October 2026 Permalink | Reply

      Brute force.

      import itertools

rows = dict(A=[1, 2, 4, 6, 7], B=[2, 3, 6, 7], C=[3, 4, 5, 7], D=[1, 2, 3, 5], E=[1, 2, 3, 5, 6], F=[1, 3, 4, 7], G=[2, 4, 6, 7], H=[4, 5, 6])

for order in itertools.permutations(rows.keys()):
    columns = ["".join([" R"[c in rows[x]] for x in order]) for c in range(1, 8)]
    for column in columns:
        runs = list(map(len, column.split()))
        if runs.count(3) != 1 or any(n not in (1, 3) for n in runs):
            break
    else:
        r_in_top = "".join(column[:4] for column in columns).count("R")
        r_in_bottom = "".join(column[4:] for column in columns).count("R")
        if r_in_top > r_in_bottom:
            print(''.join(order))

      Like

  • Unknown's avatar

    Jim Randell 9:29 am on 3 October 2026 Permalink | Reply
    Tags:   

    Teaser 2340: [Five girls] 

    From The Sunday Times, 29th July 2007 [link]

    Five girls of different ages, 11 to 15, live in adjacent houses numbered 11 to 15, sit in different classrooms, 11 to 15, with different desk numbers, 11 to 15. Their ranked positions in class are different, too: 11 to 15. For each girl, these five numbers are different. Gina has house 14, classroom 11 and desk 13. Hilda came 13th in class and has desk 15. Iris’s classroom is 14. Jane, who is not [age] 13, has the same house number as Katy’s desk number.

    What are Katy’s age, house number, classroom number, desk number and position?

    This puzzle was originally published with no title.

    [teaser2340]

     
    • Jim Randell's avatar

      Jim Randell 9:29 am on 3 October 2026 Permalink | Reply

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

      It allocates values 1..5 (representing 11..15) to each attribute for each girl.

      It runs in 114ms. (Internal runtime of the generated code is 213µs).

      #! python3 -m enigma -rr

SubstitutedExpression

#         age
#         | house
#         | | classroom
#         | | | desk
#         | | | | position
#         | | | | |
#  Gina : A B C D E
#  Hilda: F G H I J
#  Iris : K L M N P
#  Jane : Q R S T U
#  Katy : V W X Y Z

# use digits 1-5 to stand for 11-15
--base=6
--digits="1-5"
# rows and columns have distinct values
--distinct="ABCDE,FGHIJ,KLMNP,QRSTU,VWXYZ,AFKQV,BGLRW,CHMSX,DINTY,EJPUZ"

# macros for the values
--macro="@11 = 1"
--macro="@12 = 2"
--macro="@13 = 3"
--macro="@14 = 4"
--macro="@15 = 5"

# "Gina has house 14, classroom 11, desk 13
"B = @14"
"C = @11"
"D = @13"

# "Hilda has position 13, desk 15"
"J = @13"
"I = @15"

# "Iris has classroom 14"
"M = @14"

# "Jane is not [age] 13, has the same house number as Katy's desk number"
"Q != @13"
"R = Y"

# output
--template="(A B C D E) (F G H I J) (K L M N P) (Q R S T U) (V W X Y Z)"
--solution=""
--verbose="1-W"

      And here is a short Python program to run the solver and prettify the output:

      from enigma import (SubstitutedExpression, chunk, printf)

# construct the solver
p = SubstitutedExpression.from_file(["{dir}/teaser2340.run"])

# run the solver
for s in p.solve(verbose=0):
  # output solution
  names = ["Gina", "Hilda", "Iris", "Jane", "Katy"]
  attrs = ["age", "house", "class", "desk", "pos"]
  for (name, ks) in zip(names, chunk("ABCDEFGHIJKLMNPQRSTUVWXYZ", 5)):
    printf("{name:6s}  \\", name=name + ":")
    for (v, k) in zip(attrs, ks):
      printf("{v}={x}  \\", x=s[k] + 10)
    printf()
  printf()

      Solution: For Katy: age = 11, house = 13, class = 15, desk = 12, position = 14th.

      The complete table is:

      Gina:   age=12  house=14  class=11  desk=13  pos=15  
Hilda:  age=14  house=11  class=12  desk=15  pos=13  
Iris:   age=13  house=15  class=14  desk=11  pos=12  
Jane:   age=15  house=12  class=13  desk=14  pos=11  
Katy:   age=11  house=13  class=15  desk=12  pos=14

      Like

    • Frits's avatar

      Frits 10:44 am on 3 October 2026 Permalink | Reply 

      from itertools import permutations

# check for different numbers per column
check = lambda g: all(len(s := [x for x in r if x]) == len(set(s)) 
                      for r in zip(*g)) 

# age, house number, classroom number, desk number and position  

dgts = set(range(11, 16))

# define grid
g = [[0] * 5 for _ in range(5)]

# "Gina has house 14, classroom 11, desk 13
g[0][1:4] = [14, 11, 13]

# "Hilda has position 13, desk 15"
g[1][3:] = [15, 13]

# "Iris has classroom 14"
g[2][2] = 14
 
sols, orig = set(), [list(r) for r in g]
# Gina
for g[0][0], g[0][4] in permutations(dgts.difference(orig[0]), 2):
  # Hilda
  for g[1][0], g[1][1], g[1][2] in permutations(dgts.difference(orig[1]), 3):
    if not check(g): continue
    # Iris
    for g[2][0], g[2][1], g[2][3], g[2][4] \
        in permutations(dgts.difference(orig[2]), 4):
      if not check(g): continue
      # Jane
      for g[3] in permutations(dgts, 5):
        # Jane is not [age] 13
        if g[3][0] == 13 or not check(g): continue
        # Jane has the same house number as Katy's desk number
        g[4][3] = g[3][1]
        # Kate
        for g[4][0], g[4][1], g[4][2], g[4][4] \
            in permutations(dgts - {g[4][3]}, 4):
          if not check(g): continue
          sols.add(tuple(g[4]))
        g[4] = orig[4]   
      g[3] = orig[3]      
    g[2] = orig[2]
    
print("answer:", ' or '.join(str(x) for x in sols))

      Like

    • Frits's avatar

      Frits 11:10 am on 3 October 2026 Permalink | Reply 

      from itertools import permutations

# check for different numbers per column
check = lambda g: all(len(s := [x for x in r if x]) == len(set(s)) 
                      for r in zip(*g)) 

dgts = set(range(11, 16))
# define constants
(G, H, I, J, K), (a, h, c, d, p) = (0, 1, 2, 3, 4), (0, 1, 2, 3, 4)

# define grid
g = [[0] * 5 for _ in range(5)]

# Gina has house 14, classroom 11, desk 13
g[G][1:4] = [14, 11, 13]

# Hilda has position 13, desk 15
g[H][3:] = [15, 13]

# Iris has classroom 14
g[I][c] = 14
 
sols, orig = set(), [list(r) for r in g]
# Gina (choose age and house number)
for g[G][a], g[G][p] in permutations(dgts.difference(orig[G]), 2):
  # Hilda (choose age, house number and classroom number)
  for g[H][a], g[H][h], g[H][c] in permutations(dgts.difference(orig[H]), 3):
    if not check(g): continue
    # Iris (choose age, house number, desk number and position)
    for g[I][a], g[I][h], g[I][d], g[I][p] \
        in permutations(dgts.difference(orig[I]), 4):
      if not check(g): continue
      # Jane
      for g[J] in permutations(dgts, 5):
        # Jane has the same house number as Katy's desk number
        g[K][d] = g[J][h]
        # Jane is not [age] 13
        if g[J][a] == 13 or not check(g): continue
        # Kate (choose age, house number, classroom number and position)
        for g[K][a], g[K][h], g[K][c], g[K][p] \
            in permutations(dgts - {g[K][d]}, 4):
          if not check(g): continue
          sols.add(tuple(g[K]))
        g[K] = orig[K]   
      g[J] = orig[J]      
    g[I] = orig[I]
    
print("answer:", ' or '.join(str(x) for x in sols))

      Like

      • Frits's avatar

        Frits 12:16 pm on 3 October 2026 Permalink | Reply

        Using constant variables instead of hardcoded digits slowed things down.
        Calculating the numbers for Kate out of the remaining column values also seems to cause a higher run time.

        Like

  • Unknown's avatar

    Jim Randell 9:50 am on 1 October 2026 Permalink | Reply
    Tags: by: Charles Doidge   

    Teaser 2346: [Empty Sudoku] 

    From The Sunday Times, 9th September 2007 [link]

    Draw yourself an empty 9 × 9 grid of squares like the frameworks used for Sudoku. Starting at the top left-hand square and working across each row in turn, in each square place the smallest digit possible, so that when you have finished, you have a typical Sudoku solution: i.e., the digits 1 to 9 occur in each row, in each column and in each of the nine 3 × 3 blocks.

    What are the last 3 digits in the bottom row?

    This puzzle was originally published with no title.

    [teaser2339]

     
    • Jim Randell's avatar

      Jim Randell 9:50 am on 1 October 2026 Permalink | Reply

      If you follow the instructions (and don’t make any mistakes), you can fill out the grid fairly easily.

      Here is a simple Python program the fills out the grid as specified, backtracking when an impossible situation occurs. We are only interested in the first solution, so [[ solve() ]] operates on the grid in-place.

      It runs in 75ms. (Internal runtime is 4.6ms).

      from enigma import (irange, subsets, join, printf)

digits = list(irange(1, 9))

# additional cells to be checked for a box
box = list([[], [], []] for _ in irange(3))
cells = subsets([0, 1, 2], size=2, select='M')
for ((r1, c1), (r2, c2)) in subsets(cells, size=2):
  if r1 != r2 and c1 != c2:
    box[r2][c2].append((r1 - r2, c1 - c2))

# fill out the first possible digit in each box
def solve(g, i=0):
  # are we done?
  if i == 81:
    yield g
  else:
    (r, c) = divmod(i, 9)
    for d in digits:
      # check col, row, box
      if any(d == g[x][c] for x in irange(r)): continue
      if any(d == g[r][y] for y in irange(c)): continue
      if any(d == g[r + x][c + y] for (x, y) in box[r % 3][c % 3]): continue
      g[r][c] = d
      yield from solve(g, i + 1)
      g[r][c] = 0

# find the first solution, starting with an empty grid
g0 = list([0] * 9 for _ in irange(9))
for g in solve(g0):
  # output solution
  printf("{g}", g=join(g, sep="\n"))
  break  # only want the first solution

      Solution: The last 3 digits on the bottom row are: 6, 4, 2.

      The complete grid is:

      Like

    • Frits's avatar

      Frits 4:14 pm on 1 October 2026 Permalink | Reply

      Using a 1-dimensional grid and precomputing “neighbours”.

      # dimensions NxN
N0 = 3        # boxsize
N = N0 * N0
N2 = N * N
dgts = range(1, N + 1)

row = lambda i: i // N 
col = lambda i: i % N
# return box number
box = lambda i: (i // (N * N0)) * N0 + (i % (N)) // N0

neighbours = []
# for each cell precompute it's neighbours (in same row, column or box))
for i in range(N2):
  r, c, b = row(i), col(i), box(i)
  neighbours.append([j for j in range(N2) if j != i and 
                    (row(j) == r or col(j) == c or box(j) == b)])

# recursively solve the sudoku
def solve(g, i=0):
  if i == N2: # done
    yield g
  else:
    # try to fill cell with numbers not yet used by it's neighbours
    used = {g[x] for x in neighbours[i]}
    for n in [j for j in dgts if j not in used]:
      g[i] = n
      yield from solve(g, i + 1)
      g[i] = 0 # backtrack

g = [0] * N2
for s in solve(g):
  #for k in range(N): print(g[k * N:k * N + N])    
  print("answer:", g[N2 - 3:])
  break # we only need the first solution

      Like

    • Frits's avatar

      Frits 12:15 pm on 2 October 2026 Permalink | Reply

      For some reason the 16×16 sudoku case is easy to solve and runs in ms. The 25×25 case will take days/months and needs more logic.

      Like

  • Unknown's avatar

    Jim Randell 6:10 am on 27 September 2026 Permalink | Reply
    Tags:   

    Teaser 3340: Generations Jay, Kay, Elle and Em 

    From The Sunday Times, 27th September 2026 [link] [link]

    Polygonian newborns are allocated a regular polygon talisman for the day of the month they are born (1st = triangle, 2nd = square to 31st = 33-agon). Super-auspicious birth dates occur when the talisman’s internal angle is a whole number of degrees and the month number (Jan = 1 to Dec = 12) divides into it exactly and the year is a multiple of it.

    Polygonians, Em, her mam Elle, Elle’s mam Kay and Kay’s dad Jay dined out on Jay’s birthday in 2024. Chef said, “Congratulations, you’re looking fit Jay. You’ll live to 100”. Elle stated they all had super-auspicious birth dates and her 2024 birthday was in the month after next. Em added that she and Kay had their 2024 birthdays in the month before last.

    Chef then deduced their birth dates with certainty.

    Find Em’s birth date.

    [teaser3340]

     
    • Jim Randell's avatar

      Jim Randell 6:11 am on 27 September 2026 Permalink | Reply

      This Python program generate all possible “super-auspicious” dates between 1925 and 2024, and then constructs possible (J, K, L, M) values according to the specified conditions. (I also included a minimum separation between generations, but this is not necessary to find the required answer. It also turns out that no days of the month beyond 28 are involved in super-auspicious dates, so we don’t need to perform any date validation).

      This gives multiple candidate dates, but the chef knows a fact we don’t know, and that is the date on which Jay’s party is being held. So we look for candidates where knowing Jay’s birthday allows the all birthdates to be determined.

      The program runs in 71ms. (Internal runtime is 413µs).

      from enigma import (
  defaultdict, namedtuple, irange, div, subsets, tuples,
  cproduct, filter_unique, unpack, sprintf, printf
)

Date = namedtuple("Date", "y m d")

# find "super-auspicious" dates (year -> month -> days)
date = defaultdict(lambda: defaultdict(set))
for d in irange(1, 31):
  n = d + 2
  # calculate internal angles of a regular n-gon
  a = div(360, n)
  if a is None: continue
  a = 180 - a
  # calculate possible months
  ms = list(m for m in irange(1, 12) if a % m == 0)
  # consider possible years
  for y in irange.round(1925, 2024, rnd='I', step=a):
    for m in ms:
      date[y][m].add(d)

# record possible (J, K, L, M) dates
ss = list()

# now find possible birthyears for J, K, L, M
for ys in subsets(sorted(date.keys()), size=4):
  # reject any sequences with <16 years between generations
  if any(b - a < 16 for (a, b) in tuples(ys, 2)): continue

  (Jy, Ky, Ly, My) = ys
  # choose a date for J
  for (Jm, Jds) in date[Jy].items():
    if Jm < 3 or Jm > 10: continue
    # L's birthday is 2 months later
    Lm = Jm + 2
    Lds = date[Ly].get(Lm)
    if not Lds: continue

    # M and K are 2 months earlier
    Mm = Km = Jm - 2
    Mds = date[My].get(Mm)
    Kds = date[Ky].get(Km)
    if not (Mds and Kds): continue

    for (Jd, Kd, Ld, Md) in cproduct([Jds, Kds, Lds, Mds]):
      ss.append((Date(Jy, Jm, Jd), Date(Ky, Km, Kd), Date(Ly, Lm, Ld), Date(My, Mm, Md)))

# the chef knows the date of the party
rs = filter_unique(ss, unpack(lambda J, K, L, M: (J.m, J.d)))

# output solution(s)
fmt = lambda t: sprintf("{t.y:04d}-{t.m:02d}-{t.d:02d}")  # format a date
for (J, K, L, M) in rs.unique:
  printf("J={J}, K={K}, L={L} M={M}", J=fmt(J), K=fmt(K), L=fmt(L), M=fmt(M))

      Solution: Em’s birthdate is: 28th July 2016.

      The dates for K, L, M are fixed. But there are two possible birthdates for J, we don’t know which is the right one, but the chef knows when the party is, so can determine the correct value.

      J: 3rd September 1944; or: 18th September 1944 (80 in 2024)
      K: 7th July 1960 (64 in 2024)
      L: 22nd November 1980 (44 in 2024)
      M: 28th July 2016 (8 in 2024)

      These dates are all super-auspicious:

      3rd = 5-gon; internal angle = 108°
      September = 9th month; 108 is divisible by 9
      1944 is divisible by 108.

      18th = 20-gon; internal angle = 162°
      September = 9th month; 162 is divisible by 9
      1944 is divisible by 162

      7th = 9-gon; internal angle = 140°
      July = 7th month; 140 is divisible by 7
      1960 is divisible by 140

      22nd = 24-gon; internal angle = 165°
      November = 11th month; 165 is divisible by 11
      1980 is divisible by 165

      28th = 30-gon; internal angle = 168°
      July = 7th month; 168 is divisibly by 7
      2016 is divisibly by 168

      There are 18 possible date sequences, which can be summarised as:

      J=1944-03-{18, 03}, K=1960-01-{07}, L=1980-05-{01, 02, 22}, M=2016-01-{08, 28}
      J=1944-04-{03}, K=1960-02-{07}, L=1980-06-{01, 02}, M=2016-02-{08, 28}
      J=1944-09-{18, 03}, K=1960-07-{07}, L=1980-11-{22}, M=2016-07-{28}

      Only in the last case does knowing the date of J’s birthday give all the others with complete certainty.

      Like

  • Unknown's avatar

    Jim Randell 4:24 pm on 25 September 2026 Permalink | Reply
    Tags:   

    Teaser 2339: [Antique tiles] 

    From The Sunday Times, 22nd July 2007 [link]

    Mr Pebbledash, the eccentric architect, had acquired some valuable antique rectangular tiles of sizes (in metres) 1×2, 2×3, 3×4, 4×5, 5×6 and 6×7.

    He wanted to design a rectangular room covered, as far as possible, with these six non-overlapping tiles. The remaining space (if any) would have to be filled with a modern [rectangular] tile.

    He achieved this, and has kept the modern tile as small as possible.

    What was the area of the room?

    This puzzle was originally published with no title.

    [teaser2339]

     
    • Jim Randell's avatar

      Jim Randell 4:31 pm on 25 September 2026 Permalink | Reply

      Here is a solution using the rectpack.py library from the enigma-plus repository.

      It runs in 81ms. (Internal runtime is 498µs).

      from enigma import (irange, inf, divisors_pairs, printf)
import rectpack

# solve the puzzle for a collection of tiles
def solve(tiles):
  # total area of the tiles
  A = sum(x * y for (x, y) in tiles)

  # consider possible total areas
  for T in irange(A, inf):
    sol = 0
    for (x, y) in divisors_pairs(T):

      # possible sizes of the modern tile
      xss = list([])
      xt = T - A
      if xt > 0:
        for (xx, xy) in divisors_pairs(xt):
          xss.append([(xx, xy)])

      # now consider possible antique + modern tiles
      for xs in xss:
        # can we pack them into the required rectangle?
        for ps in rectpack.pack(y, x, tiles + xs):
          printf("[{x} * {y} = {T}; additional tile = {xs}]")
          rectpack.output_grid(y, x, ps, start="", end="--")
          sol += 1
          break

    if sol > 0:
      printf("[{sol} solutions]")
      return

# solve the puzzle for the given tiles
solve([(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7)])

      Solution: The area of the room was 114 sq m.

      (The published solution printed this as: “114 square miles”).

      The room is 6 m × 19 m, and here is one possible layout:

      The additional modern tile is one of the 1×2 tiles.

      Like

  • Unknown's avatar

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

    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]

     
    • Jim Randell's avatar

      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.

      Like

      • NigelR's avatar

        NigelR 12:54 pm on 26 September 2026 Permalink | Reply

        @Jim. I reached the same answer as you but (as always!) in a rather less elegant way. However, looking again at the actual questions posed, it seems that the distribution between greens of the matches resolved before the 17th is completely irrelevant. Since all matches (m) must be played on greens 9 and 10, p[9]=p[10]=m. But since p[9]=4*p[17] and p[10]=9*p[18], m must be a multiple of the lcd of 4 and 9 ie 36. But the most the difference can be between p[17] and p[18] is 5 (the number of matches resolved on the 17th), hence m can only be 36. Which means that p[18] can only be 4 and p[17] is 9, irrespective of what happens on earlier greens. Hence there were 37 players, with 5 eliminated on the 17th green. Or am I missing something?

        Like

        • Jim Randell's avatar

          Jim Randell 2:54 pm on 29 September 2026 Permalink | Reply

          @NigelR: It is a nice piece of reasoning, that gives a neat manual solution. So you are not missing anything. (In fact, it is very similar to the solution published in the book).

          Like

        • Frits's avatar

          Frits 4:18 pm on 29 September 2026 Permalink | Reply

          @NigelR, nice deduction. To me it isn’t less elegant than Jim’s.

          Like

  • Unknown's avatar

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

    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]

     
    • Jim Randell's avatar

      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. [114..334].

      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 x2 / y4. (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 x2 / y4.

      Solution The two distances are 41 ft and 799 ft.

      With a = 41 and b = 799 we get:

      41 is prime, 799 = 17 × 47, so they are coprime.

      A = 799² / (41² + (41 + 799)²)
      ⇒
      A = p / q
      p = 638401 = 7992
      q = 707281 = 294

      However, if we allow fractions that are not reduced to their lowest terms there are many other solutions.

      For example:

      a = 19 (prime), b = 161 (= 7 × 23).

      A = 161² / (19² + (19 + 161)²) = 25921 / 32761

      this is not in the required format, but A can also be written as:

      A = 849197881 / 1073283121 = 291412 / 1814

      Like

      • Jim Randell's avatar

        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 x2 / y4, 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)

        Like

        • Jim Randell's avatar

          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).

          Like

      • Frits's avatar

        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)

        Like

    • Frits's avatar

      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

      Like

  • Unknown's avatar

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

    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's avatar

      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.

      Like

    • Frits's avatar

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

      Like

  • Unknown's avatar

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

    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]

     
    • Jim Randell's avatar

      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.

      Like

      • Frits's avatar

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

        Who is Martha?

        Like

      • Frits's avatar

        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.

        Like

        • Jim Randell's avatar

          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).

          Like

  • Unknown's avatar

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

    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]

     
    • Jim Randell's avatar

      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.

      Like

      • Jim Randell's avatar

        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

        Like

        • Frits's avatar

          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”.

          Like

          • Jim Randell's avatar

            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.

            Like

  • Unknown's avatar

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

    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's avatar

      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.

      Like

      • Ruud van der Ham's avatar

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

        Like

    • Frits's avatar

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

      Like

      • Ruud van der Ham's avatar

        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.

        Like

        • Frits's avatar

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

          Like

  • Unknown's avatar

    Jim Randell 6:10 am on 6 September 2026 Permalink | Reply
    Tags:   

    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]

     
    • Jim Randell's avatar

      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.

      Like

    • Ruud van der Ham's avatar

      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)

      Like

    • Ruud van der Ham's avatar

      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])

      Like

  • Unknown's avatar

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

    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's avatar

      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.

      Like

    • Ruud van der Ham's avatar

      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"
    ]
)

      Like

    • Frits's avatar

      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")

      Like

← Older posts

c
Compose new post
j
Next post/Next comment
k
Previous post/Previous comment
r
Reply
e
Edit
o
Show/Hide comments
t
Go to top
l
Go to login
h
Show/Hide help
shift + esc
Cancel
Create your own website, free on WordPress.com.Create your own website.
Start free