Recent Updates Toggle Comment Threads | Keyboard Shortcuts

  • Unknown's avatar

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

    Teaser 3337: Hidden PINs 

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

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

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

    What is the debit card PIN?

    [teaser3337]

     
    • Jim Randell's avatar

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

      This Python program uses the [[ SubstitutedExpression ]] solver from the enigma.py library to generate possible candidate PINs directly from the conditions given in the puzzle text. And then uses the [[ filter_unique() ]] function to determine which of the candidates provides the answer to the puzzle.

      It runs in 69ms. (Internal runtime is 3.8ms)

      from enigma import (SubstitutedExpression, filter_unique, fcompose, item, is_duplicate, printf)

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

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

# if we knew whether the tel PIN had repeated digits, we could work out both PINs
frep = fcompose(item(0), is_duplicate)
for (t, c) in filter_unique(generate(), frep).unique:
  printf("(repeat = {f}) -> tel = {t:04d}, card = {c:04d}", f=frep((t, c)))

      Solution: [To Be Revealed]

      Like

    • Ruud van der Ham's avatar

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

      import peek
import istr

for tel_pin in istr.squares(length=4):
    for card_pin01 in istr.range(length=2):
        card_pin = card_pin01 | tel_pin.sqrt()
        if card_pin.all_distinct() and card_pin.is_decreasing() and len(set(tel_pin) & set(card_pin)) == 0 and not tel_pin.all_distinct():
            peek(tel_pin, card_pin)

      Like

    • Ruud van der Ham's avatar

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

      I misread the last clause and thought it said that the telephone pin HAS any repeated digits.

      This is an updated version:

      import istr

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

      Like

  • Unknown's avatar

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

    Teaser 2365: [Madison’s square garden] 

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

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

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

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

    This puzzle was originally published with no title.

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

    [teaser2365]

     
    • Jim Randell's avatar

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

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

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

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

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

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

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

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

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

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

      Like

    • Ruud van der Ham's avatar

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

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

      Like

    • Frits's avatar

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

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

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

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

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

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

      Like

  • Unknown's avatar

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

    Brain-Teaser 870: Think of a number 

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

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

    “Right”, said Sue.

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

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

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

    Sue told him — precisely.

    “It can’t be”, said Martin.

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

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

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

    What was the number?

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

    [teaser870]

     
    • Jim Randell's avatar

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

      If the procedure is followed correctly, the series of operations results in a value that is the same as the input value.

      Martin says: “It can’t be”, so we are interested in results that can be made by missing out one of the steps, but are not 2-digit whole numbers (10 – 99).

      The following Python program examines possible input numbers and missing steps to find situations where the results is a finite number, greater than one, that is not a possible start number.

      It then looks to situations where knowing the result of the process is not enough information to determine the starting number. And from the remaining candidates it looks for situations where also missing out an additional step can give a result that is 1/100th the starting number.

      It runs in 78ms. (Internal runtime is 1.5ms).

      from enigma import (Rational, irange, filter_unique, unpack, empty, seq2str, printf)

Q = Rational()

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

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

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

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

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

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

  printf()

      Solution: Sue’s starting number was 20.

      There are only 4 candidates where missing a step will lead to a viable result:

      20 → (miss 4) → 4
      40 → (miss 5) → 4
      45 → (miss 4) → 4.5
      45 → (miss 5) → 4.5

      So Sue told Martin “4”, or “4.5”.

      If he had been told “4.5” he would know that the starting number was 45 (although not which step was missed).

      So he must have been told “4” and the starting number was 20 or 40.

      Starting with 20 and missing steps 3 and 4, gives a result of 0.2 = 20/100.

      Like

    • Frits's avatar

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

      Starting with two missing steps and using the golden section search method to find the n’s (20 and 45) is slightly less efficient.

      Like

  • Unknown's avatar

    Jim Randell 7:25 am on 30 August 2026 Permalink | Reply
    Tags: ,   

    Teaser 3336: Gardener’s canes 

    From The Sunday Times, 30th August 2026 [link] [link]

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

    What was the length of the shortest broken piece?

    As published there is no solution to this puzzle.

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

    An apology was published with Teaser 3337.

    [teaser3336]

     
    • Jim Randell's avatar

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

      Using some useful routines from the enigma.py library, I was able to write a short program for this puzzle.

      Unfortunately I was not able to find a solution using the values given in the puzzle text.

      However, if we make the long rods 98 inches long (instead of 94 inches long), then there is a viable solution. (Perhaps the car extruded the canes, so the two pieces together ended up longer than the original cane).

      The longest and shortest pieces must come from the same cane, and likewise the remaining pieces. This Python program considers what integer sided triangles could be made from a broken rod of length L, and a complete rod of length S, that have an integer area. And then looks for two such triangles that differ by the required amount D.

      It runs in 80ms. (Internal runtime is 232µs).

      from enigma import (decompose, triangle_iarea, subsets, printf)

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

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

# now look for 2 breaks with the required difference in area
for ((k1, A1), (k2, A2)) in subsets(r.items(), size=2):
  if not (abs(A1 - A2) == D): continue
  # output solution
  bits = sorted(k1 + k2)
  printf("bits = {bits} [{L} = {k1} -> {A1}; {L} = {k2} -> {A2}]")

      In my alternative formulation of the puzzle, the solution is:

      Solution: The shortest piece was 20 inches long.

      The breaks are:

      98 = 20 + 78 → (20, 78, 70) triangle = area 672
      98 = 42 + 56 → (42, 56, 70) triangle = area 1176

      The (42, 56, 70) triangle = 14×(3, 4, 5).

      Like

    • Frits's avatar

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

      Using 98 inches and the constant semi-perimeter 84 in the analysis.

      from collections import defaultdict

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

target = 504 
long, short = 98, 70

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

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

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

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

print("answer:", ' or '.join(str(min(s)) for s in sols), "inches")

      Like

    • Ruud's avatar

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

      Assuming 98 instead of 94 (as suggested by Jim)

      import peek
import istr

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


n1 = 98
n2 = 70
for l1, l2 in istr.combinations(range(1, n1 // 2 + 1), 2):
    lengths = sorted((l1, n1 - l1, l2, n1 - l2))
    area1 = area(n2, lengths[0], lengths[3])
    area2 = area(n2, lengths[1], lengths[2])
    if abs(area1 - area2) == 504:
        peek(l1, l2, lengths)

      Like

    • Frits's avatar

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

      import pells

target = 504

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

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

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

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

      Like

      • Jim Randell's avatar

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

        Ha!

        I’d just written a program to look for triangles using a Pell’s equation. But it just ends up doing a brute force search.

        If L is split into (L/2 − x, L/2 + x) then the area of the triangle with S is given by:

        (4A)² = (L + S)(L − S)(S + 2x)(S − 2x)
        16A² = (L² − S²)(S² − 4x²)
        ⇒
        16A² + 4(L² − S²)x² = (L² − S²)S²

        which is a form of Pell’s equation.

        from enigma import (ediv, sq, printf)
import pells

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

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

# find solutions for L = (hL + x, hL - x)
for (A, x) in pells.diop_quad(a, b, c):
  if not (A > 0): continue
  (L1, L2) = (hL - x, hL + x)
  printf("tri({L1}, {L2}, {S}) -> area {A}")

        Even if we set [[ pells.cornacchia_threshold = 0 ]], if we set the environment variable PY_ENIGMA=v we see:

        % PY_ENIGMA=v python3 teaser3336pells.py
[a=16 b=18816 c=23049600]
[pells] brute forcing 33 values
tri(20, 78, 70) -> area 672
tri(24, 74, 70) -> area 840
tri(30, 68, 70) -> area 1008
tri(42, 56, 70) -> area 1176

        Like

        • Frits's avatar

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

          Using A = 14p my formula changes to:

          for (x, A) in pells.diop_quad(49, 6, 8643600):
  if not (A > 0): continue
  ......

          It generates the same 4 cases.

          Like

    • Alex.T.Sutherland's avatar

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

      This puzzle reminds me of Heronian triangles (triangles with integer sides
      and integer area).
      Method :-
      Create a list of pairs of integer sides (a,b) each pair summing to 98.
      (49 pairs each pair-sum is even.This is a requirement.The periphery must be even).
      Append the 70″ side (c) to each pair. (a b c).
      Calculate the half periphery for each triangle (s) (if possible).
      Calculate the area of each triangle (again if possible) using Heron’s formula.
      Area = sqrt(s*(s-a)*(s-b)*(s-c)).
      Extract those that are integer.
      With the previous data I have obtained 4 such triangles with two fitting
      the 504 requirement Hence the answer for the shortest piece of cane.
      Curiosity:- The sum of the digits in each of the areas was the same.
      Time : – < 1ms

      Like

  • Unknown's avatar

    Jim Randell 4:36 pm on 28 August 2026 Permalink | Reply
    Tags:   

    Teaser 2385: [Lucky numbers] 

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

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

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

    What is that unique lucky number?

    This puzzle was originally published with no title.

    [teaser2385]

     
    • Jim Randell's avatar

      Jim Randell 4:37 pm on 28 August 2026 Permalink | Reply

      The following Python program finds candidate 3-digit lucky numbers, and groups them by age. It then looks for ages with a unique lucky number, and examines the neighbourhood of these to find viable solutions.

      It runs in 75ms. (Internal runtime is 731µs).

      from enigma import (irange, dsum, group, item, printf)

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

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

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

# look for unique lucky numbers
for k in sorted(g.keys()):
  # and check the neighbours
  check(k, k + 1, k + 2)
  check(k, k - 1, k + 1)
  check(k, k - 2, k - 1)

      There are three possible sets of ages:

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

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

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

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

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

      Solution: The unique lucky number is 874.

      Like

    • Ruud's avatar

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

      import istr


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


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

      Like

      • Jim Randell's avatar

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

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

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

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

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

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

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

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

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

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

        Like

    • Ruud's avatar

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

      With Jim’s performance improvement suggestions:

      import istr
import functools


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


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

      Thanks, Jim

      Like

    • Frits's avatar

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

      from enigma import SubstitutedExpression

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

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

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

      Like

    • Frits's avatar

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

      from math import ceil

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

d = dict()

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

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

      Like

  • Unknown's avatar

    Jim Randell 6:51 am on 23 August 2026 Permalink | Reply
    Tags:   

    Teaser 3335: Trish tries triathalon 

    From The Sunday Times, 23rd August 2026 [link] [link]

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

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

    How long?

    [teaser3335]

     
    • Jim Randell's avatar

      Jim Randell 7:39 am on 23 August 2026 Permalink | Reply

      This Python program considers possible triangles for the leg through the field, and then finds a corresponding triangle for the leg through the lake, and checks that the choice of entry point to the lake gives a (locally) minimal total time.

      I am assuming X, Y, x1, x2, y1, y2, h1, h2 are all (non-negative) integer distances (we know at least some of them are, and we do find a single solution with this assumption).

      It runs in 78ms. (Internal runtime is 4.7ms).

      from enigma import (pythagorean_triples, hypot, printf)

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

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

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

  # output solution
  printf("h={h} [x1={x1} x2={x2} (X={X}); y1={y1} y2={y2} (Y={Y})]", X=x1 + x2, Y=y1 + y2)

      Solution: The first two legs were 1450 metres each.

      The actual distances being:

      x1 = 1440, y1 = 170, h1 = 1450
      x2 = 240, y2 = 1430, h2 = 1450
      X = x1 + x2 = 1680, Y = y1 + y2 = 1600

      Like

      • Jim Randell's avatar

        Jim Randell 10:07 am on 23 August 2026 Permalink | Reply

        Paths with minimal time obey Snell’s Law / Fermat’s Principle of Least Time [@wikipedia], so:

        sin(𝛉1) / sin(𝛉2) = 6
        ⇒
        x1 / h1 = 6 . x2 / h2

        And in this case the leg distances (h1 and h2) are the same, so:

        x1 = 6 . x2

        The following Python program has an internal runtime of 5ms.

        from enigma import (pythagorean_triples, union, printf)

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

# consider possible triangles for the lake
for (x2, y2, h) in tris:
  # find a corresponding triangle for the field
  (x1, y1) = (6 * x2, 1600 - y2)
  # is it a valid triangle?
  if (x1, y1, h) in tris:
    # output solution
    printf("h={h} [x1={x1} x2={x2} (X={X}); y1={y1} y2={y2} (Y={Y})]", X=x1 + x2, Y=y1 + y2)

        Manually:

        Using the equations:

        y1 + y2 = 1600
        x1 = 6 x2
        (x1)² + (y1)² = (x2)² + (y2)²

        we derive:

        y2 = (7/640)(x2)² + 800

        For y2 to be an integer (required), x2 must be an integer multiple of 80 (and all the values assumed to be integers must be integers):

        x2 = 80 ⇒ y2 = 870; h is not an integer
        x2 = 160 ⇒ y2 = 1080; h is not an integer
        x2 = 240 ⇒ y2 = 1430; h = 1450
        x2 = 320 ⇒ y2 = 1920; y2 is too big, so we can stop

        Just one of these gives a viable solution to the puzzle.

        Or programatically (with an internal runtime of 130µs):

        # consider possible x2 values
for x2 in irange(80, inf, step=80):
  # calculate x1, y2, y1, h
  x1 = 6 * x2
  y2 = ediv(7 * sq(x2), 640) + 800
  y1 = 1600 - y2
  if y1 < 0: break
  h = ihypot(x1, y1)
  if h is None: continue
  assert (h == ihypot(x2, y2))
  # output solution
  printf("h={h} [x1={x1} x2={x2} (X={X}); y1={y1} y2={y2} (Y={Y})]", X=x1 + x2, Y=y1 + y2)

        Like

    • Frits's avatar

      Frits 10:40 pm on 23 August 2026 Permalink | Reply

      Like manual solver John Crabtree I have also ended up with just 3 cases to check (in my case the squares lower than 11). Maybe later I can get it down to only 1 case.

      Liked by 1 person

    • Alex.T.Sutherland's avatar

      Alex.T.Sutherland 12:59 pm on 26 August 2026 Permalink | Reply

      Using J.Randell’s diagram previously given.
      Start = [0 1600].
      [x y] are the co-ords of the lake entry point (These are integers )
      From the the two triangles the following expression can be derived :-
      35*(x^2) + 3200*y – 1600^2 = 0.
      Solving this gives 3 possible sets for [x y].
      Only one set allows an equal integer value for the hypotenuses
      Answer :- The sum of the 1st two digits = 3rd digit.
      Time :- < 2ms

      Like

  • Unknown's avatar

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

    Brain-Teaser 806: Mad tea-party 

    From The Sunday Times, 2nd January 1977

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

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

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

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

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

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

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

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

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

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

    [teaser806]

     
    • Jim Randell's avatar

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

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

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

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

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

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

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

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

      Solution: The smallest possible table has at 39 places.

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

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

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

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

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

      Like

    • Frits's avatar

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

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

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

      Like

  • Unknown's avatar

    Jim Randell 7:09 am on 16 August 2026 Permalink | Reply
    Tags:   

    Teaser 3334: All square 

    From The Sunday Times, 16th August 2026 [link] [link]

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

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

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

    [teaser3334]

     
    • Jim Randell's avatar

      Jim Randell 7:13 am on 16 August 2026 Permalink | Reply

      Here is a straighforward constructive solution, that just counts the number of squares in each candidate grid.

      The following Python program runs in 71ms. (Internal runtime is 1ms).

      from enigma import (irange, printf)

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

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

# target number of squares
T = 10000

# consider number of cols
for nc in irange(1, 49):
  # and number of rows
  for nr in irange(1, nc - 1):
    t = nsquares(nr, nc)
    if t < T: continue
    if t > T: break
    # output solution
    printf("rows = {nr}, cols = {nc} -> nsquares = {t}")

      Solution: The new grid has 24 rows and 41 columns.

      Like

      • Jim Randell's avatar

        Jim Randell 7:38 am on 16 August 2026 Permalink | Reply

        See also: Teaser 1995, Enigma 1086.

        Analytically, we can show that for a grid with a rows and b columns (where a ≤ b), then the number of squares in the grid is:

        S(a, b) = a (a + 1) (3b − a + 1) / 6

        (See: OEIS A082652).

        So we can look for solutions to the equation:

        S(a, b) = 10000
        or:
        a (a + 1) (3b − a + 1) = 60000

        The following Python program implements a generic solver to find candidate grid dimensions given the total number of squares required. And then solves this particular puzzle by looking for grids that give exactly 10000 squares, and selecting those that meet the remaining requirements of the puzzle.

        It has an internal runtime of just 76µs.

        from enigma import (divisor, tuples, printf)

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

# solve the puzzle
for (a, b) in solve(10000):
  if a < b < 50:
    printf("rows = {a}, cols = {b}")

        Like

        • Frits's avatar

          Frits 11:00 pm on 16 August 2026 Permalink | Reply

          @Jim, it doesn’t seem to happen but a check for b > a wouldn’t hurt.

          Like

    • Ruud's avatar

      Ruud 7:46 am on 16 August 2026 Permalink | Reply

      Brute force:

      for ncols in range(1, 50):
    for nrows in range(1, ncols):
        if sum((nrows - size + 1) * (ncols - size + 1) for size in range(1, nrows + 1)) == 10000:
            print(f'{nrows=} {ncols=}')

      Like

    • Hugo's avatar

      Hugo 11:19 am on 23 August 2026 Permalink | Reply

      When b = a = n, the expression becomes n(n + 1)(2n + 1)/6
      which is the sum of the squares of the integers from 1 to n.

      Like

  • Unknown's avatar

    Jim Randell 3:14 pm on 14 August 2026 Permalink | Reply
    Tags:   

    Teaser 2388: [Policy number] 

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

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

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

    What is the policy number?

    This puzzle was originally published with no title.

    [teaser2388]

     
    • Jim Randell's avatar

      Jim Randell 3:14 pm on 14 August 2026 Permalink | Reply

      This Python program looks for numbers of the form n = x^N that have N digits, and the final digit is N.

      It runs in 62ms. (Internal runtime is 79µs).

      from enigma import (irange, inf, powers, ifirst, lt, printf)

# consider (single digit) values for N
for N in irange(2, 9):
  # look for values x^N that are N digits with final digit N
  (nmin, nmax) = (10**(N - 1), 10**N)
  for n in ifirst(powers(1, inf, N), skip=lt(nmin), count=lt(nmax)):
    if n % 10 == N:
      printf("N={N}: n={n}")

      There are 2 candidate solutions:

      N=3: n = 7^3 = 343
      N=9: n = 9^9 = 387420489

      As we are told they “regularly turn over thousands of policies”, I assume we are to take the second of these as the solution.

      Solution: The policy number is: 387420489.

      Like

    • Ruud's avatar

      Ruud 4:05 pm on 14 August 2026 Permalink | Reply 

      import istr

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

      Result:

      Like

  • Unknown's avatar

    Jim Randell 8:14 am on 11 August 2026 Permalink | Reply
    Tags:   

    Teaser 2390: [Near miss] 

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

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

    SUNDAY + TIMES = TEASER

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

    SUND* + TIMES = TEASER

    The * indicates where I have missed out a consonant.

    What was that consonant?

    This puzzle was originally published with no title.

    [teaser2390]

     
    • Jim Randell's avatar

      Jim Randell 8:15 am on 11 August 2026 Permalink | Reply

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

      We solve the alphametic expression:

      SUNDX + TIMES = TEASER

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

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

      It runs in 68ms. (Internal runtime is 5.4ms).

      from enigma import (SubstitutedExpression, peek, printf)

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

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

for s in p.solve(verbose=0):
  X = s['X']
  k = peek(k for k in "DMNRST" if s[k] == X)
  printf("{s}; X={k}", s=p.substitute(s, expr))

      Solution: The consonant replaced by the * is S.

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

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

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

      Like

    • Ruud's avatar

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

      import istr

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

      Like

    • Frits's avatar

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

      Optimizing code lead to a manual solution.

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

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

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

      Like

  • Unknown's avatar

    Jim Randell 6:47 am on 9 August 2026 Permalink | Reply
    Tags:   

    Teaser 3333: Hey, diddle, diddle … 

    From The Sunday Times, 9th August 2026 [link] [link]

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

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

    Find the nett values.

    [teaser3333]

     
    • Jim Randell's avatar

      Jim Randell 7:03 am on 9 August 2026 Permalink | Reply

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

      from enigma import (irange, subsets, nconcat, divf, fraction, group, item, printf)

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

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

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

# look for a fraction that gives exactly 2 values
for ((a, b), vs) in g.items():
  if len(vs) == 2:
    printf("fee = {a}/{b} -> vs = {vs}")

      Solution: The net values received were: $ 1196 and $ 1311.

      The fees deducted amounted to 1/24 of the maturity value (so the net value was 23/24 of the maturity value).

      And the values of the 2 bonds were:

      gross = $ 1248 → net = $ 1196
      gross = $ 1368 → net = $ 1311

      There are only 3 candidate maturity values: 1236, 1248, 1368.

      And possible fractional fees are 1/12 (≈ 8.33%) and 1/24 (≈ 4.17%) which give the following values:

      fee = 1/12: (1236 → 1133), (1248 → 1144), (1368 → 1254)
      fee = 1/24: (1248 → 1196), (1368 → 1311)

      Only the second of these allows the 2 values to be deduced with certainty.

      Like

    • Ruud's avatar

      Ruud 8:08 am on 9 August 2026 Permalink | Reply 

      import peek
import istr
import collections

collect = collections.defaultdict(list)

for gross in istr.range(length=4):
    if gross.is_increasing() and all(gross.divided_by(c) for c in gross):
        for fraction in range(11, int(gross)):
            if gross.is_divisible_by(fraction):
                collect[fraction].append(gross)
for fraction, grosses in collect.items():
    if len(grosses) == 2:
        peek(fraction)
        for gross in grosses:
            nett = gross - gross // fraction
            peek(nett, gross)

      Like

      • Ruud's avatar

        Ruud 8:12 am on 9 August 2026 Permalink | Reply

        `divided_by` could also read `is_divisible_by` which is arguably a bit more clear.

        Like

      • Frits's avatar

        Frits 9:01 am on 12 August 2026 Permalink | Reply

        @Ruud, you only seem to consider unit fractions.

        Like

    • Frits's avatar

      Frits 12:45 pm on 9 August 2026 Permalink | Reply

      I didn’t want to publish a similar solution.

      from math import gcd
from itertools import combinations
from functools import reduce

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

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

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

      Like

  • Unknown's avatar

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

    Teaser 2389: [Piles of cards] 

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

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

    How many cards were there in each pile?

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

    This puzzle was originally published with no title.

    [teaser2389]

     
    • Jim Randell's avatar

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

      Here is a straightforward programmed solution.

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

      from enigma import (irange, div, printf)

N = 26  # number of red/black cards

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

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

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

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

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

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

      The piles are:

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

      There is a second candidate solution:

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

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

      Like

      • Jim Randell's avatar

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

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

        #! python3 -m enigma -rr

SubstitutedExpression

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

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

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

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

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

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

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

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

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

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

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

        Like

    • Ruud's avatar

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

      Very brute force, but still running in milliseconds …

      import peek

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

      Like

    • Frits's avatar

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

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

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

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

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

      Like

  • Unknown's avatar

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

    Teaser 2396: [Consecutive numbers] 

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

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

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

    What is the odd number of the pair?

    This puzzle was originally published with no title.

    [teaser2396]

     
    • Jim Randell's avatar

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

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

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

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

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

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

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

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

      But with a bit of analysis we can do better:

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

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

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

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

      So we either have:

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

      or:

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

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

      It has an internal runtime of just 548µs.

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

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

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

      Solution: The odd number in the pair is 970225.

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

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

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

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

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

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

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

      X² − 2Y² = ±2

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

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

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

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

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

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

      Like

    • Ruud's avatar

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

      from functools import cache


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


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


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

      Like

      • Jim Randell's avatar

        Jim Randell 10:13 am on 6 August 2026 Permalink | Reply

        @Ruud: How do you know the smaller number is the even one?

        Perhaps the tests should be:

        number_of_digits_with_parity(i1, i1 % 2) % 2 == i1 % 2 and
number_of_digits_with_parity(i2, i2 % 2) % 2 == i2 % 2

        (In fact, from the recurrence relations for solutions to the corresponding Pell’s equations we can show that solution pairs are always (<even>, <odd>), so a brute force approach won’t miss solutions if it just consider these pairs).

        Like

  • Unknown's avatar

    Jim Randell 6:41 am on 2 August 2026 Permalink | Reply
    Tags:   

    Teaser 3332: As easy as one, two, three 

    From The Sunday Times, 2nd August 2026 [link] [link]

    “telladom shoodlat quoz veedku quoz” means 87.

    “rimjy veedku rimjy ump telladom” means 50.

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

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

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

    [teaser3332]

     
    • Jim Randell's avatar

      Jim Randell 8:03 am on 2 August 2026 Permalink | Reply

      Here is a Python solution that finds the required answer.

      It does, however, make the assumption that the minor values are no more than 10, and that the major values are no more than 20. (Which are not unreasonable, given the numbers specified).

      It first determines which symbols can be minor and major, using the sequences given, and then assigns values to each symbol such that the required values are made.

      The following Python program runs in 190ms. (Internal runtime is 108ms).

      from enigma import (
  irange, subsets, tuples, diff, seq_all_different, is_increasing, rev, map2str, printf
)

# symbols used
syms = "QRSTUV"

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

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

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

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

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

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

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

  # choose an ordering for the major values (largest to smallest)
  for mvs in subsets(majs, size=len, select='P'):
    # check that majors appear in order in each sum
    if not all(is_increasing((mvs.index(x) for x in diff(num, mins)), strict=1) for num in nums.keys()): continue
    # find values for minor/major symbols
    for (vm, vM) in solve(sorted(mins), rev(mvs), nums):
      # output solution
      printf("minor = {vm}; major = {vM}", vm=map2str(vm), vM=map2str(vM))

      Solution: The values are: quoz = 5, rimjy = 3, shoodlat = 16, telladom = 2, ump = 6, veedku = 10.

      The minors are: quoz, rimjy, telladom (values: 5, 3, 2).

      The majors are: shoodlat, ump, veedku (values: 16, 6, 10).

      The numbers are then:

      “telladom shoodlat quoz veedku quoz” = (2 × 16) + (5 × 10) + 5 = 87.
      “rimjy veedku rimjy ump telladom” = (3 × 10) + (3 × 6) + 2 = 50.

      With some analysis we can show that the above is the only solution.

      For the sequences TSQVQ and RVRUT, using the fact that majors cannot be repeated in a sequence we see Q and R must be minors, and we cannot have 2 consecutive minors, so S, U, V must be majors. Which only leaves T.

      If T is a major, then, as majors are strictly decreasing in each sequence we have:

      T > S > V > U > T

      which is not possible, and so T must be a minor.

      (In my program above, these assignments are determined by considering the symbol sequences given).

      The numbers are therefore:

      (T×S) + (Q×V) + Q = 87
      (R×V) + (R×U) + T = 50

      From these we can determine that T ∈ [2..8], and so we can perform an exhaustive search to find the required answer.

      The following Python program has an internal runtime of 210µs.

      from enigma import (irange, divisors_pairs, decompose, div, printf)

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

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

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

        # output solution
        printf("minor = (T={T}, R={R}, Q={Q}); major = (S={S}, V={V}, U={U})")

      Like

      • Frits's avatar

        Frits 10:47 am on 3 August 2026 Permalink | Reply

        @Jim,

        “(although 1 is never used as a minor here)”. I read this to only count when dealing with a product. This leaves value 1 still possible for a trailing minor (although in this teaser after a little analysis this is also impossible)

        Like

        • Jim Randell's avatar

          Jim Randell 11:21 am on 3 August 2026 Permalink | Reply

          @Frits: Could be. I just read it as meaning that 1 does not occur as a minor in this puzzle. (Although you would presumably have to have a minor that corresponds to 1 if you want to be able to start counting at 1). But as you say, in this puzzle there is no minor that does not appear as part of a product, so we know none of the minors under consideration can be 1.

          Like

    • Alex.T.Sutherland's avatar

      Alex.T.Sutherland 6:52 pm on 7 August 2026 Permalink | Reply

      Method:-
      1. Define minor = 0 and major =1. Pattern = binary order of the minor/major
      2. Generate a 32×5 binary matrix for numbers 0 to 31.
      3. Remove the rows containing adjacent zeros to give a matrix B (13×5).
      4. Considering the number 50.
      It must have the pattern 0 1 0 1 x.
      (The 1st and 3rd values are equal therefore cannot be a major hence are minors.
      The 2nd and 4th must be a major ,can’t be adjacent to a minor.
      The ‘x’ could be either but is less than the forth value.)
      5. Using this pattern find the list of 5 numbers (using the appropriate rules)
      that give 50. (I have a list of 20).Only needs to be calculated once.(List_50)

      6. Considering The number 87.
      The matrix B can be reduced by keeping only those where with the third and
      fifth digits are equal.
      B is reduced to 8×5 patterns from the 13×5.
      7. Iterate each of the 8 pattern lists with the List_50 using the numbers common to both
      as the matching criteria . ie N87(1) = N50(5) & N87(4)= N50(2).
      A unique solution is found on the first iteration.

      8. The answer gives the sum of the digits in both 50 & 87 as 62.
      The maximum minor value is a single digit.
      Time:- ~ 26ms

      Like

  • Unknown's avatar

    Jim Randell 3:03 pm on 31 July 2026 Permalink | Reply
    Tags:   

    Teaser 2409: [Five fours] 

    From The Sunday Times, 23rd November 2008 [link]

    In this addition sum, digits have been replaced consistently by letters, with different letters for different digits:

    What is the number NOW?

    This puzzle was originally published with no title.

    [teaser2409]

     
    • Jim Randell's avatar

      Jim Randell 3:04 pm on 31 July 2026 Permalink | Reply

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

      It runs in 78ms. (Internal runtime of the generated code is 1.4ms).

      #! python3 -m enigma -rr

SubstitutedExpression

"FOUR * 32 = TWENTY"

--answer="NOW"

      Or you can just call the solver directly from the command line:

      % python3 -m enigma SubstitutedExpression "FOUR * 32 = TWENTY" --answer="NOW"
(FOUR * 32 = TWENTY) (NOW)
(6379 * 32 = 204128) (130) / E=4 F=6 N=1 O=3 R=9 T=2 U=7 W=0 Y=8
NOW = 130 [1 solution]

      Or we can keep the sum as an addition sum (as it is originally presented), and use the [[ SubstitutedExpression.split_sum ]] solver on it.

      The following (slightly longer) run-file executes in 76ms. (Internal runtime of the generated code is 260µs).

      #! python3 -m enigma -rr

SubstitutedExpression.split_sum

"FOUR + FOUR + FOUR0 + FOUR0 + FOUR0 = TWENTY"

--distinct="EFNORTUWY"
--literal="0"
--answer="NOW"

      Solution: NOW = 130.

      Like

    • Ruud's avatar

      Ruud 5:06 pm on 31 July 2026 Permalink | Reply 

      import peek
import istr

for four in istr.range(length=4):
    twenty = 32 * four
    if len(twenty) == 6 and twenty[0] == twenty[4] and (twenty[1:] | four).all_distinct():
        now = twenty[3] | four[1] | twenty[1]
        peek(now, four, twenty)

      Like

  • Unknown's avatar

    Jim Randell 10:20 am on 28 July 2026 Permalink | Reply
    Tags:   

    Teaser 2412: [Triangular lawn] 

    From The Sunday Times, 14th December 2008 [link]

    I have a triangular lawn with sides a whole number of metres in length. Its perimeter is 54 metres. A circular water feature is equidistant from each of the three sides. I have measured the distance from the centre of the water feature to each of the corners of the lawn: in two cases, the distance is a whole number of metres.

    What is the length of the shortest side of the lawn?

    This puzzle was originally published with no title.

    [teaser2412]

     
    • Jim Randell's avatar

      Jim Randell 10:20 am on 28 July 2026 Permalink | Reply

      Starting with a triangle with sides a, b, c. Then the circular pond is concentric with the incircle of the triangle, so we are interested in the distances from the incentre (= I) to the vertices of the triangle (= u, v, w).

      The semi-perimeter (= s) of the triangle is given by:

      s = (a + b + c) / 2

      And the lengths of the sides of the triangle can be written:

      a = y + z
      b = x + z
      c = x + y
      ⇒
      s = x + y + z
      x = s − a
      y = s − b
      z = s − c

      And so the distances we are interested in are given by:

      u = hypot(r, s − a)
      v = hypot(r, s − b)
      w = hypot(r, s − c)

      We can calculate area (= A) of the triangle using Heron’s formula:

      A = √(s (s − a) (s − b) (s − c))

      And the inradius (= r) can then be calculated:

      r = A / s

      The following Python program considers possible sides of the triangle (a, b, c), and looks for scenarios where 2 of the distances from the incentre to the vertices are whole numbers.

      It runs in 76ms. (Internal runtime is 665µs).

      from enigma import (Rational, decompose, sq, is_square, sqrt, seq2str, printf)

Q = Rational()

# semi-perimeter
s = 27
# consider possible sides of the triangle (a, b, c); a + b + c = 2s
for (a, b, c) in decompose(2 * s, 3, increasing=1, sep=0):
  # if the area of the triangle is A, use Heron's formula to calculate A^2
  A2 = s * (s - a) * (s - b) * (s - c)
  # check for valid triangles
  if not (A2 > 0): continue
  # inradius = r, r = A/s, calculate r^2
  r2 = Q(A2, sq(s))

  # calculate the squares of the distances from the incentre to the vertices
  d2s = tuple(r2 + sq(s - v) for v in (a, b, c))

  # and look for situations where exactly 2 of these are perfect squares
  k = sum(1 for d2 in d2s if is_square(d2))
  if k != 2: continue

  # output solution
  ds = tuple(sqrt(d2) for d2 in d2s)
  printf("a={a} b={b} c={c} -> A2={A2} r2={r2} -> d2s={d2s} ds={ds}", d2s=seq2str(d2s), ds=seq2str(ds))

      Solution: The shortest side of the lawn is 6 m.

      And the other two sides are 24 m each. (So the triangle is isosceles).

      Giving distances from the incentre to the vertices of 4 m, 4 m, 21.166 m (= 8√7).

      Like

      • Jim Randell's avatar

        Jim Randell 11:48 am on 2 August 2026 Permalink | Reply

        If at least one of the (r² + (s − v)²) is a square number (to give a whole number root), then it follows that r² must be an integer, and so each of u², v², w² is also a whole numbers.

        And we can simplify the calculations of u², v², w² to be just in terms of a, b, c:

        u² = (s − a)bc / s
        v² = (s − b)ca / s
        w² = (s − c)ab / s

        The program can then be simplified slightly to:

        from enigma import (decompose, div, tuples, is_square, sqrt, seq2str, printf)

# semi-perimeter
s = 27
# consider possible sides of the triangle (a, b, c); a + b + c = 2s
for (a, b, c) in decompose(2 * s, 3, increasing=1, sep=0):
  # check for valid triangles
  if not (a + b > c): continue

  # calculate the squares of the distances from the incentre to the vertices
  d2s = tuple(div((s - i) * j * k, s) for (i, j, k) in tuples((a, b, c), 3, circular=1))
  if None in d2s: continue

  # look for situations where exactly 2 of these are perfect squares
  k = sum(1 for d2 in d2s if is_square(d2))
  if k != 2: continue

  # output solution
  ds = tuple(sqrt(d2) for d2 in d2s)
  printf("a={a} b={b} c={c} -> d2s={d2s} ds={ds}", d2s=seq2str(d2s), ds=seq2str(ds))

        Like

    • Frits's avatar

      Frits 1:54 pm on 28 July 2026 Permalink | Reply

      Doing most of the checks in decompose().

      from math import prod

# decompose number <t> into <k> non-decreasing numbers and semi-perimeter logic
def decompose(t, k, m=0, sp=0, s=[]):
  if k == 1:
    if not s or t >= s[-1]:
      s.append(t)
      # r^2 = (sp - a) * (sp - b) * (sp - c) / sp must be a positive integer
      p = prod(sp - x for x in s)
      if p > 0 and p % sp == 0:
        yield s, p // sp
  else:
    for n in range(m, (t // k) + 1):
      yield from decompose(t - n, k - 1, n, sp, s + [n])

# semi-perimeter
s = 27
# consider possible sides of the triangle (a, b, c); a + b + c = 2s
for (a, b, c), r2 in decompose(2 * s, 3, 1, s):
  # calculate the squares of the distances from the incentre to the vertices
  d2s = [r2 + (s - v)**2 for v in (a, b, c)]

  # and look for situations where exactly 2 of these are perfect squares
  if sum(round(rt := d2**.5) == rt for d2 in d2s) != 2: continue

  print("answer:", min(a, b, c))

      Like

  • Unknown's avatar

    Jim Randell 6:22 am on 26 July 2026 Permalink | Reply
    Tags:   

    Teaser 3331: Salarium solace 

    From The Sunday Times, 26th July 2026 [link] [link]

    During his last campaign in Germany, Centurion Ulpius lost more than one-third of his original 80 legionaries. The remaining number of men was prime. On their return to Rome, the Legate ordered his Prefect to share out the leftover salt stock to Ulpius’s remaining men, as a reward for their bravery.

    The Prefect must ensure each man receives an identical amount. Using his scales he could accurately halve any quantity of salt. He divided the initial amount into two equal piles repeatedly until the number of piles exceeded the number of men. The men then received a pile each. The remaining piles were again each halved and distributed in the same way until only one pile remained.

    The Prefect returned home with this pile, one in 16,384 of the original stock.

    How many of Ulpius’s men returned to Rome?

    [teaser3331]

     
    • Jim Randell's avatar

      Jim Randell 6:25 am on 26 July 2026 Permalink | Reply

      Here is a constructive solution that follows the procedure for primes up to 53.

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

      from enigma import (primes, printf)

# target fraction (1/F)
F = 16384

# perform the procedure
def solve(n, F=F):
  # initial number of piles (= k), and fraction for each pile (= 1/f)
  k = f = 1
  while f < F:
    # increase the number of piles until it exceeds the number of men
    while not (k > n):
      k *= 2
      f *= 2
    # n piles are distributed to the men
    k -= n
    # are we done?
    if k == 1: return f

# consider possible remaining number of men (= n)
for n in primes.between(2, 53):
  f = solve(n)
  if f == F:
    printf("n={n} -> f={f}")

      Solution: 43 of Ulpius’ men returned to Rome.

      Each man received: 1/64 + 1/256 + 1/512 + 1/1024 + 1/2048 + 1/4096 + 1/16384 = 381/16384 of the original amount of salt.

      So the total amount of salt distributed to the men was: 43 × 381/16384 = 16383/16384. Leaving 1/16384 remaining.

      Manually:

      The salt is divided into 16384 equal portions, of which 1 is retained.

      So the remaining 16383 portions are divided equally between the (prime number) of men.

      It is straightforward to determine the prime factorisation of 16383 (= 2^14 − 1):

      2^14 − 1 = (2^7 − 1) × (2^7 + 1) = 127 × 129

      We can do trial division of primes up to 11 on each factor (or note that 127 is a Mersenne prime, and 129 is clearly divisible by 3), so the prime factorisation of 16383 is:

      16383 = 127 × 43 × 3

      Of these prime factors only 3 and 43 are viable candidate primes for the number of men (i.e. less than (2/3) × 80 = 53 + 1/3).

      For each case we can calculate the multiplicative order of 2 modulo n (we can use the procedure described in the puzzle text to do this, and count the number of times the piles are divided):

      m_order(2, 3) = 2
      m_order(2, 43) = 14

      And only 43 gives the required answer of 14.

      Like

      • Jim Randell's avatar

        Jim Randell 8:50 am on 26 July 2026 Permalink | Reply

        For n men we are are looking to find the multiplicative order of 2 modulo n, i.e. the smallest k such that 2^k mod n = 1 [@wikipedia]. And we are interested in the case where k = 14 (as 2^14 = 16384).

        This gives rise to a shorter program:

        from enigma import (primes, irange, printf)

# target fraction (1/2^M)
M = 14  # 2^14 = 16384

# find k st. 2^k mod n = 1
def solve(n, m=M):
  for k in irange(1, m):
    if pow(2, k, n) == 1:
      return k

# consider possible number of men (= n)
for n in primes.between(2, 53):
  k = solve(n)
  if k == M:
    printf("n={n} -> k={k}")

        or even shorter:

        from enigma import (primes, irange, printf)

# target fraction (1/2^M)
M = 14
F = 2**M

# consider possible number of men (= n)
for n in primes.between(2, 53):
  if F % n == 1 and all(pow(2, k, n) != 1 for k in irange(1, M - 1)):
    printf("n={n} -> k={M}")

        See also: Teaser 2406.

        Like

    • Frits's avatar

      Frits 1:16 pm on 26 July 2026 Permalink | Reply

      My first attempt was pretty similar to Jim’s first program.
      I rewrote it a little bit in order not to calculate powers for every prime number.

      from math import log

N = 16384

# remaining number of men (< 2/3) was prime
P = {3, 5, 7}
P |= {2} | {x for x in range(11, (2 * 80 - 1) // 3 + 1, 2) 
            if all(x % p for p in P)}

# powers of 2 (only highest power > remaining number of men)
pow2 = [(i, 2**i)for i in range(1, 7)]
target = log(N, 2) # assuming N is a power of 2

# return first power to overshoot the prime number
nxt = lambda n, p: next((i, pow) for i, pow in pow2 if n * pow > p) 

# remaining number of men
for p in P:
  n, k = 1, 0
  # perform repeated doubling of piles
  while k < target:
    k_, n_ = nxt(n, p)
    k += k_
    
    # until only one pile remained
    if (n := n * n_ - p) == 1: break
  
  # check if only one pile remained
  if k == target and n == 1:
    print(f"answer: {p}")

      Like

  • Unknown's avatar

    Jim Randell 9:07 am on 24 July 2026 Permalink | Reply
    Tags:   

    Teaser 2426: [Magic squares] 

    From The Sunday Times, 22nd March 2009 [link]

    My grandson has learnt about 3 × 3 Magic Squares (tables of nine different positive whole numbers with each row of three, column of three and diagonal of three adding to the same sum). To illustrate, he placed 100 in the centre of a 3 × 3 table and 1 somewhere else in the table.

    He asked me to choose any other number lower than 200 and said he would place it in the table and complete it to make a Magic Square.

    This would have been possible for most numbers, but I unkindly chose my age, knowing the task would then be impossible.

    How old am I?

    This puzzle was originally published with no title.

    This completes the archive of Teaser puzzles from 2009. There is now a complete archive of Teaser puzzles from January 2009 to the most recent puzzle published in July 2026 (this represents 916 puzzles), as well as 454 earlier Teaser puzzles.

    [teaser2426]

     
    • Jim Randell's avatar

      Jim Randell 9:08 am on 24 July 2026 Permalink | Reply

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

      It runs in 108ms. (Internal runtime is 34ms).

      from enigma import (SubstitutedExpression, irange, union, diff, seq2str, printf)

#  A B C
#  D E F
#  G H I

# possible numbers in the grid
N = 199
digits = irange(1, N)

# we have E = 100
# 1 is either placed in a corner (A) or edge (B)

# magic constant is 3E = 300
eqs = [
  "A + B + C == 300", # row 1
  "D + E + F == 300", # row 2
  "G + H + I == 300", # row 3
  "A + D + G == 300", # col 1
  "B + E + H == 300", # col 2
  "C + F + I == 300", # col 3
  "A + E + I == 300", # diag 1
  "C + E + G == 300", # diag 2
]

# consider placing 1 at A or B
for q in "AB":

  # make a puzzle for this magic square
  p = SubstitutedExpression(
    eqs,
    base=N + 1, digits=digits,
    s2d={ 'E': 100, q: 1 },
    verbose='',
  )

  # collect all numbers that can appear in the square
  ns = union(s.values() for s in p.solve())

  # most numbers should be possible
  if not (2 * len(ns) > N - 2): continue

  # output impossible numbers
  xs = diff(digits, ns)
  printf("{q}=1 -> impossible = {xs}", xs=seq2str(xs))
  printf()

      The 1 must be placed in an edge cell (i.e. not a corner cell), and then the following numbers cannot appear in a square:

      34, 67, 133, 166

      (Note that these form two pairs (34, 166) and (67, 133), each with a sum of 200).

      The most likely of these to be the age of someone who has a grandson interested in magic squares (so, maybe aged around 10), is 67.

      Solution: The setter is 67.

      Like

    • Frits's avatar

      Frits 5:11 pm on 25 July 2026 Permalink | Reply 

      #  A B C
#  D E F
#  G H I
 
# assume A = 1 or B = 1
# A = 1 is invalid as it causes both C < 100 and G < 100 and C+E+G < 300
# B = 1 leads to 

#   A       1    299 - A
# 399-2A   100   2A - 199
# A - 99   199   200 - A 

used = set()
for a in range(101, 199):
  ns = {a, 1, 299 - a, 399 - 2 * a, 100, 2 * a - 199, a - 99, 199, 200 - a}
  # nine different positive whole numbers 
  if len(ns) == 9:
    used |= ns

print(f"answer: {''.join(str(n) for n in range(45, 100) if n not in used)}")

      Like

  • Unknown's avatar

    Jim Randell 7:02 am on 22 July 2026 Permalink | Reply
    Tags: , ,   

    Teaser 2422: [Water tank] 

    From The Sunday Times, 22nd February 2009 [link]

    Farmer Barfoot is building a concrete tank to conserve rain water. The tank has a horizontal rectangular base, vertical walls and an open top, the internal dimensions being whole numbers or feet. The contract price is £1 per sq ft of inside wall area, £2 per sq ft of inside floor area.

    For the volume required he choose dimensions that give the lowest possible overall cost. This cost will be a number of pounds whose digits are consecutive and in order (I do not know whether they are in increasing or decreasing order).

    What is the volume of the tank in cubic feet?

    This puzzle was originally published with no title.

    There are now 4000 puzzles posted between Enigmatic Code and S2T2.

    [teaser2422]

     
    • Jim Randell's avatar

      Jim Randell 7:03 am on 22 July 2026 Permalink | Reply

      I think the wording of this puzzle is poorly chosen.

      But if we ignore the condition that the dimensions of the tank must be an integer number of feet until we get to the end, then we can solve it in the way I think the setter intended.

      We start by considering tanks that have a minimal cost for a given volume:

      For a tank with base x by y and a height z the cost for the tank is given by:

      S = 2(x + y)z + 2xy
      ⇒
      S = 2(xy + xz + yz)

      (This assumes the price is continuous, so fractional square feet of wall/floor are charged proportionally).

      Applying the AM-GM inequality [ @wikipedia ] we get:

      (xy + xz + yz)/3 ≥ (xy . xz . yz)^(1/3)
      ⇒
      xy + xz + yz ≥ 3 (xyz)^(2/3)

      with equality when x = y = z.

      The total cost of the tank is therefore:

      S = 2(xy + xz + yz) ≥ 6 (xyz)^(2/3)

      with equality when x = y = z.

      If the volume of the tank is fixed at a value V:

      V = xyz

      we see the cost of the tank is:

      S = 2(xy + xz + yz) ≥ 6 V^(2/3)

      and we achieve the minimum cost when x = y = z, i.e. when the tank is a perfect cube.

      And the cost is then:

      S = 6x²

      (This is the same as showing for cuboids of a given volume the minimum surface area possible is achieved with a cube).

      We now introduce the fact that the sides of the tank are all whole numbers.

      The problem then is to find a positive integer x (which gives a volume of x³) where 6x² is a sequence of consecutive digits (in ascending or descending order). (We ignore the trivial case where the cost is a single digit).

      The following Python program runs in 66ms. (Internal runtime is 345µs).

      from enigma import (irange, tuples, nconcat, rev, div, is_square, cb, printf)

# solve for a cost of S
def solve(S):
  x = is_square(div(S, 6))
  if x is not None:
    V = cb(x)
    dims = (x,) * 3
    printf("vol = {V}; cost = {S}; dims = {dims}")

digits = list(irange(0, 9))

# choose 2-10 digits
for k in irange(2, 10):
  for ds in tuples(digits, k):
    if ds[0] != 0: solve(nconcat(ds))
    if ds[-1] != 0: solve(nconcat(rev(ds)))

      Unfortunately there are two possible solutions:

      % python3 teaser2422b.py
vol = 27; cost = 54; dims = (3, 3, 3)
vol = 13824; cost = 3456; dims = (24, 24, 24)

      So, even solving the puzzle in the intended way gives 2 viable answers (a quite small tank, and a very large tank). Although one of these could have been eliminated by placing restrictions on the size or cost of the tank.

      The published answer is the larger one (which has a longer run of consecutive digits in the cost):

      Solution: The volume of the tank is 13824 cu ft.

      However, this is not how I originally read the puzzle.

      As the constraint that the dimensions of the tank are whole numbers is introduced first I considered that we are only dealing with tanks that have integer dimensions, and this means that the lowest possible cost for a given tank is not necessarily when the tank is a cube. (And also we don’t have to assume the cost of fractional areas is charged proportionally).

      For example, if we suppose Farmer Barfoot is looking for a tank to hold 1175 cu ft, then there are the following possible integer dimensioned tanks:

      1 × 1 × 1175; cost = 4702
      1 × 5 × 235; cost = 2830
      1 × 25 × 47; cost = 2494
      5 × 5 × 47; cost = 990

      So, for a tank holding exactly 1175 cu ft, the best price we can manage is £ 990.

      But an 9 ft × 11 ft × 12 ft tank would cost £ 678 (a sequence of consecutive digits) and hold 1188 cu ft, so be cheaper and slightly larger (and is a reasonable size).

      And it is not possible to build a tank costing less, with a capacity of at least 1175 cu ft.

      So this seems like 1188 cu ft would be a satisfactory solution to the puzzle.

      I checked volumes up to 500,000 cu ft, and found the following solutions where the cost is at least 2 digits and consists of consecutive digits in order:

      vol = 2: cost = 10 -> (1, 1, 2)
vol = 12: cost = 32 -> (2, 2, 3)
vol = 27: cost = 54 -> (3, 3, 3)
vol = 40: cost = 76 -> (2, 4, 5)
vol = 45: cost = 78 -> (3, 3, 5)
vol = 200: cost = 210 -> (5, 5, 8)
vol = 1188: cost = 678 -> (9, 11, 12)
vol = 13824: cost = 3456 -> (24, 24, 24)

      So, my initial reading of the puzzle throws up even more candidate solutions. Although a restriction on the cost or size of the tank could narrow these down to a single solution.

      Like

  • Unknown's avatar

    Jim Randell 8:07 am on 19 July 2026 Permalink | Reply
    Tags:   

    Teaser 3330: Bermuda triangles 

    From The Sunday Times, 19th July 2026 [link] [link]

    My local estate agent was advertising a house named “Bermuda” which had a garden in the shape of a right-angled triangle containing a sundial. I went to view the property and it had nine straight and narrow footpaths. There was a path along each edge of the garden, one from each corner to the sundial and one from each edge to the sundial. Each of the latter paths was perpendicular to the edge it joined. Each path was a different whole number of feet in length, the longest being 500 feet and the two shortest being 36 and 77 feet. These two paths did not join the longest and were the only ones that were not a multiple of five feet.

    What was the combined length of the nine footpaths?

    [teaser3330]

     
    • Jim Randell's avatar

      Jim Randell 8:15 am on 19 July 2026 Permalink | Reply

      The paths are laid out as follows:

      The shortest paths do not touch the hypotenuse, so these must be x and y (which are 36 and 77 in some order), and we can immediately calculate u (= hypot(x, y)).

      And (a, b, c) is the right-angled triangle, and the longest path (= c) is the hypotenuse. As all sides must be multiples of 5, we can look for triangles with a hypotenuse of 100 and multiply the side lengths by 5.

      This Python program runs in 75ms. (Internal runtime is 195µs).

      from enigma import (sum_of_squares, sq, permute, ihypot, triangle_iheight, item, printf)

# find the sides of the triangle (a, b, c)
h = 100  # = 500 / 5
for (a, b) in sum_of_squares(sq(h), min_v=1):
  (a, b, c) = (a * 5, b * 5, h * 5)

  # the two shortest paths do not join the hypotenuse
  # so position S at (x, y)
  for (x, y) in permute([(36, 77)]):
    # we can calculate the paths to the corners (u, v, w)
    vs = (u, v, w) = (ihypot(x, y), ihypot(y, a - x), ihypot(x, b - y))
    if None in vs or u % 5 > 0 or v % 5 > 0 or w % 5 > 0: continue
    # calculate the length of the remaining perpendicular path
    z = triangle_iheight(c, v, w)
    if z is None or z % 5 > 0: continue
    # calculate the total path length
    (es, ps) = ((a, b, c), (x, y, z))
    ns = es + vs + ps
    t = sum(ns)
    # check puzzle conditions hold (different lengths, shortest 2 and longest 1)
    if not (len(set(ns)) == 9 and item(0, 1, -1)(sorted(ns)) == (36, 77, 500)): continue

    # output solution
    printf("t = {t} [edge = {es}; corner = {vs}; perpendicular = {ps}]")

      Instead of using [[ triangle_iheight() ]] we can consider the big triangle to be made up from the three triangles with altitudes x, y, z. Then we have:

      ab/2 = ay/2 + bx/2 + cz/2
      ⇒
      z = (ab − ay − bx)/c

      So line 15 can be:

      z = div(a * b - a * y - b * x, c)

      Solution: The combined length of the 9 paths is 2163 ft.

      The paths around the edge of the garden have lengths 300 ft, 400 ft, 500 ft. (And so the triangle is a scaled-up (3, 4, 5) triangle).

      The paths to the corners of the triangle have lengths 85 ft, 275 ft, 325 ft.

      And the perpendicular paths have lengths 36 ft, 77 ft, 165 ft.

      (In the diagram the assignments are: a = 300, b = 400, c = 500; u = 85, v = 275, w = 325; x = 36, y = 77, z = 165).

      Like

      • Frits's avatar

        Frits 3:05 pm on 22 July 2026 Permalink | Reply

        @Jim, min_v can be probably set to 8 to that the resulting a and b are both greater than 36.

        Like

        • Jim Randell's avatar

          Jim Randell 9:28 am on 23 July 2026 Permalink | Reply

          @Frits: When I wrote the code I was just worried about eliminating the 0² + 100² = 100² solution. But you are right, as we already know that the shortest paths are 36 and 77 we can start from min_v=16.

          Like

    • Alex T Sutherland's avatar

      Alex T Sutherland 10:34 am on 21 July 2026 Permalink | Reply

      Found that there are 3 Pythagorean triangles with a hypotenuse = 500.
      One set can be discounted,the sides not divisible by 5.(obvious)
      Another set whose vertices to sundial lengths are not divisible by 5
      can be eliminated.(requires length calc)
      The remaining set satisfies the requirements.
      The third normal (36,77,?) can be found by equating the sum of the areas
      of 3 triangles to that of the garden triangle.(both equal).
      The answer I have for the total path length is a 4 digit number with the
      following characteristic:-
      T = abcd
      3*(ab) = (cd)
      Time < 1ms ( Mostly finding the distances between known points ).

      Like

    • Ellen Napier's avatar

      Ellen Napier 2:43 pm on 23 July 2026 Permalink | Reply

      Seems like the last sentence of the puzzle statement is redundant.

      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
Design a site like this with WordPress.com
Get started