Recent Updates Toggle Comment Threads | Keyboard Shortcuts

  • Unknown's avatar

    Jim Randell 7:15 am on 15 November 2026 Permalink | Reply
    Tags:   

    Teaser 3347: Croquet league 

    From The Sunday Times, 15th November 2026 [link] [link]

    In our croquet league, everyone plays against everyone else exactly once during the season. At the end of the season, the top four players, ranked by number of wins (draws are not possible), progress to the playoff stage. If players are tied on number of wins, then individual game scores are used to determine the ranking. The minimum number of wins needed to guarantee progression (irrespective of individual game scores) is four times the maximum number of wins with which it is impossible to progress (again irrespective of game scores).

    How many players are in the league?

    [teaser3347]

     
    • Jim Randell's avatar

      Jim Randell 7:17 am on 15 November 2026 Permalink | Reply

      We can use the [[ landau() ]] function in the enigma.py library to check if a score sequence is viable. (Originally implemented for Teaser 3324).

      This Python program considers increasing numbers of players/teams (supposing there are at least 5 teams), and collects the top 4 scores (for the teams who progress) and the remaining scores (for the teams that don’t), and then calculates:

      A = the minimum number wins needed to guarantee progression
      B = the maximum number of wins with which it is impossible to progress

      Fortunately the solution is found for a relatively small number of teams, so the program runs in a reasonable time.

      This Python program runs in 108ms. (Internal runtime is 27ms).

      from enigma import (irange, inf, C, decompose, landau, printf)

# check a league with <n> teams
def check(n):
  # record:
  # A = numbers of wins for the teams that progress (top 4)
  # B = numbers of wins for teams that fail to progress (rest)
  (A, B) = (set(), set())
  # the total number of wins is ...
  t = C(n, 2)
  # find possible score sequences
  for ss in decompose(t, n, increasing=1, sep=0, min_v=0, max_v=n - 1):
    if not landau(n, ss): continue
    A.update(ss[-4:])
    B.update(ss[:-4])
  return (
    # the minimum number wins needed to guarantee progression
    min(A.difference(B)),
    # the maximum number of wins with which it is impossible to progress
    max(B.difference(A)),
  )

# consider increasing numbers of teams (at least 5)
for n in irange(5, inf):
  (A, B) = check(n)
  printf("{n} teams [A = {A}, B = {B}]")
  if A == 4 * B: break

      Solution: [To Be Revealed]

      In general we find:

      A = (n − 2)
      B = floor((n − 5) / 2)

      Like

  • Unknown's avatar

    Jim Randell 3:45 pm on 11 November 2026 Permalink | Reply
    Tags:   

    Teaser 2342: [Teaser and Mephisto] 

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

    On 8th April 2007 the number of the Teaser was 2324 and the number of Mephisto was 2432 — the same digits in a different order. Assuming Teaser number 1 appeared after Mephisto number 1, and that since then, each Sunday, one Teaser and one Mephisto have appeared, always correctly numbered …

    … on how many occasions were the digits of the Teaser number the same as those of the number of that day’s Mephisto?

    This puzzle was originally published with no title.

    [teaser2342]

     
    • Jim Randell's avatar

      Jim Randell 3:45 pm on 11 November 2026 Permalink | Reply

      This puzzle is straightforward to solve programatically by just looking backwards from the given numbers, and checking each previous week’s puzzles to see if they have the same digit content.

      This Python program runs in 84ms. (Internal runtime is 10ms).

      from enigma import (nsplit, printf)

# end numbers
(M, T) = (2432, 2324)

# count occurrences
n = 0

while M > 0 and T > 0:
  # same digits used?
  if sorted(nsplit(M)) == sorted(nsplit(T)):
    printf("[M = {M:d}, T = {T:d}]")
    n += 1
  # move on to the previous week
  M -= 1
  T -= 1

# output solution
printf("total occurrences = {n}")

      Solution: The puzzles have had the same digits on 37 occasions.

      Although, if the puzzles were always printed with a 4-digit puzzle number, then they would have had the same digits on 48 occasions:

      from enigma import (nsplit, printf)

# end numbers
(M, T) = (2432, 2324)

# count occurrences
n = 0

while M > 0 and T > 0:
  # same digits used?
  if sorted(nsplit(M, 4)) == sorted(nsplit(T, 4)):
    printf("[M = {M:04d}, T = {T:04d}]")
    n += 1
  # move on to the previous week
  M -= 1
  T -= 1

# output solution
printf("total occurrences = {n}")

      Like

    • Ruud van der Ham's avatar

      Ruud van der Ham 4:03 pm on 11 November 2026 Permalink | Reply 

      import peek
from collections import Counter

n = 0

for teaser in range(1, 2324 + 1):
    mephisto = teaser + 2432 - 2324
    if Counter(str(teaser)) == Counter(str(mephisto)):
        n += 1
        peek(teaser, mephisto)
peek(n)

      Like

  • Unknown's avatar

    Jim Randell 7:53 am on 8 November 2026 Permalink | Reply
    Tags:   

    Teaser 3346: Step-free axes 

    From The Sunday Times, 8th November 2026 [link] [link]

    Changing underground lines, we used a step-free access route: three lifts joining ends of pairs from four horizontal L-shaped corridors at different levels; the corridor segments ran on E-W or N-S axes, with a right-hand turn between the first and second.

    We started on the green corridor, walking 20 yards, turning right, and going 40 yards. This was at a lower level than the yellow one (30 yards, turning right then 50 yards); for blue, the values were 60 then 10; for red, 70 then 20. I’ve forgotten the direction the corridors started in, and the order of the last three. The route ended exactly above where we started.

    The arrangement had me in a knot — literally, because the route we followed actually formed a knot.

    What was the order of the corridors (e.g., B, G, R, Y), and the order of their levels (bottom to top)?

    [teaser3346]

     
    • Jim Randell's avatar

      Jim Randell 8:18 am on 8 November 2026 Permalink | Reply

      There are multiple variables:

      1. The orders of the segments (although we know G is the first)
      2. The levels of the segments (although we know G is lower than Y)
      3. The relative directions between the legs (we could exit each lift and follow a corridor in one of 4 directions)

      This Python program tries all possible arrangements, and for each constructs the corresponding path (as a collection of (x, y, z) points in 3-space). We reject any path where the endpoint is not directly above the start, or if the path is self intersecting. We then construct a knot diagram, which determines the “crossings” in the path, and see if (when the beginning and end of the path are joined together) the resulting structure can be untangled to form a simple loop, otherwise it forms a knot. (This is an unkotting problem [@wikipedia], which are generally quite hard, but for this puzzle we only need to deal with simple diagrams that have fewer than 4 crossings, so there is essentially only one possible non-trivial knot that could be constructed).

      It runs in 106ms. (Internal runtime is 22ms).

      from enigma import (
  Rational, Matrix, irange, inf, subsets, cproduct, tuples,
  delete, line_intersect, catch, compare, sprintf, printf
)

Q = Rational()

# the segments of the corridors
segs = {
  'G': (20, 40),
  'Y': (30, 50),
  'B': (60, 10),
  'R': (70, 20),
}

# labels for the corridors
ks = sorted(segs.keys())

# choose an order for the segments ('G' is first)
orders = list(ss for ss in subsets(ks, size=len, select='P') if ss[0] == 'G')

# assign levels to the segments ('G' is lower than 'Y')
levels = list()
for ss in subsets([0, 20, 40, 60], size=len, select='P'):
  d = dict(zip(ks, ss))
  if d['G'] < d['Y']:
    levels.append(d)

# choose a start direction (0 = E, 1 = N, 2 = W, 3 = S) for each leg
turns = list((0,) + ss for ss in subsets([0, 1, 2, 3], size=3, select='M'))

# check if line segments (p0, p1) and (q0, q1) intersect
# segments must be parallel to one of the x, y, z axes
def seg_intersect(p0, p1, q0, q1):
  for (a, b, c, d) in zip(p0, p1, q0, q1):
    if max(min(a, b), min(c, d)) > min(max(a, b), max(c, d)): return False
  return True

# is path self intersecting?
def self_intersecting(path):
  for (i, j) in subsets(irange(len(path) - 1), size=2):
    if j - i == 1: continue
    if seg_intersect(path[i], path[i + 1], path[j], path[j + 1]): return True
  return False

# now some knot theory:

# collapse the path along axis <z>, and determine crossings
def crossings(path, z=2):
  segs = list((p, q) for (p, q) in tuples(path, 2, circular=1) if p[z] == q[z])
  collapse = lambda p: delete(p, [z])
  # determine the crossings
  cs = list()
  for (i, j) in subsets(irange(len(segs)), size=2):
    (p1, p2) = (collapse(p) for p in segs[i])
    (p3, p4) = (collapse(p) for p in segs[j])
    r = catch(line_intersect, p1, p2, p3, p4, internal=1+2, div=Q)
    if r is None or (r.q1 in {0, 1} and r.q2 in {0, 1}): continue
    # level is -1 for under, +1 for over
    c = compare(segs[i][0][z], segs[j][0][z])
    # each crossing is encountered twice
    cs.extend([((i, r.q1), (i, j), c), ((j, r.q2), (i, j), -c)])
  # return the list of (<crossing id>, <level>) in order encountered
  cs.sort()
  return tuple(delete(t, [0]) for t in cs)

# calculate the knot determinant:
# the unknot has det = 1
# all non-trivial knots with fewer than 10 crossings have det > 1

# calculate the determinant from a series of crossings
def det(cs, n):
  # fewer than 2 crossings => loop
  if n < 2: return 1
  # enumerate the crossings and arcs
  (a, cn, num, over, under) = (0, dict(), irange(0, inf), dict(), dict())
  for (i, s) in cs:
    if i in cn:
      k = cn[i]
    else:
      k = cn[i] = next(num)
    if s > 0:
      over[k] = a
    else:
      a1 = (a + 1) % n
      under[k] = (a, a1)
      a = a1
  # construct the matrix:
  # each crossing gives 2 * (over arc) - (arc in) - (arc out) = 0
  rs = list()
  for i in irange(n):
    r = [0] * n
    r[over[i]] += 2
    for j in under[i]: r[j] -= 1
    rs.append(r)
  # calculate the knot determinant (by deleting a row and column from the matrix)
  return abs(Matrix((r[1:] for r in rs[1:]), field=Q).det())

# determine if <path> is a knot
def is_knot(path):
  # walk the path and determine crossings (each crossing appears twice)
  cs = crossings(path)
  n = len(cs) // 2
  # calculate the knot determinant for the diagram
  d = det(cs, n)
  # det > 1 is always a non-trivial knot
  if d > 1: return sprintf("KNOT (det {d})")
  # for diagrams with < 10 crossings, det = 1 identifies the UNKNOT
  # for larger diagrams the determinant is inconclusive
  return (None if n < 10 else sprintf("UNKNOWN (det {d})"))

# x,y multipliers for the directions (0 .. 3)
mvx = [+1,  0, -1,  0]
mvy = [ 0, +1,  0, -1]

# check if visiting the corridors in the specified order, levels, turn
# results in a path that is a knot
def check(order, level, turn):
  x = y = 0
  path = list()
  # accumulate line segments
  for (k, i) in zip(order, turn):
    z = level[k]
    path.append((x, y, z))
    (d1, d2) = segs[k]
    # move along the first corridor
    x += mvx[i] * d1
    y += mvy[i] * d1
    path.append((x, y, z))
    # turn right
    i = (i - 1) % 4
    # move along the second corridor
    x += mvx[i] * d2
    y += mvy[i] * d2
    path.append((x, y, z))

  # path must finish directly above starting point
  ((x0, y0, z0), (x1, y1, z1)) = (path[0], path[-1])
  if not (x0 == x1 and y0 == y1 and z0 < z1): return

  # path must not be self intersecting
  if self_intersecting(path): return

  # path must form a knot
  r = is_knot(path)
  if r is None: return  # None => UNKNOT (LOOP)

  printf("order = {order}; level = {level}; turn = {turn}")
  printf("-> path = {path}")
  printf("-> {r}")
  printf()

# choose one value from each category
for (order, level, turn) in cproduct([orders, levels, turns]):
  check(order, level, turn)

      Solution: The order the corridors were visited was: green, blue, red, yellow. And the order of the levels was: green (lowest), red, yellow, blue (highest).

      Here is a diagram (generated using Claude AI):

      The resulting knot is a trefoil knot [@wikipedia].

      Like

  • Unknown's avatar

    Jim Randell 5:26 pm on 4 November 2026 Permalink | Reply
    Tags:   

    Teaser 2345: [Gin and tonic] 

    From The Sunday Times, 2nd September 2007 [link]

    Some friends met for a celebration. The host poured everyone a gin and tonic. Each drink was the same size, but the proportion of gin and tonic varied from glass to glass. One contained a whole-number percentage of the gin used overall and a whole-number percentage of the tonic used overall. In fact, the first of those numbers happened to equal one half of the number of people present; the second number equalled a quarter of the number of people present.

    How many people were present?

    This puzzle was originally published with no title.

    [teaser2345]

     
    • Jim Randell's avatar

      Jim Randell 5:26 pm on 4 November 2026 Permalink | Reply

      Suppose there are n people present. We know both one half and one quarter of the number of people present are whole numbers, so n must be a multiple of 4.

      If each glass has a volume of 1 unit, then the total volume of the drinks is n, and this splits into the volume of gin G and the volume of tonic T.

      n = G + T

      One glass has (n/2)% of the gin and (n/4)% of the tonic:

      (n/2)G + (n/4)T = 100
      n(2G + T) = 400

      Substituting G + T = n we get:

      n(G + n) = 400

      This Python program looks for a viable value for n, where the quantities G and T are in the range (0, n).

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

Q = Rational()

# consider possible n values (n is multiple of 4)
for n in irange(4, inf, step=4):

  # calculate G and T
  G = Q(400, n) - n

  # look for a viable solution
  if 0 < G < n:
    printf("n={n} [G={G} T={T}]", T=n - G)
    break

      Solution: There were 16 people present.

      With 16 people, if the drinks were distributed equally, then each would contain 6.25% (= 1/16) each of the gin and the tonic.

      As it is, one glass gets 8% of the gin (more than their fair share) and 4% of the tonic (less than their fair share).

      And the remaining 92% of the gin and 96% of the tonic is distributed between the remaining 15 drinks.

      Manually:

      We know:

      0 < G < n

      Adding n to each term gives:

      n < G + n < 2n

      Multiplying each term by n gives:

      n² < n(G + n) < 2n²

      Hence:

      n² < 400 < 2n²
      ⇒
      n < 20
      n > 14.14…

      And n is an integer multiple of 4, so:

      n = 16

      Like

  • Unknown's avatar

    Jim Randell 7:47 am on 1 November 2026 Permalink | Reply
    Tags:   

    Teaser 3345: Locked together 

    From The Sunday Times, 1st November 2026 [link] [link]

    Our sports centre has lockers numbered from 100 to 400. My locker number is a multiple of three. If you list all the three-figure numbers that use the same digits as my locker number, then you find that they are all the sum of two primes and two-thirds of them are the difference of two squares.

    My wife’s locker number is one less than mine. If you list all the three-figure numbers that use the same digits as her locker number, then her list also has those two properties.

    What is my locker number?

    [teaser3345]

     
    • Jim Randell's avatar

      Jim Randell 7:48 am on 1 November 2026 Permalink | Reply

      I wasn’t sure if we were to discard rearrangements that had a leading zero. Although in the end it doesn’t matter if we do or not. [I decided that the most likely reading is that the puzzle wants us to consider all 3-digit rearrangements of the original number, so we need to allow for leading zeros in the tests].

      This Python program is a straightforward search of all multiples of 3 in the range [100, 400] with the property, and then checks if (n − 1) also has the property.

      It runs in 70ms. (Internal runtime is 3.7ms).

      from enigma import (irange, subsets, nsplit, nconcat, primes, seq_ordered, cache, printf)

# primes up to 3 digits
primes.expand(999)

# numbers that are the sum of two primes
sum_of_primes = set()
for p in primes.between(2, 500):
  sum_of_primes.update(p + q for q in primes.between(p, 999 - p))

# numbers that are the difference of two squares
diff_of_squares = set()
for a in irange(0, 500):
  sq_a = a * a
  for b in irange(a, 0, step=-1):
    d = sq_a - b * b
    if d > 999: break
    diff_of_squares.add(d)

@cache
def check_digits(ds):
  # all rearrangements of the digits <ds>
  ns = list(subsets(ds, size=len, select='mP', fn=nconcat))
  # total number of rearrangements
  t = len(ns)
  return (
    # <t> of them are sum of two primes
    len(sum_of_primes.intersection(ns)) == t and
    # (2/3) <t> of them are diff of two squares
    3 * len(diff_of_squares.intersection(ns)) == 2 * t
  )

# check number <n>
def check(n):
  # numbers using the same digits will give the same result
  return check_digits(nsplit(n, fn=seq_ordered))

# consider possible multiples of 3
for n in irange.round(100, 400, step=3, rnd='I'):
  if check(n) and check(n - 1):
    printf("lockers = {n} and {n1}", n1=n - 1)

      Solution: Your locker number is 285.

      Like

      • Jim Randell's avatar

        Jim Randell 3:31 pm on 1 November 2026 Permalink | Reply

        Here’s an alternative approach, which looks at possible sets of 3 digits, to find which sets have arrangements which satisfy the requirements (which have been reduced analytically to simple tests), and then adds those that are viable locker numbers to a set of candidates.

        We then look for 2 locker numbers in the candidate set, where one is a multiple of 3, and the other is the preceding integer.

        It has an internal runtime of 3.5ms, so is slightly faster.

        from enigma import (irange, subsets, nconcat, primes, printf)

# primes up to 3-digits
primes.expand(999)

def is_sum_of_two_primes(n):
  # even numbers: Goldbach's conjecture has been verified for n up to 4e+18
  # odd numbers: n = 2 + p
  return (n > 2 if n % 2 == 0 else primes.contains(n - 2))

def is_diff_of_two_squares(n):
  # only numbers with n % 4 != 2 can be expressed as the difference of two squares
  return (n % 4 != 2)

# record locker numbers with the required properties
ns = set()

# consider 3-digits
for ds in subsets(irange(0, 9), size=3, select='R'):
  # arrange the digits into numbers
  rs = list(subsets(ds, size=len, select="mP", fn=nconcat))
  # total count
  t = len(rs)
  # how many are the difference of two squares
  d = sum(1 for n in rs if is_diff_of_two_squares(n))
  if 3 * d != 2 * t: continue
  # how many are the sum of two primes?
  p = sum(1 for n in rs if is_sum_of_two_primes(n))
  if p != t: continue
  # record numbers in the designated range
  for n in rs:
    if 100 <= n <= 400:
      ns.add(n)

# look for consecutive pairs
for n in ns:
  if n % 3 == 0 and n - 1 in ns:
    printf("lockers = {n} and {n1}", n1=n - 1)

        Like

    • Ruud van der Ham's avatar

      Ruud van der Ham 9:17 am on 1 November 2026 Permalink | Reply 

      import istr


def is_sum_of_two_primes(n):
    return any(i.is_prime() and (n - i).is_prime() for i in istr.range(2, n // 2 + 1))


def is_difference_of_two_squares(n):
    return n % 4 != 2


def has_two_properties(locker_number):
    return (
        sum(is_sum_of_two_primes(x) for x in istr.permutations(locker_number, join=True)) == 6
        and sum(is_difference_of_two_squares(x) for x in istr.permutations(locker_number, join=True)) == 4
    )


for my_locker_number in istr.range(102, 401, 3):
    if has_two_properties(my_locker_number) and has_two_properties(my_locker_number - 1):
        print("my locker number is", my_locker_number)

      Like

      • Ruud van der Ham's avatar

        Ruud van der Ham 9:49 am on 1 November 2026 Permalink | Reply

        This works because an integer can be expressed as a difference of two integer squares if and only if its remainder when divided by 4 is not 2.

        Liked by 1 person

  • Unknown's avatar

    Jim Randell 10:29 am on 31 October 2026 Permalink | Reply
    Tags:   

    Brain-Teaser 48: Championship chances 

    From The Sunday Times, 18th February 1962 [link]

    Wolfe was playing Lambe in a match (over the best of five sets) for our Lawn Tennis Championship. At the end of the third set Wolfe was leading by two sets to one, the score being 5-7, 8-6, 6-4.

    “It is strange”, said Fred, “that though there were at least half a dozen service breaks in the first set, there was only one service break in the next 22 games”.

    “It is even more strange”, said David, “that if only Wolfe had lost the very first game (and all other game results had remained unchanged) he would be champion now. As it is he might easily lose”. (In fact Lambe went on to win the championship by three sets to two, though that does not concern us here).

    Which of the first 36 games did Wolfe actually win?

    Who served in that vital [first] game?

    And what would the score have been if Wolfe had lost that first game?

    [teaser48]

     
    • Jim Randell's avatar

      Jim Randell 10:29 am on 31 October 2026 Permalink | Reply

      You need to know a little bit about tennis to solve this puzzle. Specifically:

      A player wins a set if they are the first to win 6 games, and have a lead of at least 2 games. If not, play continues until one player does have a lead of 2 games.

      One player serves for the whole of each game, and in the next game the other player serves (even if it is in a new set).

      If a player loses a game that they are serving, then this is a “service break”.

      This Python 3 program considers possible sequences of games with the required number of service breaks, and where changing the outcome of the first game (but none of the others) leads to a match win for W.

      It runs in 92ms. (Internal runtime is 12ms).

      from enigma import (trim, first, printf)

# labels for the players
(p0, p1) = players = "WL"

# find a sequence of games that gives the required scores
def games(x, y, gs=""):
  if x == y == 0:
    yield gs
  else:
    if x > 0:
      yield from games(x - 1, y, gs + p0)
    if y > 0:
      yield from games(x, y - 1, gs + p1)

# play games <gs> until a set is won
# return (<score>, <remaining games>)
# <remaining games> is None if the set is incomplete
def play_set(gs):
  x = y = 0
  for g in gs:
    if g == p0: x += 1
    elif g == p1: y += 1
    else: return
    if abs(x - y) >= 2 and (x >= 6 or y >= 6):
      # return score, and any unused games from the sequence
      return ((x, y), trim(gs, head=x + y))
  return ((x, y), None)  # None = set is incomplete

# is the set complete?
# i.e. the set is won/lost, and all games are consumed
def set_complete(gs):
  (s, gs) = play_set(gs)
  return (gs == "")

# count the breaks (where the winner is not the server)
# i = index of initial server
def breaks(gs, i=0):
  n = 0
  for g in gs:
    n += (g != players[i])
    i ^= 1
  return n

# play a match from games <gs>
# return (<scores>, <remaining games>)
def play_match(gs):
  x = y = 0
  ss = list()
  while gs:
    (s, gs) = play_set(gs)
    ss.append(s)
    if gs is not None:
      (sx, sy) = s
      if sx > sy: x += 1
      if sy > sx: y += 1
      if x == 3 or y == 3: break
  return (ss, gs)

# we know W won the first game; so allocate the remaining games in set 1
S1 = list(gs for gs in games(4, 7, "W") if set_complete(gs))
# allocate games for sets 2 and 3
S2 = list(gs for gs in games(8, 6) if set_complete(gs))
S3 = list(gs for gs in games(6, 4) if set_complete(gs))

# consider possible sequence of games for sets 2, 3, 1:
# choose the index of service at the start of set 2
for i2 in [0, 1]:
  # allocate games in set 2
  for gs2 in S2:
    # at most 1 service break in the second set
    b2 = breaks(gs2, i2)
    if b2 > 1: continue

    # allocate the games in set 3
    for gs3 in S3:
      # exactly 1 service break in set 2 and the first 8 games of set 3
      i3 = (i2 + len(gs2)) % 2
      b3 = breaks(first(gs3, 8), i3)
      if b2 + b3 != 1: continue

      # allocate the games in set 1
      for gs1 in S1:
        # there should be at least 6 service breaks in the first set
        i1 = (i2 - len(gs1)) % 2
        b1 = breaks(gs1, i1)
        if not (b1 >= 6): continue

        # now consider the current game sequence, but with L winning the first game
        xs = 'L' + trim(gs1 + gs2 + gs3, head=1)
        (ss, rs) = play_match(xs)
        if rs is None: continue
        # find a match where W wins 3 of the sets
        if not (sum(x > y for (x, y) in ss) == 3): continue

        # output solution
        printf("sets: 1={gs1} 2={gs2} 3={gs3}; start={i}", i=players[i1])
        printf("-> W could have won {ss}")
        printf()

      Solution: Wolfe won games: 1, 7, 8, 9, 10, 14, 16, 18, 20, 22, 24, 25, 26, 28, 30, 32, 34, 35, 36. Lambe served in the first game. If Wolfe had lost the first game he would have won the match 0-6, 6-4, 6-4, 6-4.

      The games won in each set were:

      S1: (5-7) W L L L L L W W W W L L
      S2: (8-6) L W L W L W L W L W L W W W
      S3: (6-4) L W L W L W L W W W

      If Wolfe had lost the first game, the remaining games would have played out as follows:

      S1: (0-6) L L L L L L
      S2: (6-4) W W W W L L L W L W
      S3: (6-4) L W L W L W L W W W
      S4: (6-4) L W L W L W L W W W

      Like

  • Unknown's avatar

    Jim Randell 10:03 am on 29 October 2026 Permalink | Reply
    Tags:   

    Teaser 2344: [Football league] 

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

    The Borsetshire League has 20 teams. After each had played one match, I looked at the league table. Teams were in order, and no two were level (positions decided by points won, then goal difference in the event of ties, then goals scored if they still tied). The top team had not played the bottom team. And, though Perks had scored a hat-trick, his team, Ambridge, were in the bottom half. If you knew the total number of goals scored, you could work out all the scores.

    What, in order, were the scores in the matches played by the 10 leading teams?

    This puzzle was originally published with no title.

    [teaser2344]

     
    • Jim Randell's avatar

      Jim Randell 10:03 am on 29 October 2026 Permalink | Reply

      There are 20 teams, and each has played exactly 1 match, so there have been 10 matches played. And no match can have been drawn, as we cannot differentiate between the teams that played in a drawn match.

      So we are looking for 10 matches that are won/lost. The teams that won are in the top half, and the teams that lost are in the bottom half. And one of the teams that lost scored (at least) 3 goals (so there must have been at least 7 goals scored in that match).

      This Python 3 program considers possible increasing total numbers of goals scored in the tournament. It then divides the total number of goals among the 10 matches, and allocates different score lines for each match, and looks to see if they make a valid order. If there is only a single valid order, then we have found a solution to the puzzle.

      It runs in 165ms. (Internal runtime is 95ms).

      from enigma import (
  irange, inf, decompose, multiset, subsets, rev, singleton,
  ulambda, cache, printf
)

# return possible matches with <n> goals scored
@cache
def matches(n):
  return list(decompose(n, 2, increasing=-1, sep=1, min_v=0))

# choose matches for the totals given in multiset <m>
def choose(m, rs=list()):
  # are we done?
  if not m:
    yield rs
  else:
    # allocate different matches for the next goal total
    k = m.peek()
    for ms in subsets(matches(k), size=m.count(k)):
      yield from choose(m.copy().discard(k), rs + list(ms))

# sort matches according to (goal difference), then (goals scored)
order = ulambda("(x, y): (x - y, x)")

# find viable orders for a given total number of goals <t>
def solve(t):
  # decompose the total into 10 matches
  for ms in decompose(t, 10, increasing=1, sep=0, min_v=1):
    # one of the matches must have at least 7 goals scored
    if max(ms) < 7: continue
    # all matches must be different
    m = multiset.from_seq(ms)
    if any(v > len(matches(k)) for (k, v) in m.items()): continue

    # choose winning matches for each total
    for ws in choose(m):
      # there must be a team that lost with at least 3 goals
      if not any(y >= 3 for (x, y) in ws): continue
      # each match won is also lost
      ms = list(ws)
      ms.extend((y, x) for (x, y) in ws)
      # put the matches in order
      ss = sorted(ms, key=order, reverse=1)
      # the top team did not play the bottom team
      if ss[0] == rev(ss[-1]): continue
      # valid order
      yield ss

# consider possible total goals scored in the 10 matches
for t in irange(10, inf):
  # is there a single viable order?
  ss = singleton(solve(t))
  if ss:
    printf("{t} total goals")
    printf("-> {ss}")
    break

      Solution: The scores (in order) of the matches played by the top 10 teams was:

      1st: 5 – 1
      2nd: 4 – 0
      3rd: 4 – 1
      4th: 3 – 0
      5th: 3 – 1
      6th: 2 – 0
      7th: 4 – 3
      8th: 3 – 2
      9th: 2 – 1
      10th: 1 – 0

      There were 40 goals scored in the tournament.

      The bottom half of the table looks like this (scores from the losing teams perspective):

      11th: 3 – 4 [losing hat-trick]
      12th: 2 – 3
      13th: 1 – 2
      14th: 0 – 1
      15th: 1 – 3
      16th: 0 – 2
      17th: 1 – 4
      18th: 0 – 3
      19th: 1 – 5
      20th: 0 – 4

      We see that the top team did not play the bottom team. The matches are (1st vs 19th) and (2nd vs 20th), and the 11th team lost (to the 7th), even though they had scored 3 goals.

      Like

  • Unknown's avatar

    Jim Randell 6:21 am on 25 October 2026 Permalink | Reply
    Tags:   

    Teaser 3344: Wining and dying 

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

    You are a king with 15 wine barrels in your cellar. You know that exactly one of the barrels contains a lethal poison, but you do not know which. On day one you give some wine (or none) to each of your four wine tasters. Any who took poison will be dead by the next day. The trouble is that you cannot tell the tasters apart, so if any of them do die you cannot be certain what wine it was you gave them. On day two you observe how many are still alive and can repeat the process with them, carrying on until you have identified the poisoned barrel.

    On which day can you be absolutely certain which is the poisoned wine?

    [teaser3344]

     
    • Jim Randell's avatar

      Jim Randell 6:22 am on 25 October 2026 Permalink | Reply

      If we cannot distinguish the tasters, then the outcome of a tasting is how many of the tasters survive. So with 4 tasters the possible outcomes are that 0, 1, 2, 3, 4 of them survive, which is only 5 possible outcomes. And there are 15 barrels, so we are going to need more than 1 round of tastings.

      Let B(k, r) be the maximum number of barrels that can be resolved given k tasters and r rounds of tasting.

      In 0 rounds we can only determine the poison barrel if there is only 1 barrel to choose from.

      B(k, 0) = 1

      In 1 round of tasting there can be (k + 1) different outcomes (i.e. 0 .. k of the tasters die). So, if we label the barrels 0 .. k, and have the same number of tasters taste each barrel as the number on the label, then we can determine the poison barrel directly from the number of tasters that die.

      B(k, 1) = k + 1

      For r > 1 we can have groups of barrels that are tasted by 0 .. k of the tasters, and the number of barrels that we allocate to each group must be the number that can be resolved by the surviving tasters (who were not part of that group).

      B(k, r) = sum (j = 0 .. k) B(j, r − 1)

      This gives a straightforward recursive implementation of B(k, r).

      This Python program looks at increasing numbers of rounds with 4 tasters, until we are able to resolve 15 barrels.

      from enigma import (irange, inf, cache, arg, printf)

# B(k, r) = max number of barrels that can be resolved
# with <r> rounds of tasting and <k> tasters (initially)
@cache
def B(k, r):
  # in 0 rounds we can resolve 1 barrel
  if r == 0: return 1
  # [optional] in 1 round we can resolve (k + 1) barrels
  if r == 1: return k + 1
  # otherwise allocate barrels to tasters according to how many
  # barrels can be resolved by j surviving tasters in (r - 1) rounds
  return sum(B(j, r - 1) for j in irange(0, k))

n = arg(15, 0, int, prompt="number of barrels")
k = arg(4, 1, int, prompt="number of tasters")

# find minimum number of rounds to resolve <n> barrels
for r in irange(0, inf):
  b = B(k, r)
  printf("[B({k}, {r}) = {b}]")
  if b >= n:
    printf("{n} barrels, {k} tasters -> {r} rounds")
    break

      We can determine the poison barrel after 2 rounds of tasting, so:

      Solution: On the third day we can be certain which barrel is poisoned.

      Here is a decision tree for resolving the situation in (at most) 2 rounds of tastings:

      Label the barrels 1 .. 15, and the tasters A, B, C, D:

      For the first round of tasting:

      A = 1
      B = 1, 2, 3
      C = 1, 2, 3, 4, 5, 6
      D = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
      untasted = 11, 12, 13, 14, 15

      If all 4 tasters die, then barrel 1 is poison (determined after 1 round).

      If 3 tasters die, then the poison barrel is 2 or 3 (2 barrels), and we have 1 taster remaining (see 2a).

      If 2 tasters die, then the poison barrel is 4, 5, or 6 (3 barrels), and we have 2 tasters remaining (see 2b).

      If 1 taster dies, then the poison barrel is 7, 8, 9, or 10 (4 barrels), and we have 3 tasters remaining (see 2c).

      If all tasters survive, then the poison barrel is 11, 12, 13, 14, or 15 (5 barrels), and we have 4 tasters remaining (see 2d).

      After 1 round, we have determined that barrel 1 is poisoned (and lost all tasters), or we require another round of tasting.

      Round 2a:

      A = 2
      untasted = 3

      If the taster dies, then the poison barrel is 2; if not the poison barrel must be 3.

      After 2 rounds, we have determined that barrel 2 is poison (and lost all tasters); or barrel 3 is poison (and 1 taster survived).

      Round 2b:

      A = 4
      B = 4, 5
      untasted = 6

      If both tasters die, then the poison barrel is 4.

      If one taster dies, then the poison barrel is 5.

      If both tasters survive, then the poison barrel is 6.

      After 2 rounds, we have determined the poison barrel is 4 (no survivors), 5 (1 survivor), or 6 (2 survivors).

      Round 2c:

      A = 7
      B = 7, 8
      C = 7, 8, 9
      untasted = 10

      If all 3 tasters die, then the poison barrel is 7.

      If 2 tasters die, then the poison barrel is 8.

      If 1 taster dies, then the poison barrel is 9.

      If all tasters survive, then the poison barrel is 10.

      After 2 rounds, we have determined the poison barrel is 7 (no survivors), 8 (1 survivor), 9 (2 survivors), or 10 (3 survivors).

      Round 2d:

      A = 11
      B = 11, 12
      C = 11, 12, 13
      D = 11, 12, 13, 14
      untasted = 15

      If all 4 tasters die, then the poison barrel is 11.

      If 3 tasters die, then the poison barrel is 12.

      If 2 tasters die, then the poison barrel is 13.

      If 1 taster dies, then the poison barrel is 14.

      If all tasters survive, then the poison barrel is 15.

      After 2 rounds, we have determined the poison barrel is 11 (no survivors), 12 (1 survivor), 13 (2 survivors), 14 (3 survivors), or 15 (4 survivors).

      On the first day, the first round of tasting occurs. And we have to wait for the results.

      On the second day, we find out how many of the tasters have survived. If none have, then the barrel that they all tasted is the poison one (determined after 1 round). Otherwise, we proceed to the second round of tasting with the surviving tasters.

      On the third day, the result of the second round of tasting will be apparent, and the poison barrel can be determined.

      So, whichever barrel is poisoned, we can be sure that the poison barrel is determined by the third day.

      In general, if C(n, r) is the combinatorial function (sometimes written nCr), we have:

      B(k, r) = C(k + r, k) = C(k + r, r)

      In this case:

      % python3
>>> C(4 + 2, 2)
15

      See also: Teaser 2784.

      Like

      • NigelR's avatar

        NigelR 2:16 pm on 27 October 2026 Permalink | Reply

        Try this!

        #display pots for this round of tasting and return player's answer on consequent deaths
def print_pots(s,t):
    print (f'It is now Day {day} and {t} taster(s) are still alive.')
    print ('How many tasters will die if each of the pots below is drunk by a different taster?')
    while len(s)%t:s.append([])
    for i in range(t):
        print (f'Pot {i+1}: {[s[j] for j in range(i,len(s),t) if s[j]]}')
    while True:
        try:
            deaths = int(input(f'enter 0 - {t}:  '   ))
            if 0 <= deaths <= t:
                return deaths
            print (f' Try again - entry must be between 0 and {t}')
        except ValueError:
            print (f' Entry must be a whole number between 0 and {t}')

# identifies barrels that should be included in todays's sampling pots
samples = lambda s: flatten( [[lookup[k]]*int(k[day-1]) for k in s])
flatten = lambda l : [i for item in l for i in item if i]

print('\n\n\n  There are 15 barrels of wine, just one of which contains a lethal poison. Up to 4 tasters will each sample a')
print('different pot containing a mix of wines. Anyone sampling a pot with the poisoned wine in the mix will die.')
print('You are now asked to choose which is the poisoned barrel and then, without disclosing your selection, answer')
print('questions on the tasting outcomes based on your choice. \n')

day = 1
tasters = 4
#generate 2 digit code for each barrel based on @Jim Randall's analysis
seq=[str(5-b)+str(i) for b in range(5,0,-1) for i in range(b)]
code = {i: seq[i-1] for i in range(1, 16)}
#create inverse lookup to identify barrel from code
lookup = {code[i]:i for i in code.keys()}
samp = samples(seq)
d1 = print_pots(samp,tasters)
day = 2
tasters -= d1
seq2 = [s for s in seq if int(s[0]) == d1]
d2 = print_pots(samples(seq2),tasters)
ans = lookup[str(d1)+str(d2)]
print(f'The poison was in barrel {ans}')

        Like

        • Jim Randell's avatar

          Jim Randell 11:20 am on 28 October 2026 Permalink | Reply

          Nice. I am going to post a decision tree when I give the details of my solution on Saturday. (Although not a program to generate the tree, like I did for Teaser 1342).

          (I had to rescue the [code] tag in your comment, as the language="python" parameter had non-ASCII quotation marks, so WordPress didn't understand it, but hopefully the rest of the code came through OK once that was fixed).

          Also, there is a problem if all 4 tasters are poisoned on the first tasting, then the program gives an error.

          Like

          • NigelR's avatar

            NigelR 3:45 pm on 28 October 2026 Permalink | Reply

            Schoolboy error, and thanks for spotting! I did originally test for 4 deaths on day 1 but that was before I tried to be cute and added a padding test of %t. Line 38 becomes:’ if not tasters: d2 = 0’. Next line is ‘else: d2 = print_pots(…etc)

            Like

  • 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: The initial non-integer score was 4/3.

      The sequence is: [4/3, 4, 12, 36, 108, 324, 972, 2916, 8748, 26244, 78732, …].

      So it starts off with a non-integer S[0] value, but then each subsequent S[k] value is an integer (common ratio is 3).

      In general: S[k] = 8 . p^k / (9 − p).

      For p = 2 the value is always a non-integer (S[k] = 2^(k + 3) / 7).

      For p = 3 the first value is non-integer (S[0] = 4/3), but subsequent values are integer. (S[k] = 4 . 3^(k − 1)).

      For p = 5 the values are always integer. (S[k] = 2 . 5^k).

      For p = 7 the values are always integer. (S[k] = 4 . 7^k).

      If the p value is not restricted to primes, there is also a solution at p = 6:

      S[k] = 2^(k + 3) . 3^(k − 1)
      S = [8/3, 16, 96, 576, 3456, 20736, 124416, 746496, 4478976, 26873856, 161243136, …]

      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

← 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