S2T2 | Solving Sunday Times Teasers

Recent Updates Page 8 Toggle Comment Threads | Keyboard Shortcuts

Jim Randell 8:13 am on 9 May 2025 Permalink | Reply
Tags: by: Danny Roth ( 87 )
Teaser 2553: The X-Factor
From The Sunday Times, 28th August 2011 [link] [link]

George and Martha’s daughter entered a singing competition. The entrants were numbered from one upwards. The total number of entrants was a three-digit number and their daughter’s number was a two-digit number. The five digits used in those two numbers were all different and non-zero. Martha noted that the number of entrants was a single-digit multiple of their daughter’s number. George realised the same would be true if the two digits of their daughter’s number were reversed.

How many entrants were there?

[teaser2553]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Frits, Ruud, and Jim Randell are discussing. Toggle Comments
- Jim Randell 8:14 am on 9 May 2025 Permalink | Reply
  Here is a solution using the [[ SubstitutedExpression ]] solver from the enigma.py library.
  
  The following run file executes in 84ms. (Internal runtime of the generated code is 10.9ms).
```
#! python3 -m enigma -rr

SubstitutedExpression

# total number of entrants = ABC
# daughters number = XY

--digits="1-9"

"ediv(ABC, XY) < 10"
"ediv(ABC, YX) < 10"

--answer="ABC"
```
  Solution: There were 168 entrants.
  
  The daughter’s number is either 24 or 42.
  
  168 / 24 = 7
  168 / 42 = 4
  
  LikeLike
  - Frits 3:31 pm on 9 May 2025 Permalink | Reply
    
    I tested that “ediv” is a bit faster than “div” as for “div” an error/exception may occur when comparing “None” with an integer.
    
    LikeLike
    - Jim Randell 4:19 pm on 9 May 2025 Permalink | Reply
      
      @Frits: [[ ediv() ]] throws an error if the division is not exact, whereas [[ div() ]] returns [[ None ]].
      
      In Python 3 you will get type error if you compare [[ None ]] to a number. But in Python 2 [[ None ]] compares as less than any number (including [[ -inf ]]). So using [[ ediv() ]] also allows the run file to work in older versions of Python.
      
      LikeLike
      - Frits 3:18 pm on 10 May 2025 Permalink | Reply
        
        or skipping a loop over “J”.
        
        #! python3 -m enigma -rr SubstitutedExpression # total number of entrants = ABC # daughters number = XY --distinct="ABCXY" --digits="1-9" --invalid="1,I" # find the single digit multiples I, J "XY * I = ABC" "ABC % YX == 0 and ABC // YX < 10" --answer="ABC"
        
        LikeLike
  - Jim Randell 8:33 am on 10 May 2025 Permalink | Reply
    Or without using [[ *div() ]] function calls.
    
    This run file has an internal runtime of 188µs.
```
#! python3 -m enigma -rr

SubstitutedExpression

# total number of entrants = ABC
# daughters number = XY

--distinct="ABCXY,IJ"
--digits="1-9"

# find the single digit multiples I, J
"XY * I = ABC"
"YX * J = ABC"

--answer="ABC"
```
    (Further speed improvements left as a simple exercise for the reader).
    
    LikeLike
- Ruud 3:01 pm on 9 May 2025 Permalink | Reply
```
import peek
import istr

for daughter in istr(range(10, 100)):
    for n, m in istr.combinations(range(1, 10), r=2):
        if (
            (entrants := daughter * n) == (daughter_reversed := daughter.reversed()) * m
            and len(entrants) == 3
            and ("0" not in entrants)
            and (entrants | daughter).all_distinct()
            and (entrants | daughter_reversed).all_distinct()
        ):
            peek(entrants, daughter, daughter_reversed)
```
  LikeLike
  - Frits 4:09 pm on 9 May 2025 Permalink | Reply
    
    @Ruud,
    
    Line 11 doesn’t seem to be logically necessary.
    
    I read the readme of the peek module at your Salabim site. I wish I had known this before. I will have a look at it (I’ll send you an email concerning an installation issue).
    
    I made my own simple debugging tool, I don’t need to import anything as I use preprocessing.
    A basic version is described at:
    
    [ https://enigmaticcode.wordpress.com/notes/#comment-10234 ]
    
    LikeLike
    - ruudvanderham 1:16 pm on 10 May 2025 Permalink | Reply
      
      Yes, you are right. Line 11 could be omitted (although it is not wrong).
      Nice to be in contact (in Dutch!) with you on the subject of peek.
      
      LikeLike
Reply Cancel reply
Required fields are marked *

Name *

Email *

Website

Notify me of new comments via email.
Notify me of new posts via email.
Δ
Jim Randell 9:42 am on 6 May 2025 Permalink | Reply
Tags: by: Danny Roth ( 87 )
Teaser 2523: [Unusual Avenue]
From The Sunday Times, 30th January 2011 [link] [link]

George and Martha moved to a two-figure house number in Unusual Avenue. The avenue runs from south to north and each house is directly opposite another. No 1 is the southernmost on the west side, then the houses run consecutively up the west side, then southwards back down the east side. So, No 1 is opposite the highest-numbered house.

George and Martha’s number is a multiple of the number of the house opposite. The same is true of the five houses their daughters live in, but all their houses have three-figure numbers.

How many houses are there in the avenue?

This puzzle was originally published with no title.

[teaser2523]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Frits and Jim Randell are discussing. Toggle Comments
- Jim Randell 9:42 am on 6 May 2025 Permalink | Reply
  If there are k houses on each side of the road, then opposite houses sum to (2k + 1).
  
  There are 2k houses on the road in total, and the number of George and Martha’s house n is a 2-digit number that is a multiple of the house opposite (which has number 2k + 1 − n).
  
  Hence:
  
  n > 2k + 1 − n
  ⇒
  k < (2n − 1) / 2
  
  And the maximum possible 2-digit value for n is 99, hence:
  
  k ≤ 98
  
  This gives us an upper bound for an exhaustive search.
  
  The following Python program runs in 56ms. (Internal runtime is 332µs).
```
from enigma import (irange, group, ndigits, printf)

# consider possible k values (number of houses on one side of the road)
for k in irange(52, 98):
  t = 2 * k  # total number of houses
  # collect numbers that are a multiple of the house opposite
  ns = list(x for x in irange(k + 1, t) if x % (t + 1 - x) == 0)
  if len(ns) < 6: continue
  # group the numbers by digit count
  g = group(ns, by=ndigits)
  # ensure there is a 2-digit and 5 3-digits
  (n2s, n3s) = (g.get(2), g.get(3))
  if (not n2s) or (not n3s) or (len(n3s) < 5): continue
  # output solution
  printf("total houses = {t} [n2s={n2s} n3s={n3s}]")
```
  Solution: There are 134 houses in the road.
  
  And so the numbers of opposite houses sum to 135.
  
  George and Martha live at 90, which is opposite 45.
  
  And there are 6 houses that their 5 daughters could live at:
  
  108 (opposite 27)
  120 (opposite 15)
  126 (opposite 9)
  130 (opposite 5)
  132 (opposite 3)
  134 (opposite 1)
  
  If instead of an Avenue the road was a Close, with a house at the closed end (or several houses), then there would be further possible solutions.
  
  LikeLike
- Frits 12:39 pm on 8 May 2025 Permalink | Reply
  Using ideas of Jim and Brian.
```
# the number of houses is even, say 2.k, so we want numbers 
# n such that:
# 
#    n = m.(2.k + 1 - n)  ==>  (m + 1).n = m.(2.k + 1)
#
# this makes both n and m even (credit: B. Gladman)

d3 = 5  # five 3-digit numbers
mn = 49 + d3            # 2.k >= 100 + (d3 - 1) * 2 
mx = (3 * 99 - 2) // 4  # n >= 2 * (2k + 1) - n

# are there at least <a> house numbers with correct opposite house number?
def find(k, a, strt, m=-1):
  c, x, k2 = 0, strt, k + k
  while c <= a and x >= m:
    c += (x % (k2 + 1 - x) == 0)
    x -= 2
  return c >= a  

# consider possible k values (number of houses on one side of the road)
for k in range(mn, mx + 1):
  # opposite housenumbers t.m / (m + 1) and t / (m + 1) with t = 2.k + 1
  # t.m / (m + 1) <= 98 or m <= 98 / (t - 98)  
  m = 98 // ((k2 := k + k) - 97) 
  # check for solutions of even n less than 100
  if any((k2 + 1) % x == 0 for x in range(3, m + 2, 2)):
    # check for at least <d3 - 1> solutions for even numbers 
    # in range 100 ... 2.k - 2
    if find(k, d3 - 1, k2 - 2, 100):
      print("answer:", k2)
```
  LikeLike
Jim Randell 7:14 am on 4 May 2025 Permalink | Reply
Tags: by: Victor Bryant ( 144 )
Teaser 3267: Leaf-eaters
From The Sunday Times, 4th May 2025 [link] [link]

My encyclopaedia consists of many volumes, each containing the same number (over 40) of leaves. (Each leaf has a page number on each side. With n leaves Volume 1 would have pages 1 to 2n, Volume 2 would have pages 2n+1 to 4n, etc.) I keep the encyclopaedia on one long shelf so that on their spines I can read “Volume 1”, “Volume 2”, etc, from left to right.

A voracious bookworm started at the left-hand end of the shelf and ate through some covers and leaves, finishing by eating through the leaf with a page number double the number of leaves it had eaten through. Meanwhile, another bookworm started at the right-hand end of the shelf and ate through twice as many leaves as the first bookworm. Then in two of the volumes, the percentage of the nibbled leaves was equal to the volume number.

How many volumes are there in the set? And how many leaves per volume?

[teaser3267]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Frits and Jim Randell are discussing. Toggle Comments
- Jim Randell 8:57 am on 4 May 2025 Permalink | Reply
  See also: Enigma 660, Tantalizer 386. (In particular the note about page numbering).
  
  If the worms pass each other, then 100% of the pages in each volume will have been nibbled, and the only possibility in this case is that vol 100 is 100% nibbled (providing there are at least 100 volumes).
  
  However if they both reach partially into the same volume (from opposite sides), then we could have a situation where this volume has a smaller percentage nibbled, while all the remaining volumes are 100% nibbled, so if we have at least 100 volumes, this could lead to a viable scenario.
  
  For volumes with n leaves per volume. If worm 1 nibbles v whole volumes, and x (= 1 .. n) additional leaves in the final volume it visits, then the total number of leaves nibbled is:
  
  t₁ = nv + x
  
  and the even page number of the final leaf nibbled is:
  
  p₁ = 2n(v + 1) − 2(x − 1)
  
  and this page number is twice the number of leaves nibbled, hence:
  
  2n(v + 1) − 2(x − 1) = 2(nv + x)
  ⇒
  x = (n + 1) / 2
  
  Hence n must be an odd number. (This effectively eliminates worm 1 from making the other partially nibbled volume by itself).
  
  And worm 2 must nibble twice as many leaves:
  
  t₂ = 2(nv + x)
  t₂ = (2v + 1)n + 1
  
  Hence worm 2 nibbles (2v + 1) whole volumes and 1 additional page of volume (v + 1). (And this effectively eliminates worm 2 from making the other partially nibbled volume by itself).
  
  We want there to be at least 100 volumes, and so:
  
  k = v + (2v + 1) + 1
  k ≥ 100 ⇒ v ≥ 33
  
  And the volume nibbled from both ends (v + 1) must have the percentage of its pages nibbled that is the number of the volume.
  
  100 (x + 1) / n = v + 1
  ⇒
  n(v − 49) = 150
  
  So we can determine the solution by looking at divisor pairs of 150, such that n is greater than 40 and odd. It turns out there is only one possibility:
  
  n = 75, v = 51 → x = 38, p = 52%
  
  Programatically:
```
from enigma import (divisors_pairs, div, printf)

# consider possibilities for n = leaves per volume (odd divisor of 150)
for (v, n) in divisors_pairs(150):
  if not (n > 40): break
  if not (n % 2 == 1): continue
  v += 49  # v = number of whole volumes nibbled by worm 1
  x = div(n + 1, 2)  # x = number of extra leaves nibbled by worm 1
  p = v + 1  # p = volume where percentage nibbled = volume number
  v2 = 2 * v + 1  # v2 = number of whole volumes nibbled by worm 2
  x2 = 1  # x2 = number of extra leaves nibbled by worm 2
  k = v + v2 + 1  # k = total number of volumes
  # output solution
  printf("n={n} k={k} [v={v} x={x} -> v2={v2} x2={x2} p={p}%]")
```
  Solution: There are 155 volumes in the set. And 75 leaves per volume.
  
  Each volume has 150 pages, and the complete set consists of 23250 pages.
  
  Worm 1 has eaten through vols 1 → 51, and 38 leaves of vol 52, so the last leaf consumed is pages 7725/7726. The total number of leaves consumed is 51×75 + 38 = 3863, and 3863×2 = 7726.
  
  Worm 2 starts from the other end of the shelf and eats through 7726 leaves, which is 103 volumes and 1 leaf. It eats through vols 155 → 53, and 1 leaf of vol 52 (= page 7651/7652).
  
  So vol 52 has had 38 leaves eaten by worm 1 and 1 leaf eaten by worm 2, for a total of 39/75 leaves = 52% of the leaves in the volume. And this percentage is the same as the volume number.
  
  The remaining volumes, vols 1-51 and 53-155, have been eaten through entirely by worm 1 or worm 2 respectively. In particular vol 100 has been eaten through 100% by worm 2.
  
  And so there are exactly 2 volumes where the percentage of leaves eaten is equal to the volume number.
  
  LikeLike
  - Frits 4:37 pm on 4 May 2025 Permalink | Reply
    I have gotten a similar manual solution, I didn’t want to publish it. The formula and variables are based on Jim’s original program.
```
 
# n = 2x - 1
# percentage 100(x + x2) = n(v + 1)
# 50(n + 1) = n.v + n - 100x2
# v = 49 + (100.x2 + 50) / n

# 2t/n = (2nv + 2x) / n = 2v + (n + 1) / n = 2v + 1 + 1/n
# so v2 = 2v + 1 and x2 must be 1

# x2 = 1 implies v = 49 + 150 / n
# as n must be odd and > 40 only one value remains for n
# all other values can now be calculated.
```
    LikeLike
  - Frits 6:48 pm on 4 May 2025 Permalink | Reply
    
    We should also prove that there is/are no solution(s) if the percentage of the nibbled leaves for worm 1 was equal to the volume number (v < 100).
    As we have v = 50 + 50 / n this can only happen for n = 50 (not odd).
    
    So we can disregard this option.
    
    LikeLike
Jim Randell 7:37 am on 1 May 2025 Permalink | Reply
Tags: by: Graham Smithers ( 84 )
Teaser 2554: Odd and even
From The Sunday Times, 4th September 2011 [link] [link]

Roddy and Eve have a set of cards on which is written a consecutive sequence of whole numbers, one number on each card. Roddy challenges Oliver to choose two cards at random, promising a prize if the sum of the numbers is odd. Eve issues the same challenge, but offers a prize for an even sum. Oliver accepts the challenge that gives him the greater probability of winning. This probability is a whole number percentage and, when reversed, it gives the two-digit number of cards.

Whose challenge did Oliver accept and how many cards are there?

[teaser2554]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Frits and Jim Randell are discussing. Toggle Comments
- Jim Randell 7:37 am on 1 May 2025 Permalink | Reply
  We can consider sets of cards numbered 1 .. n, as if each card has a offset x from these values, then the sum of the pairs is increased by 2x, and this doesn’t change whether the sum is odd or even.
  
  The percentage must be > 50%, and it is the reverse of the number of cards.
  
  This Python program runs in 77ms. (Internal runtime is 16ms).
```
from enigma import (irange, subsets, div, nrev, printf)

# consider 2-digit percentages >50%
for p in irange(51, 99):
  # reverse is the number of cards
  n = nrev(p)
  if n < 10: continue

  # count odd/even pairs
  t = [0, 0]
  for (x, y) in subsets(irange(1, n), size=2):
    t[(x + y) % 2] += 1
  T = sum(t)

  # calculate higher probability as a percentage
  x = max(t)
  q = div(100 * x, T)
  if q == p:
    # output solution
    printf("n={n} -> t={t} p={p}% (= {x}/{T})")
```
  Solution: There are 25 cards. Oliver chooses Roddy’s challenge.
  
  With 25 cards there are C(25, 2) = 300 ways of choosing a pair of cards.
  
  144 of them give an even total, and 156 of them give an odd total.
  
  So the probability of choosing cards that give an odd total is:
  
  156 / 300 = 0.52 or 52%
  
  LikeLike
- Frits 6:06 pm on 1 May 2025 Permalink | Reply
```
# only consider odd number of cards, n = 10 * a + b
# number odd sums = 1st even * 2nd odd + 1st odd * 2nd even
# ((n - 1) // 2) * ((n + 1) // 2) + ((n + 1) // 2) * ((n - 1) // 2) or
# (n**2 - 1) / 2
# percentage = number odd / (n * (n - 1) = (n + 1) / (2 * n)

# a whole number percentage and, when reversed, 
# it gives the two-digit number of cards
# 100 * ((10 * a + b) + 1) / ((10 * a + b) * 2) = 10 * b + a
# 500 * a + 50 * b + 50 = (a + 10 * b) * (10 * a + b)
# 10 * a**2 + (101 * b - 500) * a + 10 * b**2 - 50 * b - 50 = 0

for b in range(5, 10, 2):
  a, r = divmod(500 - 101 * b + 3 * (1089 * b**2 - 11000 * b + 28000)**.5, 20)
  if r: continue
  print(f"There are {10 * int(a) + b} cards. "
        f"Oliver chooses Roddy's challenge")
```
  LikeLike

Jim Randell 8:04 am on 29 April 2025 Permalink | Reply
Tags: by: C Higgins ( 37 ), by: H Bradley ( 37 )

Teaser 2526: [Lucky dates]

From The Sunday Times, 20th February 2011 [link] [link]

Orla was married in this century, on her lucky day of the week, and her twin sister Enya’s lucky-number day of the month. Enya told Orla on that big day that she intended her own wedding to be on the same lucky day of the week and lucky-number day of the month. She realised that it could not be in the same year as Orla’s, but Orla added that Enya could not be married in the following year, either. Enya married months later, the actual number of months being the sum of the six digits of Orla’s wedding date.

What was Orla’s wedding date?

This puzzle was originally published with no title.

[teaser2526]

Jim Randell 8:04 am on 29 April 2025 Permalink | Reply

I am assuming that “this century” means the 21st century (which started on 2001-01-01).

And “the sum of the six digits of Orla’s wedding date” refers to the sum of date expressed as “DD/MM/YY” (i.e. using the final 2 digits of the year, rather than indicating that Orla’s wedding date is of the form “D/M/YYYY”).

This Python program runs in 67ms. (Internal runtime is 9.0ms).

from datetime import (date, timedelta)
from enigma import (irange, repeat, inc, dsum, catch, printf)

# increment date (<d>, <m>, <y>) by <i> months
def incmonth(d, m, y, i=1):
  m += i
  while m > 12:
    m -= 12
    y += 1
  return catch(date, y, m, d)

# consider dates in the 21st century for Orla's wedding
for d1 in repeat(inc(timedelta(days=1)), date(2001, 1, 1)):
  if d1.year > 2009: break
  # calculate the day of the week
  wd = d1.isoweekday()
  valid = lambda x: x is not None and x.isoweekday() == wd
  # calculate the digit sum of the date (6 digits)
  (d, m, y) = (d1.day, d1.month, d1.year)
  n = dsum(d) + dsum(m) + dsum(y % 100)
  # consider a date <n> months in advance
  d2 = incmonth(d, m, y, n)
  if not valid(d2): continue
  if not (d2.year - d1.year > 1): continue
  # and check no intervening date would do
  if any(valid(incmonth(d, m, y, i)) for i in irange(1, n - 1)): continue
  # output solution
  printf("Orla = {d1}, Enya = {d2} [{n} months later]")

Solution: Orla’s wedding day was: Wednesday, 31st December 2008.

The next (Wednesday, 31st) occurs on: Wednesday, 31st March 2010, and so this is Enya’s wedding day.

Enya’s wedding day occurs 15 months after Orla’s, and the sum of the digits in Orla’s date expressed as: 31/12/08 is 15.

If we were to use an 8-digit format for the dates (e.g. “DD/MM/YYYY” or “YYYY-MM-DD”), we can get a solution of:

Orla = Tuesday, 31st July 2007
Enya = Tuesday, 31st March 2009 (20 months later)

LikeLike

Frits 12:32 pm on 30 April 2025 Permalink | Reply

from enigma import SubstitutedExpression
from datetime import date

# check date format and possible other checks
def check(AB, CD, EF, extra=False):
  try:
    wd = date(2000 + EF, CD, AB).weekday()
  except ValueError:
    return False
  
  if extra:
    # check if in the next year there are any dates with day number AB
    # on the same weekday as Orla's
    for m in range(1, 13):
      try:
        if date(2000 + EF + 1, m, AB).weekday() == wd: 
          return False
      except ValueError:
        continue
  return True

# the alphametic puzzle
p = SubstitutedExpression(
  [ # Orla : AB-CD-EF  Enya: AB-GH-IJ  (dd-mm-yy)
    "AB < 32",
    "CD < 13",
    # Enya married months later but not in the following year
    "(sd := A + B + C + D + E + F) > 24 - CD",
    # check validity of Orla's date and that Enya could not be married 
    # in the following year
    "check(AB, CD, EF, 1)",
    
    "IJ <= 11",   # 2011
    # Enya could not be married in the following year
    "IJ > EF + 1",
    
    # Enya married months later, the actual number of months being the sum 
    # of the six digits of Orla's wedding date
    "sd - 12 * (IJ - EF) + CD = GH",
    "0 < GH < 13",
    
    # check validity of Enya's date
    "check(AB, GH, IJ)",
    # Enya married on the same day of the week as Orla
    "date(2000 + EF, CD, AB).weekday() == date(2000 + IJ, GH, AB).weekday()"
  ],
  answer="(AB, CD, 2000 + EF)",
  d2i=dict([(k, "ICGE") for k in range(2, 4)] +
           [(k, "AICGE") for k in range(4, 10)]),
  distinct="",
  s2d=dict(E=0),
  env=dict(date=date, check=check),
  reorder=0,
  verbose=0,    # use 256 to see the generated code
)

# print answers
for ans in p.answers():
  print(f"answer: {'-'.join(str(x) for x in ans)}")

LikeLike

Jim Randell 6:41 am on 27 April 2025 Permalink | Reply
Tags: by: Colin Vout ( 38 )

Teaser 3266: Where are the keys?

From The Sunday Times, 27th April 2025 [link] [link]

Skaredahora’s venture into atonal music — music with no fixed key — had as its (so-called!) melody a long sequence employing 8 different notes, which he labelled Q to X. Behind his composition were 7 keys each using 4 notes. Every three consecutive melody notes obeyed specific rules:

(1) all three had to be different;
(2) they had to belong to exactly one of the keys;
(3) they had not to repeat in the same order any other three consecutive notes;
(4) the key had to change at every step.

His chosen melody was:

WUQRVWQRXWTRUQWRVQWTSRQWVRSTWQVRWQURTWXRQVWRTSX

What were the keys involving X, in alphabetical order individually and collectively (e.g. QRTX, SUVX)?

[teaser3266]

Jim Randell 8:08 am on 27 April 2025 Permalink | Reply

Be careful to get the melody sequence exactly right! (I initially had a typo that made it impossible to find a solution).

This Python 3 program solves the puzzle constructively. It first checks that triples of 3 consecutive notes are all different (3), and each consists of 3 different notes (1). It then fills out keys that can be used to play the triples in the required order, with a key change at each step (4). And then finally, once a set of keys is found, it checks that each triple belongs to exactly one of the keys (2).

The program runs in 72ms. (Internal runtime is 1.2ms).

from enigma import (tuples, join, fail, update, singleton, seq2str, printf)

# the chosen melody
melody = "WUQRVWQRXWTRUQWRVQWTSRQWVRSTWQVRWQURTWXRQVWRTSX"

K = 4  # number of notes in a key
N = 7  # number of keys

# split into triples
ts = list(tuples(melody, 3, fn=join))
# check they are all different (3), and consist of different notes (1)
if not (len(ts) == len(set(ts)) and all(len(t) == len(set(t)) for t in ts)):
  fail(msg="invalid melody")

# find keys <ks> for the triples <ts>, with no adjacent repeats (4)
# ts = triples to solve
# n = number of next key to allocate
# ks = map of keys to notes
# pk = previous key
def solve(ts, n=1, ks=dict(), pk=0):
  # are we done?
  if not ts:
    yield ks
    return

  # look at the next triple
  t = set(ts[0])

  # examine its relation to existing keys
  (ks1, ks2) = (list(), list())
  for (k, v) in ks.items():
    if v.issuperset(t):
      # it is already fully covered by an existing key
      ks1.append(k)
    else:
      vt = v.union(t)
      if len(vt) <= K:
        # an existing key can be extended to cover it
        ks2.append((k, vt))

  # there are three cases:
  if ks1:
    # it is already covered by exactly one key
    k = singleton(ks1, default=0)
    if k > 0 and k != pk: yield from solve(ts[1:], n, ks, k)
    return  # we are done

  # extend an existing key
  for (k, v) in ks2:
    if k != pk:
      yield from solve(ts[1:], n, update(ks, [(k, v)]), k)

  # allocate a new key
  if  n <= N:
    yield from solve(ts[1:], n + 1, update(ks, [(n, t)]), n)

# construct the progression of keys, where each triple belongs to exactly one key (2)
def check_keys(ts, ks):
  ss = list()
  # check each triple belongs to just one of the keys
  for t in ts:
    ss.append(singleton(k for (k, v) in ks.items() if v.issuperset(t)))
    if ss[-1] is None: return
  return ss

# solve the puzzle
for ks in solve(ts):
  ss = check_keys(ts, ks)
  if not ss: continue
  # output solution
  for k in sorted(ks):
    printf("{k}: {vs}{s}", vs=seq2str(ks[k], sort=1, sep=" "), s=(' <-' if 'X' in ks[k] else ''))
  printf("{ss}", ss=seq2str(ss, sep=" "))
  printf()

Solution: The keys involving X are: QRUX, RVWX, STWX.

The full set of keys is:

1: (Q U V W)
2: (Q R U X)
3: (Q R S V)
4: (R V W X)
5: (Q R T W)
6: (S T W X)
7: (R S T U)

(The required answer to the puzzle is keys 2, 4, 6, which all contain the note X).

And this gives the following progression of keys:

(1 2 3 4 1 5 2 4 6 5 7 2 1 5 4 3 1 5 6 7 3 5 1 4 3 7 6 5 1 3 4 5 1 2 7 5 6 4 2 3 1 4 5 7 6)

LikeLike

Jim Randell 12:06 pm on 4 May 2025 Permalink | Reply

We can slightly simplify the code using the following observation (due to JohnZ [link]).

Each set of 3 consecutive notes in the melody must uniquely identify a key, and adjacent triples must identify different keys, hence no key can consist of 4 consecutive notes in the melody, so we can identify a set of invalid keys that we can avoid to ensure each consecutive key must be different. And this means we don’t have to drag information about the previously used key as we construct the progression of keys.

Here is a modified version of my program adapted to use this method. It has an internal runtime of 524µs.

from enigma import (tuples, join, fail, update, singleton, seq2str, printf)

# the chosen melody
melody = "WUQRVWQRXWTRUQWRVQWTSRQWVRSTWQVRWQURTWXRQVWRTSX"

K = 4  # number of notes in a key
N = 7  # number of keys

# split into triples
ts = list(tuples(melody, 3, fn=join))
# check they are all different (3), and consist of different notes (1)
if not (len(ts) == len(set(ts)) and all(len(t) == len(set(t)) for t in ts)):
  fail(msg="invalid melody")

# but no key can include 4 consecutive notes from the melody, so if we avoid
# the following keys, there can be no adjacent repeats (4)
invalid = set(tuples(melody, 4, fn=frozenset))

# find keys <ks> for the triples <ts>, with no adjacent repeats (4)
# ts = triples to solve
# n = number of next key to allocate
# ks = map of keys to notes
def solve(ts, n=1, ks=dict()):
  # are we done?
  if not ts:
    yield ks
    return

  # look at the next triple
  t = set(ts[0])

  # examine its relation to existing keys
  (ks1, ks2) = (list(), list())
  for (k, v) in ks.items():
    if v.issuperset(t):
      # it is already fully covered by an existing key
      ks1.append(k)
    else:
      vt = v.union(t)
      if len(vt) <= K and vt not in invalid:
        # an existing key can be extended to cover it
        ks2.append((k, vt))

  # there are three cases:
  if ks1:
    # it is already covered by exactly one key
    k = singleton(ks1, default=0)
    if k > 0: yield from solve(ts[1:], n, ks)
    return  # we are done

  # extend an existing key
  for (k, v) in ks2:
    yield from solve(ts[1:], n, update(ks, [(k, v)]))

  # allocate a new key
  if  n <= N:
    yield from solve(ts[1:], n + 1, update(ks, [(n, t)]))

# construct the progression of keys, where each triple belongs to exactly one key (2)
def check_keys(ts, ks):
  ss = list()
  # check each triple belongs to just one of the keys
  for t in ts:
    ss.append(singleton(k for (k, v) in ks.items() if v.issuperset(t)))
    if ss[-1] is None: return
  return ss

# solve the puzzle
for ks in solve(ts):
  ss = check_keys(ts, ks)
  if not ss: continue
  # output solution
  for k in sorted(ks):
    printf("{k}: {vs}{s}", vs=seq2str(ks[k], sort=1, sep=" "), s=(' <-' if 'X' in ks[k] else ''))
  printf("{ss}", ss=seq2str(ss, sep=" "))
  printf()

LikeLike

Pete Good 2:57 pm on 30 April 2025 Permalink | Reply

Jim, The Sunday Times published this teaser under the title “Where Are the Keys?”

LikeLike
- Jim Randell 3:02 pm on 30 April 2025 Permalink | Reply
  
  @Pete: Thanks. Corrected now.
  
  LikeLike

Jim Randell 6:45 am on 24 April 2025 Permalink | Reply
Tags: by: Bob Walker ( 10 )

Teaser 2555: Today’s value

From The Sunday Times, 11th September 2011 [link] [link]

These 10 children’s bricks are numbered from 1 to 10. Where a brick rests on two others its number is the difference of their two numbers. Given that U = 1 …

What is the number DAY?

[teaser2555]

Jim Randell 6:46 am on 24 April 2025 Permalink | Reply

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

The following run file executes in 78ms. (Internal runtime of the generated code is 331µs).

#! python3 -m enigma -rr

SubstitutedExpression

# numbers range from 1 to 10
--base=11
--digits="1-10"

"abs(U - N) = S"
"abs(D - A) = U"
"abs(A - Y) = N"
"abs(T - I) = D"
"abs(I - M) = A"
"abs(M - E) = Y"

--assign="U,1"
--answer="(D, A, Y)"

--template=""

Solution: DAY = 672.

At least the digits have values: D = 6, A = 7, Y = 2.

But since the digits go from 1 to 10, you could argue that the result is expressed in base 11, so:

DAY = 672 [base 11] = 805 [base 10]

LikeLike

Ruud 6:14 am on 28 April 2025 Permalink | Reply

Brute force one liner:

import itertools

print(
    *(
        f"{d}{a}{y}"
        for s, n, d, a, y, t, i, m, e in itertools.permutations(range(2, 11), 9)
        if s == abs(1 - n) and 1 == abs(d - a) and n == abs(a - y) and d == abs(t - i) and a == abs(i - m) and y == abs(m - e)
    )
)

LikeLike

Frits 10:51 am on 26 April 2025 Permalink | Reply

#    S
#   U N                            U = 1
#  D A Y
# T I M E

sols = set()
U, mx = 1, 10
r0 = set(range(2, mx + 1)) # remaining digits to use

for N in range(2, mx - 1):  # no using <mx - 1> and <mx> on this level
  S = N - U
  r1 = r0 - {N, S}
  if len(r1) != len(r0) - 2: continue
  for A in r1 - {mx}:       
    r2 = r1 - {A}
    for D in (A - U, A + U):
      if D not in r2 or D == mx: continue
      r3 = r2 - {D}
      for Y in (A - N, A + N):
        if Y not in r3 or Y == mx: continue
        r4 = r3 - {Y}
        if max(r4) - min(r4) < max(D, A, Y): continue
        for I in r4:
          for M in (I - A, I + A):
            if M not in r4: continue
            for T in (I - D, I + D):
              if T not in r4: continue
              for E in (M - Y, M + Y):
                if {T, I, M, E} != r4: continue
                sols.add(100 * D + 10 * A + Y)

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

LikeLike

Jim Randell 8:18 am on 22 April 2025 Permalink | Reply
Tags: by: Graham Smithers ( 84 )

Teaser 2550: Cricket averages

From The Sunday Times, 7th August 2011 [link] [link]

Playing for our local team, Sam and Oliver between them took 5 wickets in each innings, taking 5 wickets each overall. Sam’s averages (i.e. runs per wicket) were lower than Oliver’s in both innings, but overall Sam had the higher average. All six averages were single non-zero digits.

If you knew Sam’s overall average, it would then be possible to calculate the number of runs scored against Sam and against Oliver.

What were the total runs scored against: (a) Sam and (b) Oliver?

[teaser2550]

Jim Randell 8:19 am on 22 April 2025 Permalink | Reply

This Python program chooses possible numbers of wickets taken by each bowler in each innings, and then considers possible averages such than Sam has a lower average than Oliver in each innings, but a higher average overall.

From the possible candidate scenarios we then looks for situations where knowing Sam’s overall average allows you to determine the overall number of runs scored against each bowler.

It runs in 65ms. (Internal runtime is 2.2ms).

from enigma import (Record, decompose, subsets, irange, div, filter_unique, printf)

# generate possible scenarios
def generate():
  # choose numbers of wickets taken by S and O in the first innings
  for (wS1, wO1) in decompose(5, 2, increasing=0, sep=0, min_v=1):
    # numbers of wickets taken in the second innings
    (wS2, wO2) = (5 - wS1, 5 - wO1)

    # S and O's averages in the first innings (single digit numbers)
    for (aS1, aO1) in subsets(irange(1, 9), size=2):
      # calculate runs against S and O in the first innings
      (rS1, rO1) = (aS1 * wS1, aO1 * wO1)

      # averages in the second innings
      for (aS2, aO2) in subsets(irange(1, 9), size=2):
        # calculate runs against S and O in the second innings
        (rS2, rO2) = (aS2 * wS2, aO2 * wO2)

        # overall averages
        (orS, orO) = (rS1 + rS2, rO1 + rO2)
        (oaS, oaO) = (div(orS, 5), div(orO, 5))
        if oaS is None or oaO is None or not (oaS > oaO): continue

        # output: first innings; second innings; totals
        printf("[1: S={wS1}w for {rS1}r avg={aS1}, O={wO1}w for {rO1}r avg={aO1}; 2: S={wS2}w for {rS2}r avg={aS2}, O={wO2}w for {rO2}r avg={aO2}; T: S=5w for {orS}r avg={oaS}, O=5w for {orO}r avg={oaO}]")
        yield Record(
          wS1=wS1, wO1=wO1, rS1=rS1, rO1=rO1, aS1=aS1, aO1=aO1,
          wS2=wS2, wO2=wO2, rS2=rS2, rO2=rO2, aS2=aS2, aO2=aO2,
          orS=orS, orO=orO, oaS=oaS, oaO=oaO,
        )

# if you knew oaS, then you could determine (orS, orO)
rs = filter_unique(generate(), (lambda r: r.oaS), (lambda r: (r.orS, r.orO)))
for r in rs.unique:
  printf("S={r.orS}r O={r.orO}r [{r}]")

Solution: (a) 35 runs were scored against Sam; (b) 25 runs were scored against Oliver.

Here is one scenario:

First innings:
Sam took 1 wicket, for 3 runs (avg = 3/1 = 3).
Oliver took 4 wickets, for 16 runs (avg = 16/4 = 4).

Second innings:
Sam took 4 wickets, for 32 runs (avg = 32/4 = 8).
Oliver took 1 wicket, for 9 runs (avg = 9/1 = 9).

Overall:
Sam took 5 wickets, for 35 runs (avg = 35/5 = 7).
Oliver took 5 wickets, for 25 runs (avg = 25/5 = 5).

In each innings Sam has a lower average than Oliver, but overall Oliver has a lower average than Sam.

There is a second scenario, with the innings in the opposite order.

LikeLike

Frits 3:35 pm on 22 April 2025 Permalink | Reply

Inventing the wheel again to determine a duplicate entry. I didn’t feel like grouping entries per overall average.

from enigma import SubstitutedExpression

# the alphametic puzzle
p = SubstitutedExpression(
  [ # Sam:    1st: A wickets, avg B, 2nd: C wickets, avg D, overall avg E
    # Oliver: 1st: P wickets, avg Q, 2nd: R wickets, avg S, overall avg T
    
    # between them took 5 wickets in each innings and taking 
    # 5 wickets each overall (assume Sam took more wickets in the 2nd inning)
    "5 - A = P", "5 - P = R", "5 - R = C",
    "A < C", "A + C == 5", 
    # Sam had lower averages ...
    "B < Q", "D < S",
    # total averages"
    "div(trs := A * B + C * D, 5) = E",
    "div(tro := P * Q + R * S, 5) = T",
    # ... but a higher overall average
    "E > T",
  ],
  answer="E, (trs, tro)",
  d2i=dict([(0, "ACPRQS")] +
           [(k, "ACPR") for k in range(5, 9)] +
           [(9, "ACPRBD")]),
  distinct="",
  verbose=0,    # use 256 to see the generated code
)

c, prev, sols = 0, (-1, -1), set()
# get unique values of Sam's overall average
for (soa, tr) in sorted(p.answers()) + [(-1, prev)]:
  if soa != prev[0]:
    if c == 1:
      sols.add(prev[1])
    c = 1
  else:
    c += 1
  prev = (soa, tr)

# print total runs
for trS, trO in sols:  
  print(f"answer: a() = {trS} runs, b() = {trO} runs")

LikeLike

Jim Randell 6:59 am on 20 April 2025 Permalink | Reply
Tags: by: Andrew Skidmore ( 87 )

Teaser 3265: Easter prayer

From The Sunday Times, 20th April 2025 [link] [link]

Millions of people will today turn their thoughts to those throughout the world whose lives are made miserable by the ravages of war and bitter conflict. I have taken a selection of letters from the alphabet and given each a different single-digit value. In this way the two words that form the title of this teaser represent two six-digit numbers, one of which is a factor of the other.

There are two letters in EASTER PRAYER for which the following is true. If I told you the value of that letter alone, you wouldn’t be able to work out all the others, but if I told you both their values then you could work out all the values.

What is the value of PRAYER?

[teaser3265]

Jim Randell 7:49 am on 20 April 2025 Permalink | Reply

This Python program uses the [[ SubstitutedExpression ]] solver from the enigma.py library to find solutions to the alphametic puzzle, and then looks for a pair of symbols that allow a unique solution to be determined if both their values are known, but not if only one of their values is known.

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

from enigma import (SubstitutedExpression, filter_unique, singleton, subsets, translate, printf)

# find solutions to the alphametic puzzle
expr = "EASTER % PRAYER == 0 or PRAYER % EASTER == 0"
tmpl = "[EASTER={EASTER} PRAYER={PRAYER}]"
p = SubstitutedExpression(expr, template=tmpl)
ss = list(p.solve(verbose="T"))

# for each symbol record values with multiple solutions
rs = set()
for k in p.symbols:
  for s in filter_unique(ss, (lambda s: s[k])).non_unique:
    rs.add((k, s[k]))

# look for pairs that give a unique solution
for ((k1, v1), (k2, v2)) in subsets(rs, size=2):
  if k1 == k2: continue
  s = singleton(s for s in ss if s[k1] == v1 and s[k2] == v2)
  if s is None: continue

  # output solution
  (EASTER, PRAYER) = (translate(x, s) for x in ["EASTER", "PRAYER"])
  printf("{k1}={v1} {k2}={v2} -> EASTER={EASTER} PRAYER={PRAYER}")

Solution: PRAYER = 159275.

There are 3 candidate solutions:

EASTER = 796375; PRAYER = 159275
EASTER = 796875; PRAYER = 159375
EASTER = 798375; PRAYER = 159675

In each case EASTER = 5 × PRAYER.

And if we were told either of S = 6 or T = 3 we could only narrow the candidates down to 2 solutions. But if we are told both together, then we can narrow the candidates down to a single solution (the first one).

LikeLike

Frits 1:49 pm on 20 April 2025 Permalink | Reply

As usual built for speed.
Always difficult to code a branch that is not easy to test.

from itertools import permutations, combinations, product
from functools import reduce

# digits to number
d2n = lambda *s: reduce(lambda x,  y: 10 * x + y, s)
# return <n>th digit of number <num>, n has to be > 0
nth = lambda num, n, ln=1: int(str(num)[n - 1:n - 1 + ln])

# EASTER % PRAYER == 0 or PRAYER % EASTER == 0 
cands = []
for E, R in permutations(range(10), 2):  
  if not E: continue
  ER = d2n(E, R)
  for m in range(2, 10):                   # multiplier
    if (m * ER) % 100 != ER: continue
    
    if E >= m:  # EASTER might be the numerator
      for P in [n for n in range(1, E // m + 1) if n not in {E, R}]:
        PR = d2n(P, R)
        # check if m * PR9999 can become at least Exxxxx
        if nth(m * (PR + 1), 1) < E: continue
        for A in set(range(10)) - {E, R, P}:
          PRA = d2n(P, R, A)
          EA = d2n(E, A)
          # check if m * PRA999 can become at least EAxxxx
          if nth(m * (PRA + 1), 1, 2) < EA: continue
          for Y in set(range(10)) - {E, R, P, A}:
            PRAYER = d2n(P, R, A, Y, E, R)
            EASTER = m * PRAYER
            if nth(EASTER, 1, 2) != EA: continue
            S = nth(EASTER, 3)
            T = nth(EASTER, 4)
            if S == T or not {E, R, P, A, Y}.isdisjoint({S, T}): continue
            cands.append(([A, E, P, R, S, T, Y]))
            
    if m * E < 10:  # EASTER might be the denominator 
      for P in range(m * E, 10):
        if P == R: continue
        PR = d2n(P, R)
        for A in set(range(10)) - {E, R, P}:
          EA = d2n(E, A)
          # check if m * EA9999 can become at least PRxxxx
          if nth(m * (EA + 1), 1, 2) < PR: continue
          PRA = d2n(P, R, A)
          for S in set(range(10)) - {E, R, P, A}:
            EAS = d2n(E, A, S)
            # check if m * EAS999 can become at least PRAxxx
            if nth(m * (EAS + 1), 1, 3) < PRA: continue
            for T in set(range(10)) - {E, R, P, A, S}:
              EASTER = d2n(E, A, S, T, E, R)
              PRAYER = m * EASTER
              if nth(PRAYER, 1, 3) != PRA: continue
              Y = nth(PRAYER, 4)
              if Y in {E, R, P, A, S, T}: continue
              cands.append(([A, E, P, R, S, T, Y]))

if not cands:
  print("no solution")

# positions of letters that have multiple values (but not all different)
pos = [j  for j in range(7) if 1 < len({c[j] for c in cands}) < len(cands)]

# choose two of those letters
for a, b in combinations(pos, 2):
  # collect letter values ...
  lv = [[c[x] for c in cands] for x in (a, b)]
  # ... that occur more than once
  lv = [{x for i, x in enumerate(v) if x in v[i + 1:]} for v in lv]
  # choose for each letter a value
  for p1, p2 in product(*lv):
    # corresponding candidates
    if len(cs := [c for c in cands if c[a] == p1 and c[b] == p2]) != 1: 
      continue 
    # select PRAYER
    print("answer:", ''.join(str(cs[0][i]) for i in [2, 3, 0, 6, 1, 3]))

LikeLike

Jim Randell 10:08 am on 17 April 2025 Permalink | Reply
Tags: by: Andrew Skidmore ( 87 )
Teaser 2535: Eastertide
From The Sunday Times, 24th April 2011 [link] [link]

In the following division sum I have consistently replaced digits with letters, with different letters used for different digits. All three numbers featured are even:

EASTER ÷ TIDE = EGG

What is the numerical value of my TEASER?

[teaser2535]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 10:08 am on 17 April 2025 Permalink | Reply
  We can solve this puzzle using the [[ SubstitutedExpression ]] solver from the enigma.py library:
  
  The following command line executes in 83ms. (Internal runtime of the generated code is 5.6ms).
```
% python3 -m enigma SubstitutedExpression "EGG * TIDE = EASTER" --answer="TEASER"
(EGG * TIDE = EASTER) (TEASER)
(244 * 1062 = 259128) (125928) / A=5 D=6 E=2 G=4 I=0 R=8 S=9 T=1
TEASER = 125928 [1 solution]
```
  Solution: TEASER = 125928.
  
  LikeLike

Jim Randell 9:06 am on 15 April 2025 Permalink | Reply
Tags: by: W A Thatcher ( 13 )

Brain-Teaser 380: [Feeler gauges]

From The Sunday Times, 18th August 1968 [link]

“Feeler gauges”, says Bell at the pub, “are remarkably interesting things. You’ve all seen garage men use them — fingers of steel fastened together at one end and you can fan them out if you want. When you measure a space you find out which lot of fingers fits in. The thicknesses are marked in thous, that’s thousandths of an inch”.

“I’ve got a set of five gauges here which will measure any number up to 13 thous, always using either a single gauge or a touching set of them. You don’t need to use gauges which aren’t touching for a measurement like you do with the usual gauges. So mine’s better. I might patent it and make a packet”.

Clark examined it for few minutes and said “Not bad at all. I notice you could add an extra gauge in front and then your set would give all measurements up to 18 thous”.

How would the six gauges then read starting at the top?

This puzzle was originally published with no title.

[teaser380]

Jim Randell 9:08 am on 15 April 2025 Permalink | Reply

See also: Teaser 119, Teaser 560, Teaser 777, BrainTwister #61.

I reused the code to generate sparse rulers that I wrote for Teaser 119.

This Python 3 program runs in 81ms. (Internal runtime is 4.1ms).

from enigma import (irange, diff, append, tuples, csum, subsets, printf)

# generate sparse rulers
# L = length
# M = number of marks
# ms = existing marks (set)
# k = number of remaining marks
# xs = distances not yet satisfied (ordered list)
# zl = left zone
# zr = right zone
def rulers(L, M, ms, k, xs, zl, zr):
  if k == 0:
    if not xs:
      yield sorted(ms)
  else:
    # perform some early termination checks:
    # are there too many unsatisfied differences remaining?
    if xs and len(xs) > (k * (k - 1)) // 2 + k * (M - k): return
    # is max distance too big?
    if xs and xs[-1] > max(zr, L - zl): return
    # can we fit k marks in the gaps?
    if zr - zl + 1 < k: return

    # extend left zone?
    if not (zl > L - zr):
      # try with mark at zl
      ds = set(abs(m - zl) for m in ms)
      yield from rulers(L, M, append(ms, zl), k - 1, diff(xs, ds), zl + 1, zr)
      # try without mark at zl
      yield from rulers(L, M, ms, k, xs, zl + 1, zr)
    else:
      # try without mark at zr
      yield from rulers(L, M, ms, k, xs, zl, zr - 1)
      # try with mark at zr
      ds = set(abs(m - zr) for m in ms)
      yield from rulers(L, M, append(ms, zr), k - 1, diff(xs, ds), zl, zr - 1)

# generate rulers that can measure 1..N
sparse_rulers = lambda L, M, N: rulers(L, M, {0, L}, M - 2, diff(irange(1, N), [L]), 1, L - 1)

# consider possible sparse rulers with length L, to measure 1 - 13
for L in irange(13, 19):
  for ss in sparse_rulers(L, 6, 13):
    # calculate gauge thicknesses
    ts = list(b - a for (a, b) in tuples(ss, 2))

    # look for an additional gauge to make all thicknesses up to 18
    for x in irange(max(18 - L, 1), 17):
      ts_ = [x] + ts
      # calculate all measures
      ms_ = set(y - x for (x, y) in subsets(csum(ts_, empty=1), size=2))
      if ms_.issuperset(irange(1, 18)):
        # output solution
        printf("[1..13] = {ts} -> [1..18] = {ts_}")

Solution: The six gauges are: 14, 1, 3, 6, 2, 5.

Gauges [1, 3, 6, 2, 5] can be use to measure 1..13 (as well as 16, 17). It corresponds to a sparse ruler of length 17 with 6 marks.

Adding a gauge of 14 we get the set [14, 1, 3, 6, 2, 5], which can measure 1..18 (as well as 24, 26, 31). Which corresponds to a sparse ruler of length 31 with 7 marks.

Each of the gauges in the original 5-set has a different thickness, and there is another 5-set that would also work:

[1, 7, 3, 2, 4], which can measure 1..13 (as well as 16, 17).

But it cannot be extended to a 6-set that measures 1..18.

LikeLike

Frits 12:19 pm on 17 April 2025 Permalink | Reply

@Jim, you are allowing negative gauges in line 48.

LikeLike
- Jim Randell 2:39 pm on 17 April 2025 Permalink | Reply
  
  @Frits: Thanks. Fixed now.
  
  LikeLike

Frits 12:08 pm on 17 April 2025 Permalink | Reply

Assuming that the first five gauges are single digit.
Instead of “SubstitutedExpression” also “decompose” could have been used to find five numbers that add up to “L”.

from enigma import SubstitutedExpression
from itertools import combinations, accumulate

# can we make numbers 1 - <n> with sequence <s> using "touching" sets 
def check(s, n):
  # calculate all measures
  s_ = set(y - x for (x, y) in combinations(accumulate([0] + s), 2))
  return s_.issuperset(range(1, n + 1))

# the alphametic puzzle
p = SubstitutedExpression(
  [ # we have to make numbers 1 - 13 with a touching set of gauges A, B, C, D, E
    "A + B + C + D < 19",
    "12 < A + B + C + D + E < 20",  # Jim: 13 <= L <= 19
    "check([A, B, C, D, E], 13)",
    
    # we have to make numbers 1 - 18 with a touching set of gauges XY, A, B, C, D, E
    "XY < 18",                  # Jim: 18 - L <= XY <= 17
    "check([XY, A, B, C, D, E], 18)"
  ],
  answer="[XY, A, B, C, D, E]",
  d2i=dict([(0, "ABCDE")] +
           [(k, "X") for k in range(2, 10)]),
  distinct="",
  env=dict(check=check),
  reorder=0,
  verbose=0,    # use 256 to see the generated code
)

# print answers
for ans in p.answers():
  print(f"{ans}")

LikeLike

Frits 12:41 pm on 17 April 2025 Permalink | Reply

The decomposition version (without assuming single digits).

from itertools import combinations, accumulate

# can we make numbers 1 - <n> with sequence <s> using "touching" sets 
def check(s, n):
  # calculate all measures
  s_ = set(y - x for (x, y) in combinations(accumulate([0] + s), 2))
  return s_.issuperset(range(1, n + 1))
  
# decompose <t> into <k> numbers from <ns> so that sum(numbers) equals <t>
def decompose(t, k, ns, s=[]):
  if k == 1:
    if t in ns:
      yield s + [t]
  else:
    for n in ns:
      # <ns> must be a sorted list
      if n > t - (k - 1) * ns[0]: break
      yield from decompose(t - n, k - 1, ns, s + [n])

# consider possible sparse rulers with length L, to measure 1 - 13
for L in range(13, 20):
  # find five numbers that up to <L>
  for s in decompose(L, 5, range(1, L - 3)):
    # can we make numbers 1 - 13 with sequence <s> using "touching" sets
    if not check(s, 13): continue
    # look for an additional gauge to make all thicknesses up to 18
    for x in range(max(1, 18 - L), 18):
      # can we make numbers 1 - 18 using "touching" sets 
      if not check([x] + s, 18): continue
      # output solution
      print(f"[1..13] = {s} -> [1..18] = {[x] + s}")

LikeLike

Jim Randell 6:53 am on 13 April 2025 Permalink | Reply
Tags: by: Mark Valentine ( 17 )
Teaser 3264: Saving rum
From The Sunday Times, 13th April 2025 [link] [link]

Captain Noah was tired of spilling his rum at sea. His glass (twice the density of the rum) is a hollow cylinder with a solid flat base. The outer diameter is 72 mm. The glass thickness and base height are both 4 mm. After testing the stability of the upright glass, he instructed the steward to keep his glass topped up to one-third full, where it has the lowest centre of mass.

What is the overall height of the glass (including the base)?

[teaser3264]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 8:03 am on 13 April 2025 Permalink | Reply
  Here is a numerical solution, using the [[ find_min() ]] function from the enigma.py library.
  
  I treat the glass and rum system as 3 separate components:
  
  a hollow cylinder of glass, with external diameter 72 mm (external radius = 36 mm) and 4 mm thick walls (internal radius = 32 mm), and height h.
  
  a solid disc of glass, with diameter 72 mm (radius = 36 mm) and height 4 mm, that sits underneath the cylinder, on a flat table.
  
  a cylinder of rum with radius 32 mm, and height x (between 0 and h), that sits on the disc, inside the cylinder. The density of the rum is 1/2 that of the glass.
  
  The individual centres of mass of the three components are then combined to give the combined centre of mass. Each of them is somewhere on the central line of the cylinder, so we only need to worry about their heights above the table.
  
  For a given value of h we can calculate the value of x that gives the minimum height for the combined centre of mass, and then look for a value of h where h = 3x.
  
  This Python program runs in 69ms. (Internal runtime is 2.3ms).
```
from enigma import (sq, fdiv, find_min, find_value, printf)

# given height h find height of rum that gives the minimal centre of mass
def fn(h):

  # calculate centre of mass for rum height x
  def f(x):
    # mass of cylinder, base, rum (half the density)
    mc = (sq(36) - sq(32)) * h * 2
    mb = sq(36) * 4 * 2
    mr = x * sq(32)
    # heights of their respective centres of mass
    hc = 4 + h * 0.5
    hb = 2
    hr = 4 + x * 0.5
    # calculate height of combined centre of mass
    return fdiv(mc * hc + mb * hb + mr * hr, mc + mb + mr)

  # find minimal centre of mass = x
  r = find_min(f, 0, h)
  x = r.v
  # return h/x
  return fdiv(h, x)

# find when h/x = 3 (i.e. the minimal centre of mass is when the glass is 1/3 full)
r = find_value(fn, 3, 20, 200)
# output overall glass height (including base = 4 mm)
h = r.v + 4
printf("height = {h:.2f} mm")
```
  Solution: The glass is 112 mm high.
  
  So the internal height is 108 mm, and the lowest centre of mass occurs with 36 mm of rum in the glass.
  
  We can get an exact answer to the puzzle using analysis.
  
  LikeLike
  - Jim Randell 1:14 pm on 15 April 2025 Permalink | Reply
    Here is my analytical solution:
    
    The CoM of the cylinder is in the centre of the cylinder, and adding the base will bring the CoM down a little.
    
    Suppose we then start adding rum to the glass:
    
    We start by adding a little rum. This forms a layer of rum below the current CoM of the glass, so the combined CoM moves down a bit. And this continues until the combined CoM is level with the top of the rum. At this point, when we add additional rum, it forms a layer above the current CoM, and so the combined CoM starts to move upwards.
    
    Hence the combined CoM is at a minimum when it is level with the top of the rum.
    
    So we are interested in when:
    
    ∑(m[i] . h[i]) / ∑(m[i]) = x + 4
    ⇒
    ∑(m[i] . h[i]) = (x + 4) ∑(m[i])
    
    And we want to find solutions when h = 3x, which we can do manually, or use a program.
```
from enigma import (Polynomial, rdiv, sq, printf)

x = Polynomial('x')
h = 3 * x
half = rdiv(1, 2)

# mass of cylinder, base, rum (half the density)
mc = (sq(36) - sq(32)) * h * 2
mb = sq(36) * 4 * 2
mr = x * sq(32)
# heights of their respective centres of mass
hc = 4 + h * half
hb = 2
hr = 4 + x * half

# polynomial to solve: sum(m[i] * h[i]) = (x + 4) * sum(m[i])
p = (mc * hc + mb * hb + mr * hr) - (x + 4) * (mc + mb + mr)
p = p.scale()
printf("[p = {p}]")

# find real, positive solutions for p(x) = 0
for x in p.roots(domain='F', include='+'):
  h = 3 * x
  height = h + 4
  printf("height = {height} mm [x={x} h={h}]")
```
    Manually we find the resulting polynomial p(x) factorises as follows:
    
    p(x) = 19x^2 − 648x − 1296
    p(x) = (19x + 36)(x − 36)
    
    From which we see there is a single positive real root that is an integer, and this provides an integer answer to the puzzle.
    
    Or we can use calculus to determine when the minimum height centre of mass occurs:
    
    For a glass with an internal height h and a depth of rum x we can calculate the centre of mass as:
    
    f(x) = (544h(4 + h/2) + 10368 . 2 + 1024x(4 + x/2)) / (544h + 10368 + 1024x)
    f(x) = (17h^2 + 136h + 32x^2 + 256x + 1296) / (34h + 64x + 648)
    
    And we can calculate when the derivative of this function with respect to x is 0, using the quotient rule:
    
    f(x) = p(x) / q(x)
    ⇒
    f'(x) = (p'(x) q(x) − p(x) q'(x)) / q(x)^2
    
    So the minimum value occurs when p’ q = p q’.
    
    In this case:
    
    p(x) = (17h^2 + 136h + 32x^2 + 256x + 1296)
    p'(x) = 64x + 256
    
    q(x) = (34h + 64x + 648)
    q'(x) = 64
    
    (64x + 256)(34h + 64x + 648) = (17h^2 + 136h + 32x^2 + 256x + 1296)(64)
    ⇒
    32x^2 + (648 + 34h)x + (1296 − 17h^2) = 0
    
    And we want to find the minimum value when h = 3x:
    
    32x^2 + (648 + 34 . 3x)x + (1296 − 17 . (3x)^2) = 0
    ⇒
    19x^2 − 648x − 1296 = 0
    (19x + 36)(x − 36) = 0
    ⇒
    x = 36
    h = 108
    
    And the answer to the puzzle follows directly.
    
    LikeLike
Jim Randell 8:32 am on 11 April 2025 Permalink | Reply
Tags: by: Graham Smithers ( 84 )
Teaser 2557: The legacy
From The Sunday Times, 25th September 2011 [link] [link]

In my will I have set aside a five-digit sum of pounds for charity — a group of four animal charities and a group of seven children’s charities. This five-digit sum consists of five consecutive non-zero digits, not in numerical order. On my death this legacy is to be divided equally between these charities. But I have left it to my executors’ discretion to choose to divide it instead equally among the charities in just one of the groups. Each donation will be a whole number of pounds, whichever course they take.

What is the five-digit sum?

[teaser2557]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Frits and Jim Randell are discussing. Toggle Comments
- Jim Randell 8:32 am on 11 April 2025 Permalink | Reply
  The amount must be divisibly by 4, 7, 11, and LCM(4, 7, 11) = 308.
  
  So we are looking for a 5-digit number that is a multiple of 308, and is composed from a set of 5 different non-zero consecutive digits, but not in numerical order.
  
  This Python program looks at 5-digit multiples of 308. It has a runtime of 63ms, and an internal runtime of 1.7ms.
```
from enigma import (irange, mlcm, nsplit, is_consecutive, printf)

# look for 5-digit multiples of 4, 7, 11
k = mlcm(4, 7, 11)
for n in irange.round(10000, 99999, step=k, rnd='I'):
  # split into digits
  ds = nsplit(n)
  # look for consecutive non-zero digits
  if (0 in ds) or is_consecutive(ds) or not is_consecutive(sorted(ds)): continue
  # output solution
  printf("amount = {n}")
```
  But it is slightly faster (but also slightly longer) to start with the possible non-zero consecutive digits, and then consider rearrangements of those digits.
  
  This Python program also runs in 63ms, but has an internal runtime of 784µs.
```
from enigma import (irange, mlcm, tuples, subsets, nconcat, is_consecutive, printf)

# amount must be divisible by 4, 7, 11
k = mlcm(4, 7, 11)

# choose 5 consecutive digits
for ds in tuples(irange(1, 9), 5):
  # consider possible numbers formed from these digits
  for ds in subsets(ds, size=len, select='P'):
    n = nconcat(ds)
    # check divisibility
    if not (n % k == 0): continue
    # check the digits are not consecutive
    if is_consecutive(ds): continue
    # output solution
    printf("amount = {n}")
```
  Solution: The amount is: £ 74536.
  
  £ 74536 = 4× £ 18634
  £ 74536 = 7× £ 10648
  £ 74536 = 11× £ 6776
  
  If a 0 digit is permitted there is a second solution of £ 43120.
  
  LikeLike
- Frits 4:59 pm on 11 April 2025 Permalink | Reply
  Using divisibility rules.
```
from itertools import permutations

# suppose d1 + d3 + d5 = d2 + d4 + k   
# then k % 11 = 0 as legacy is divisible by 11 (alternating sum)
# t = sum(d1...d5) = 2 * (d2 + d4) + k

for i, t in enumerate(range(15, 36, 5), 1):
  # it t odd then k = 11, it t even then k = 0
  k = 11 if t % 2 else 0
  d2d4 = (t - k) // 2
  if d2d4 < 2 * i + 1 or d2d4 > 2 * i + 7: continue
  for d2 in range(i, i + 5):
    d4 = d2d4 - d2
    if d4 == d2 or d4 not in range(i, i + 5): continue
    for d1, d3, d5 in permutations(set(range(i, i + 5)) - {d2, d4}):
      if d5 % 2: continue
      n45 = 10 * d4 + d5
      # divisibility by 4
      if n45 % 4: continue
      # divisibility by 7 rule (alternating sum of blocks of three)
      if (100 * d3 + n45 - 10 * d1 - d2) % 7: continue 

      print("answer:", ''.join(str(x) for x in (d1, d2, d3, d4, d5)))
```
  LikeLike
Jim Randell 8:27 am on 8 April 2025 Permalink | Reply
Tags: by: Robin Nayler ( 16 )
Teaser 2547: Multiple celebration
From The Sunday Times, 17th July 2011 [link] [link]

Today is my birthday and the birthday of my granddaughter Imogen. My age today is a whole-number multiple of hers, and this has been true on one third of our joint anniversaries.

If we both live until I am six times her current age, then my age will be a multiple of hers on two more birthdays.

How old are we today?

[teaser2547]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 8:27 am on 8 April 2025 Permalink | Reply
  This Python program runs in 63ms. (Internal runtime is 139µs).
```
from enigma import (irange, is_divisor, printf)

# find multiple anniversaries for [a, b] and [a+d, b+d]
def multiples(d, a, b):
  for x in irange(a, b):
    y = x + d
    if is_divisor(y, x):
      yield (x, y)

# consider possible ages for the granddaughter (must be a multiple of 3)
for g in irange(3, 20, step=3):
  # consider the setters age (a multiple of g, less than 6g)
  for k in [2, 3, 4, 5]:
    s = k * g

    # calculate earlier multiples
    d = s - g
    ms = list(multiples(d, 1, g))
    # exactly 1/3 of the joint anniversaries so far are multiples
    if not (len(ms) * 3 == g): continue

    # and in there future there will be 2 more multiple anniversaries
    ms_ = list(multiples(d, g + 1, 6 * g - d))
    if not (len(ms_) == 2): continue

    # output solution
    printf("g={g} s={s} [k={k} d={d}] -> {ms} {ms_}")
```
  Solution: The setter is 72. The granddaughter is 18.
  
  So the age difference is 54 years.
  
  The multiples in the past are:
  
  1 year old & 55 years old (multiple = 55)
  2 years old & 56 years old (multiple = 28)
  3 years old & 57 years old (multiple = 19)
  6 years old & 60 years old (multiple = 10)
  9 years old & 63 years old (multiple = 7)
  18 years old & 72 years old (multiple = 4)
  
  Which is 6 anniversaries out of 18, so one third of them are multiples.
  
  In the future (with the setters age up to 6 × 18 = 108) we can have the following multiples:
  
  27 years old & 81 years old (multiple = 3)
  54 years old & 108 years old (multiple = 2)
  
  LikeLike

Jim Randell 7:13 am on 6 April 2025 Permalink | Reply
Tags: by: Victor Bryant ( 144 )

Teaser 3263: Snakes and ladders

From The Sunday Times, 6th April 2025 [link] [link]

My “Snakes and Ladders” board has numbers from 1 to 100 — you throw a die repeatedly and work your way up. There are three “snakes”, each taking you down from one perfect square to another, and three “ladders”, each taking you up from one prime to another. The twelve ends of the snakes and ladders are different two-digit numbers. You must go down a snake if you land on its top-end, and up a ladder if you land on its bottom-end.

For any number from 1 to 6, if I throw that same number repeatedly then I eventually land on 100. The number of throws of 4 needed (with first stops 4, 8, …) is one more than when throwing 5s, which is more than when throwing 3s.

What are the three ladders (in the form “p to q“)?

[teaser3263]

Jim Randell 7:47 am on 6 April 2025 Permalink | Reply

Here is my first go at a solution.

It constructs all possible arrangements of snakes and ladders, and then checks to see if valid sequences of moves can be made. This is quite slow, as although there are only a few possible arrangements for the snakes, there are a lots of possible ladder arrangements to consider.

It runs in 22.8s (using PyPy).

from enigma import (irange, primes, subsets, partitions, update, printf)

# play the game, constantly throwing <d>
# return: <sequence-of-positions> or None
def play(d, m, p=0):
  ps = list()
  while True:
    # move d spaces
    p += d
    # have we hit a special position?
    p = m.get(p, p)
    # have we hit a loop?
    if p in ps: return
    ps.append(p)
    # are we done?
    if p >= 100: return ps

# check map <m> of special positions for a solution
def check(m):
  n = dict()
  for d in [4, 5, 3, 6, 2, 1]:
    # each play eventually gets to 100
    ps = play(d, m)
    if ps is None or ps[-1] != 100: return
    n[d] = ps
    # check n4 = n5 + 1
    if d == 5 and not (len(n[4]) == len(n[5]) + 1): return
    # check n3 < n5
    if d == 3 and not (len(n[3]) < len(n[5])): return
  # return the moves for each die value
  return n

# collect 2-digit squares and primes
sqs = list(i * i for i in irange(4, 9))
prs = list(primes.between(10, 99))

# choose k special positions
def special(ss, k, r, m):
  # choose k positions
  for xs in subsets(ss, size=k):
    # pair them up
    for ps in partitions(xs, 2, distinct=1):
      # add them to the map
      yield update(m, (sorted(pair, reverse=r) for pair in ps))

# choose 6 ends for the snakes (squares) and ladders (primes)
for m0 in special(sqs, 6, 1, dict()):
  for m in special(prs, 6, 0, m0):
    # check for solution
    n = check(m)
    if n:
      # output solution
      for (x, y) in m.items():
        printf("{x} -> {y} {z}", z=("ladder" if x < y else "snake"))
      printf()
      for d in sorted(n.keys()):
        printf("{d} -> {k} throws {v}", k=len(n[d]), v=n[d])
      printf()

Solution: The ladders are: 19 → 97, 29 → 73, 31 → 43.

And the snakes are: 36 → 25, 49 → 16, 81 → 64.

The number of throws for each die value are as follows:

1 = 22 throws
2 = 42 throws
3 = 18 throws
4 = 21 throws
5 = 20 throws
6 = 22 throws

With a standard board layout it looks like this:

(Snakes in red; Ladders in green).

LikeLike

Jim Randell 2:41 pm on 8 April 2025 Permalink | Reply

Here is a faster approach:

This Python 3 program starts by repeatedly throwing a die value and travelling along the board. When it hits a potential “special” square it either allocates a snake/ladder or does nothing, until it completes a sequence that ends on 100. Once this is achieved it takes the partially completed board and then tries another die value, until all values have achieved valid sequences. The completed board (and sequences) are then returned.

It runs in 115ms. (Internal runtime is 40ms).

from enigma import (irange, primes, update, remove, printf)

# collect 2-digit squares and primes
sqs = list(i * i for i in irange(4, 9))
prs = list(primes.between(10, 99))

# play the game, repeatedly throwing <d>
# m = behaviour of positions (src -> tgt)
# p = current position
# ps = previous positions
# sps = positions for snakes
# lps = positions for ladders
# ns = remaining snakes
# nl = remaining ladders
# return updated (m, ps, sps, lps, ns, nl) values
def play(d, m, p, ps, sps, lps, ns, nl):
  # are we done?
  if p >= 100:
    yield (m, ps, sps, lps, ns, nl)
  else:
    # move <d> spaces
    p += d
    x = m.get(p)
    if x is not None:
      # behaviour of position is already allocated
      if x not in ps:
        yield from play(d, m, x, ps + [x], sps, lps, ns, nl)
    else:
      # decide the behaviour of this position, either:

      # -> p is not a special square
      if p not in ps:
        yield from play(d, update(m, [(p, p)]), p, ps + [p], sps, lps, ns, nl)

      # -> p is the bottom of a ladder
      if nl > 0 and p in lps:
        # move to a higher ladder position
        for x in lps:
          if not (x > p): continue
          if x not in ps:
            yield from play(d, update(m, [(p, x)]), x, ps + [x], sps, remove(lps, p, x), ns, nl - 1)

      # -> p is the top of a snake
      if ns > 0 and p in sps:
        # move to a lower snake position
        for x in sps:
          if not (x < p): break
          if x not in ps:
            yield from play(d, update(m, [(p, x)]), x, ps + [x], remove(sps, p, x), lps, ns - 1, nl)

# solve the puzzle for repeated throws in <ds>
# m = behaviour of positions (src -> tgt)
# sps = positions for snakes
# lps = positions for ladders
# ns = remaining snakes
# nl = remaining ladders
# ss = sequences recorded
# return (m, ss)
def solve(ds, m, sps, lps, ns, nl, ss=dict()):
  # are we done?
  if not ds:
    yield (m, ss)
  else:
    # try the next sequence
    d = ds[0]
    for (m_, ps_, sps_, lps_, ns_, nl_) in play(d, m, 0, [], sps, lps, ns, nl):
      # check the sequence ends on 100
      if not (ps_[-1] == 100): continue
      ss_ = update(ss, [(d, ps_)])
      # check n4 = n5 + 1
      if d == 4 or d == 5:
        (ss4, ss5) = (ss_.get(4), ss_.get(5))
        if ss4 and ss5 and not (len(ss4) == len(ss5) + 1): continue
      # check n3 < n5
      if d == 3 or d == 5:
        (ss3, ss5) = (ss_.get(3), ss_.get(5))
        if ss3 and ss5 and not (len(ss3) < len(ss5)): continue
      # solve for the remaining sequences
      yield from solve(ds[1:], m_, sps_, lps_, ns_, nl_, ss_)

# solve for repeated throws 1 - 6, with 3 snakes on squares, 3 ladders on primes
for (m, ss) in solve([6, 5, 4, 3, 2, 1], dict(), sqs, prs, 3, 3):
  # output layout
  for s in sorted(m.keys()):
    t = m[s]
    if s < t: printf("{s} -> {t} ladder")
    if s > t: printf("{s} -> {t} snake")
  printf()
  # output sequences
  for d in sorted(ss.keys()):
    ts = ss[d]
    printf("{d} -> {n} throws {ts}", n=len(ts))
  printf()

LikeLike

Frits 6:25 pm on 7 April 2025 Permalink | Reply

Similar to Jim’s program.

It runs under 10 seconds (using PyPy).

# -------------------------------- start Jim Randell ------------------------
# play the game starting with list <lst>, constantly throwing <d>
# return: <sequence-of-positions> or None
def play(d, m, lst):
  ps = list(lst)
  p = lst[-1]
  while True:
    # move d spaces
    p += d
    # have we hit a special position?
    p = m.get(p, p)
    # have we hit a loop?
    if p in ps: return
    ps.append(p)
    # are we done?
    if p >= 100: return ps    

# check map <m> of special positions for a solution
def check_sol(m):
  n = dict()
  for d in [4, 5, 3, 6, 2, 1]:
    # each play eventually gets to 100
    ps = play(d, m, f_lst[d])
    if ps is None or ps[-1] != 100: return
    n[d] = ps
    # check n4 = n5 + 1
    if d == 5 and not (len(n[4]) == len(n[5]) + 1): return
    # check n3 < n5
    if d == 3 and not (len(n[3]) < len(n[5])): return
  # return the moves for each die value
  return n
# -------------------------------- end Jim Randell --------------------------
  
prms = [x for x in range(11, 100, 2) if all(x % p for p in [3, 5, 7])]
sqs = [i * i for i in range(4, 10)]  # 2-digit squares
spec = prms + sqs

# mandatory first numbers 
f_lst = {n: list(range(n, next(x for x in range(n, 100, n) if x in spec and 
                  x not in {sqs[0], prms[-1]}), n)) for n in range(1, 7)}

# generate all possible combinations of 3 ladders
ladders = []
inds = {x: i for i, x in enumerate(prms)}
for P in prms[:-3]:
  for Q in prms[inds[P] + 1:]:
   
    for R in prms[inds[P] + 1:-2]:
      if R == Q: continue
      for S in prms[inds[R] + 1:]:
        if S == Q: continue
        
        for T in prms[inds[R] + 1:-1]:
          if T in {Q, S}: continue
          for U in prms[inds[T] + 1:]:
            if U in {Q, S}: continue
            ladders.append((P, Q, R, S, T, U))
        
# generate all possible combinations of 3 snakes
for a in range(5, 9):
  A = a * a
  for b in range(4, a):
    B = b * b
    for c in range(a + 1, 9):
      C = c * c
      for d in range(4, c):
        if d in {a, b}: continue
        D = d * d
        e = 9
        E = e * e
        f = 39 - a - b - c - d - e
        if f in {a, b, c, d}: continue
        F = f * f
        # create snake dictionary
        d = {A: B, C: D, E: F}
        for lddr in ladders:
          d_ = d.copy()
          # add ladder data to dictionary
          d_.update({lddr[i]: lddr[i + 1] for i in range(0, 6, 2)})
          # check for solution 
          if (n := check_sol(d_)) is None: continue
          print("answer:", *[lddr[i:i+2] for i in range(0, 6, 2)])

LikeLike

Frits 7:13 pm on 8 April 2025 Permalink | Reply

New approach, again without using analysis.
The main line can probably done with recursion but I didn’t feel like doing that.

It run in approx. 18ms (using Cpython).

prms = [x for x in range(11, 100, 2) if all(x % p for p in [3, 5, 7])]
sqs = [i * i for i in range(4, 10)]  # 2-digit squares
spec = prms + sqs

# dictionary of mandatory last numbers 
dlast = {n: tuple(range(next(x for x in range(100 - n, 0, -n) if x in spec and 
            x not in {sqs[-1], prms[0]}), 100 + n, n)) for n in range(1, 7)}

# dictionary of mandatory first numbers
dfirst = {n: tuple(range(n, next(x for x in range(n, 100, n) if x in spec and 
                   x not in {sqs[0], prms[-1]}), n)) for n in range(1, 7)}

# go from number <a> to <b> by adding a maximum of <k> board numbers
# between <a> and <b> with standard throws <m> and <kn> = known snakes/ladders
def solve(m, a, b, k, ns=0, nl=0, kn=set(), ss=[], new=set()):
  tst = (11, 83) in kn | new
  # <k> fields cause <k + 1> moves
  if k == -1 or a == b:
    if a == b:
      yield len(ss) - 1, kn | new, ns, nl
  else:
    # new number may not have been seen before
    if (n := a + m) in ss or n > 100: return
    # try standard throw if not on a kn snake of ladder 
    if n not in {x for x, y in kn}:
      yield from solve(m, n, b, k - 1, ns, nl, kn, ss + [n], new)
    
    # try to add a snake  
    if n in sqs:
      for s in sqs:
        if s == n: break 
        # do checks for new snake
        if (n, s) not in kn:
          if ns > 2 or not set(sum(kn | new, ())).isdisjoint({n, s}):
            continue
          ns_ = ns + 1
        else:
          ns_ = ns
        yield from solve(m, s, b, k - 1, ns_, nl, kn, ss + [s], new | {(n, s)})
    # try to add a ladder
    if n in prms:
      for p in prms[::-1]:
        if p == n: break 
        # do checks for new ladder
        if (n, p) not in kn:
          if nl > 2 or not set(sum(kn | new, ())).isdisjoint({n, p}):
            continue
          nl_ = nl + 1
        else:
          nl_ = nl  
        yield from solve(m, p, b, k - 1, ns, nl_, kn, ss + [p], new | {(n, p)})

def six_throws(seq, ln5=0, ns=0, nl=0, kn=set(), ss=[]):
  if not seq:
    if len(kn) == 6:
      yield kn
  else:
    m = seq[0]
    mx = (107 if m not in {3, 4} else
          ln5 + (2 * m - 7) - len(dfirst[m]) - len(dlast[m]))
    
    for ln, kn_, ns_, nl_ in solve(m, dfirst[m][-1], dlast[m][0], 
                                   mx, ns, nl, kn):
      if m == 4: # check requirement
        if len(dfirst[m]) + len(dlast[m]) + ln != ln5 + 1: continue
        
      if m == 5: # save number of throws of 5 needed
        ln5 = len(dfirst[m]) + len(dlast[m]) + ln
      
      yield from six_throws(seq[1:], ln5 , ns_, nl_, kn_, ss)
        
# perform 2 passes as some ordr's generate incorrect solutions
ordr = (5, 4, 3, 6, 2, 1)  # one of the most efficient orders
# 1st pass: start with no known snakes and ladders
for p1 in six_throws(ordr):
  # 2nd pass: check again with a full set of snakes and ladders
  sols = []
  for p2 in six_throws(ordr, 0, 3, 3, p1):
    if p2 not in sols:
      if p1 != p2: 
        print("ERROR")
        exit(0)
      sols.append(p2) 
      
for s in sols:
  print("answer:", *[(x, y) for x, y in sorted(s) if x not in sqs])

LikeLike

Jim Randell 10:30 am on 4 April 2025 Permalink | Reply
Tags: by: C Higgins ( 37 ), by: H Bradley ( 37 )
Teaser 2558: Round table
From The Sunday Times, 2nd October 2011 [link] [link]

Pat likes to demonstrate his favourite trick shot on the pub pool table, which is 90 inches long and 48 inches wide. Pat hits the ball so that it strikes the long side of the table first, then (after a perfect bounce) it hits the short side, then the other long side, and then finally the other short side, from which it returns to the starting point, making its path the perimeter of a quadrilateral.

What is the length of the perimeter of that quadrilateral?

[teaser2558]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 10:31 am on 4 April 2025 Permalink | Reply
  (See also: Teaser 3184, Teaser 3073, Teaser 1917).
  
  Wherever the ball starts tracing out the quadrilateral, we can consider its movement in the x and y directions.
  
  In the x direction it travels to the cushion on one end, back to the other cushion, and then returns to its original position.
  
  i.e. the total distance travelled in the x direction is twice the length of the table (= 2 × 90 in = 180 in).
  
  Similarly the distance travelled in the y direction is twice the width of the table (= 2 × 48 in = 96 in).
  
  Hence the total distance travelled by the ball is: hypot(180, 96):
```
>>> hypot(180, 96)
204.0
```
  Solution: The length of the perimeter of the quadrilateral is 204 in.
  
  LikeLike

Jim Randell 8:59 am on 2 April 2025 Permalink | Reply
Tags: by: Nick MacKinnon ( 56 )

Teaser 2561: Winning the double

From The Sunday Times, 23rd October 2011 [link] [link]

Four teams, A, B, C and D, played each other once in a league, then played a knockout competition. They scored a total of 54 goals in the nine games, with a different score in each game; no team scored more than five goals in any game. For each team the average number of goals per game was a different whole number. Team B beat D by a margin of more than one goal in the knockout competition, but team A took the double, winning all their games.

What was the score in the match CvD?

[teaser2561]

Jim Randell 9:00 am on 2 April 2025 Permalink | Reply
In the tournament the 6 matches are:

AvB, AvC, AvD, BvC, BvD, CvD

In the knockout there is a BvD match (which B won), but A won the knockout. So the matches in the knockout must be:

1st round: AvC (A wins); BvD (B wins)
Final: AvB (A wins)

So A and B have played 5 matches, and C and D have played 4.

A won all their matches, so their goal average must be at least 3.

B won at least one match, so their goal average must be at least 1.

The following run file finds possible scorelines in each match. It isn’t very fast though, but it does run in 10.3s under PyPy.
```
#! python3 -m enigma -rr

SubstitutedExpression

# tournament:
#
#     A B C D
#  A: - H I J  (A wins all matches)
#  B: K - L M
#  C: N P - Q
#  D: R S T -
#
# knockout:
#
#  round 1: A v C = U - V (A wins); B v D = W - X (B wins)
#  final: A v B = Y - Z (A wins)
#
# no team scored more than 5 goals, so goals (and goal averages = A, B, C, D) are all 0-5
--base=6  # allows digits 0-5
--distinct="ABCD"  # goal averages are all different

# total goals scored by each team
--macro="@goalsA = (H + I + J + U + Y)"
--macro="@goalsB = (K + L + M + W + Z)"
--macro="@goalsC = (N + P + Q + V)"
--macro="@goalsD = (R + S + T + X)"

# total of all the goals scored is 54
"@goalsA + @goalsB + @goalsC + @goalsD == 54"

# each game has a different score line
"seq_all_different(ordered(x, y) for (x, y) in zip([H, I, J, L, M, Q, U, W, Y], [K, N, R, P, S, T, V, X, Z]))"

# goal averages (are all different by --distinct)
"A * 5 == @goalsA"
"B * 5 == @goalsB"
"C * 4 == @goalsC"
"D * 4 == @goalsD"
"A > 2"  # A won all their matches
"B > 0"  # B won at least one match
# and the total of all goals scored is 54
"5 * (A + B) + 4 * (C + D) == 54"

# B beat D by more than 1 goal in the knockout
"W > X + 1"

# A won all their games
"H > K" "I > N" "J > R" "U > V" "Y > Z"

--template="(H-K I-N J-R L-P M-S Q-T) (U-V W-X; Y-Z) (A B C D)"
--header="(AvB AvC AvD BvC BvD CvD) (AvC BvD; AvB) (A B C D)"
--solution=""
--answer="(Q, T)"  # answer is the score in C vs D match
--denest=-1  # CPython workaround
```
Solution: The score in the C vs D match was 5 – 5.

The program finds 48 ways to assign the scores in each match.

For example, one of the assignments is:

Tournament:
A vs B = 5-1
A vs C = 5-3
A vs D = 5-0
B vs C = 0-4
B vs D = 0-3
C vs D = 5-5

Knockout:
A vs C = 5-4
B vs D = 2-0
A vs B = 5-2

A wins all their matches by scoring 5 goals, so their goal average is 5. And the goal averages for B, C, D are B = 1 (from 5 goals), C = 4 (from 16 goals), D = 2 (from 8 goals).

LikeLike
- Frits 1:20 pm on 2 April 2025 Permalink | Reply
  
  @Jim, typo in line 48: “J > R”.
  It makes the program slower (and 48 ways to assign the scores in each match)
  
  LikeLike
  - Jim Randell 1:35 pm on 2 April 2025 Permalink | Reply
    
    @Frits: Thanks. Fixed now.
    
    LikeLike
- Frits 2:17 pm on 2 April 2025 Permalink | Reply
  Easy performance enhancement (from Brian’s analysis):
```
--invalid="5,BCD"  # teams other than A cannot score 5 goals in all their games
```
  LikeLike
  - Jim Randell 2:27 pm on 2 April 2025 Permalink | Reply
    Yes. With a little analysis there are some easy additional restrictions we can deduce.
    
    These bring the run time down to a much more reasonable 196ms.
```
# more restrictions we can deduce
--invalid="0,ABHIJUWY"
--invalid="1,AW"
--invalid="2,A"
--invalid="4,X"
--invalid="5,BCDKNRVXZ"
```
    And with more analysis we can go further. But I prefer to let the computer do the majority of the work.
    
    LikeLike

Frits 1:15 pm on 3 April 2025 Permalink | Reply

The program loops over the requested score so we can early return as soon as a solution is found (and not report 47 similar solutions).

The runtime approaches the 10 ms with CPython (as is feasible for most teasers).

from itertools import product

# Analysis: (credit B. Gladman)

# If the average goals per game for A, B, C, D are a, b, c and d we then have
#
#     54 == 5.(a + b) + 4.(c + d) 
#
# (since A and B play five games whereas C and D play four). Here the possible
# solutions (a + b, c + d) = (10, 1), (6, 6) or (2, 11).
 
# Since the maximum goals a team can score in any game is 5, all the averages
# are five or less. And, since the averages are all different, a + b and c + d
# are both less than 10 which means that a + b == c + d == 6. Moreover, since
# A wins all their games, other teams cannot score 5 goals in all their games
# and must have goals per match averages of less than five.
#
# Hence the possibilities are:
#
#      (a, b) = (5, 1), (4, 2), (2, 4)
#      (c, d) = (4, 2), (2, 4)
#
# And since the values are all different 
#
#      (a, b, c, d) =  (5, 1, 4, 2) or (5, 1, 2, 4)
#
#
# Hence in goal totals (A, B, C, D) = (25, 5, 16, 8) or (25, 5, 8, 16)

(H, I, J, U, Y, A, B) = (5, 5, 5, 5, 5, 5, 1)

# tournament:
#
#     A B C D
#  A: - H I J  (A wins all matches)
#  B: K - L M
#  C: N P - Q
#  D: R S T -
#
# knockout:
#
#  round 1: A v C = U - V (A wins); B v D = W - X (B wins)
#  final: A v B = Y - Z (A wins)
#

def inner(Q, T):
  for C in [2, 4]:
    D = 6 - C
    # A wins all their games with 5 goals  
    if 5 in {Q, T} and (Q, T) != (5, 5): continue
    for X in range(3):                        # X != 3 as W < 5
      for W in range(X + 2, 5):               # B beat D by more than one goal
        for R in range(5):
          S = D * 4 - (R + T + X)             # team D
          if not (0 <= S <= 4): continue      # S != 5 as M <= 3
          for V in range(5):                  # as W >= 2 then K,L,M,Z <= 3
            if V == R: continue
            for N in range(5):
              if N in {V, R}: continue
              P = C * 4 - (N + Q + V)         # team C
              if not (0 <= P <= 4): continue  # P != 5 als L <= 3
              # as W >= 2 then K,L,M,Z <= 3
              for L, M in product(range(4), repeat=2): 
                # different games
                if (len(set(s := list(zip([L, M, Q, W], [P, S, T, X])))) !=
                    len(s)): continue
                for Z in range(4):            # as W >= 2 then K,L,M,Z <= 3
                  if Z in {V, R, N}: continue
                  K = B * 5 - (L + M + W + Z) # team B
                  if not (0 <= K <= 3) or K in {V, R, N, Z}: continue
                  if H+I+J+K+L+M+N+P+Q+R+S+T+U+V+W+X+Y+Z != 54: continue
                  return str((Q, T))

sols = []
# Process scores CvD  (Q, T)
for C, D in product(range(6), repeat=2):
  if (s := inner(C, D)):
    sols.append(s)

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

LikeLike

Frits 6:20 pm on 3 April 2025 Permalink | Reply

Another one using more analysis. Internal runtime 22 microseconds (under PyPy).

from itertools import product, permutations

stup = lambda x, y: (x, y) if x < y else (y, x)
  
def diffgames(a, b):
  return len(set(s := list(stup(x, y) for x, y in zip(a, b)))) == len(s)
  
# Analysis: (credit B. Gladman)

# If the average goals per game for A, B, C, D are a, b, c and d we then have
#
#     54 == 5.(a + b) + 4.(c + d) 
#
# (since A and B play five games whereas C and D play four). Here the possible
# solutions (a + b, c + d) = (10, 1), (6, 6) or (2, 11).
 
# Since the maximum goals a team can score in any game is 5, all the averages
# are five or less. And, since the averages are all different, a + b and c + d
# are both less than 10 which means that a + b == c + d == 6. Moreover, since
# A wins all their games, other teams cannot score 5 goals in all their games
# and must have goals per match averages of less thsn five.
#
# Hence the possibilities are:
#
#      (a, b) = (5, 1), (4, 2), (2, 4)
#      (c, d) = (4, 2), (2, 4)
#
# And since the values are all different 
#
#      (a, b, c, d) =  (5, 1, 4, 2) or (5, 1, 2, 4)
#
#
# Hence in goal totals (A, B, C, D) = (25, 5, 16, 8) or (25, 5, 8, 16)
#
#
# In the knockout 1st round game BvD team B can score a maximum of 4 goals
# and we have B - D >= 2. Team D can only score a maximum of 2 goals in this 
# knockout round.
# This means the average of team D cannot be 4 (as it would require at least 
# 2 wins with 5 goals). So the averages of team C and D are 2 resp. 4.
# In all games of team C they score at least 3 goals.

(H, I, J, U, Y, A, B, C, D) = (5, 5, 5, 5, 5, 5, 1, 4, 2)
(B5, C4, D4) = (5 * B, 4 * C, 4 * D)

# tournament:
#
#     A B C D
#  A: - H I J  (A wins all matches)
#  B: K - L M
#  C: N P - Q
#  D: R S T -
#
# knockout:
#
#  round 1: A v C = U - V (A wins); B v D = W - X (B wins)
#  final: A v B = Y - Z (A wins)
#

# inner loops
def inner(Q, T):
  # team A wins all their games scoring 5 goals in each game
  if 5 in {Q, T} and (Q, T) != (5, 5): return
  for X in range(3):                      # X != 3 as W < 5
    for R in range(3):                    # as N and V (team C) use 3 and 4
      S = D4 - (R + T + X)             # team D
      if not (0 <= S <= 4): continue      # S != 5 as M <= 3
      for N, V in permutations(range(3, 5), 2): # team C goals
        P = C4 - (N + Q + V)           # team C
        if not (3 <= P <= 4): continue    # P != 5 als L <= 3
        for W in range(X + 2, 5):         # B beat D by more than one goal
          # K + N + R + V + Z = 10  and  K + L + M + W + Z = 5
          for L in range((LM := (V + N + R) - W - 5) + 1):       
            M = LM - L
            
            # different games
            if not diffgames([L, M, Q, W], [P, S, T, X]): continue

            for Z in range(6 - W - L - M):  # K,L,M,Z <= 3 as W >= 2
              if Z in {V, R, N}: continue
              K = B5 - (L + M + W + Z) # team B
              if not (0 <= K <= 3) or K in {V, R, N, Z}: continue

              if H+I+J+K+L+M+N+P+Q+R+S+T+U+V+W+X+Y+Z != 54: continue
              return str((Q, T))

sols = []
# process scores CvD, team C scores at least 3 goals in each game
for Q, T in product(range(3, 6), range(6)):
  if (s := inner(Q, T)):
    sols.append(s)

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

LikeLike

Jim Randell 2:42 am on 30 March 2025 Permalink | Reply
Tags: by: John Owen ( 33 )
Teaser 3262: Log cabins
From The Sunday Times, 30th March 2025 [link] [link]

Ann, Bert, Chloe and Dave own log cabins on the shore of a circular lake. Ann often rows across the lake (in a straight line) to visit Bert, and vice-versa. Chloe and Dave also visit each other in the same way.

The two routes cross in the lake at point X. Interestingly, the four distances from the log cabins to X are all whole numbers of metres (greater than 20m), but the list of distances contains no digit more than once. Chloe’s distance from her log cabin to X is twice Ann’s, while Bert’s distance is three times Ann’s.

In ascending order, what are the four distances from the log cabins to X?

[teaser3262]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 3:10 am on 30 March 2025 Permalink | Reply
  The cabins form a cyclic quadrilateral [ @wikipedia ].
  
  And if we denote the distances AX = a, BX = b, CX = c, DX = d. Then we have:
  
  a . b = c . d
  
  This is the intersecting chords theorem [ @wikipedia ].
  
  So:
  
  b = 3a
  c = 2a
  ⇒
  d = 3a/2
  
  Hence a must be even.
  
  The following Python program runs in 67ms. (Internal runtime is 106µs).
```
from enigma import (irange, inf, ediv, ordered, join, printf)

# consider distance AX = a (must be even)
for a in irange(22, inf, step=2):
  # BX = b = 3a, CX = c = 2a, DX = d = 3a/2
  (b, c, d) = (3 * a, 2 * a, ediv(3 * a, 2))
  ds = ordered(a, b, c, d)
  s = join(ds)
  # between them they use no digit more than once
  if len(s) > 10: break
  if len(s) != len(set(s)): continue
  # output solution
  printf("{ds} [a={a} b={b} c={c} d={d}]")
```
  Solution: The distances are: 36, 54, 72, 108 metres.
  
  a = 36
  b = 108
  c = 72
  d = 54
  and:
  a . b = c . d = 3888
  
  Manually we can follow a similar approach, considering even values for a starting at 22, until a solution is found:
  
  a = 22; repeated digits
  a = 24; b = 72; repeated digits
  a = 26; b = 78; c = 52; repeated digits
  a = 28; b = 84; repeated digits
  a = 30; b = 90; repeated digits
  a = 32; b = 96; c = 64; repeated digits
  a = 34; b = 102; c = 68; d = 51; repeated digits
  a = 36; b = 108; c = 72; d = 54; solution found
  
  For an exhaustive solution it is sufficient to check a ≤ 66 beyond which the distances use more than 10 digits, so there will always be duplication of digits. But there are no further solutions.
  
  LikeLike

Jim Randell 3:50 pm on 28 March 2025 Permalink | Reply
Tags: by: Andrew Skidmore ( 87 )

Teaser 2563: Prime time

From The Sunday Times, 6th November 2011 [link] [link]

In this addition sum I have consistently replaced digits by letters, with different letters for different digits, and I have ended up with another correct addition sum.

What is the prime number NOW?

[teaser2563]

Jim Randell 3:51 pm on 28 March 2025 Permalink | Reply
We can use the [[ SubstitutedExpression.split_sum ]] solver from the enigma.py library to solve this puzzle.

The following run file executes in 77ms. (Internal runtime of the generated code is 110µs).
```
#! python3 -m enigma -rr

SubstitutedExpression.split_sum

"ONE + TWO + FIVE = EIGHT"

--extra="is_prime(NOW)"
--answer="NOW"
```
Solution: NOW = 467.

LikeLike

Ruud 9:17 am on 29 March 2025 Permalink | Reply

import istr


for o, n, e, t, w, f, i, v, g, h in istr.permutations(range(10)):
    if (o | n | e) + (t | w | o) + (f | i | v | e) == (e | i | g | h | t) and (n | o | w).is_prime():
        print("now =", n | o | w)

LikeLike

GeoffR 10:12 am on 29 March 2025 Permalink | Reply


% A Solution in MiniZinc
include "globals.mzn";

%      O N E
%      T W O
%    F I V E
%  ---------
%  E I G H T
%  ---------
%     c3c2c1
 
var 1..9:O; var 1..9:N; var 1..9:E; var 1..9:T; var 0..9:W; 
var 1..9:F; var 0..9:I; var 0..9:V; var 0..9:G; var 0..9:H;
var 0..2:c1; var 0..2:c2; var 0..2:c3;
var 100..999:NOW = 100*N + 10*O + W;

constraint E == 1;

constraint all_different([O, N, E, T, W, F, I, V, G, H]);

predicate is_prime(var int: x) = 
x > 1 /\ forall(i in 2..1 + ceil(sqrt(int2float(ub(x))))) 
((i < x) -> (x mod i > 0));

constraint (E + O + E ) mod 10 == T 
/\ (E + O + E) div 10 == c1;

constraint (N + W + V + c1) mod 10 == H 
/\ (N + W + V + c1) div 10 == c2;

constraint (O + T + I + c2) mod 10 == G 
/\ (O + T + I + c2) div 10 == c3;

constraint (F + c3) mod 10 == I /\ (F + c3) div 10 == E; 

constraint is_prime(NOW);

solve satisfy;
output[ "NOW = " ++ show(NOW)];

% NOW = 467
% ----------
% ==========

LikeLike

Jim Randell 8:39 am on 25 March 2025 Permalink | Reply
Tags: by: Victor Bryant ( 144 )
Teaser 2559: Inconsequential
From The Sunday Times, 9th October 2011 [link] [link]

Most whole numbers can be expressed as the sum of two or more consecutive whole numbers. For example:

35 = 17 + 18
36 = 11 + 12 + 13
40 = 6 + 7 + 8 + 9 + 10

I have written down two whole numbers. Between them they use each of the digits 0 to 9 exactly once. But neither of the numbers can be expressed as the sum of two or more consecutive whole numbers.

What are my two numbers?

[teaser2559]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 8:39 am on 25 March 2025 Permalink | Reply
  I am assuming that by “whole numbers” the setter means the positive integers.
  
  We have encountered the polite numbers [@wikipedia] before, see: BrainTwister #43, Enigma 776, Teaser 2994, Enigma 914, Enigma 1231, Enigma 1.
  
  The “impolite” numbers are the powers of 2, so we need to find two powers of 2 that between them use each of the 10 digits exactly once.
  
  This Python program runs in 62ms. (Internal runtime is 134µs).
```
from enigma import (distinct_chars, printf)

# record powers of 2 (as strings)
ps = list()
n = 1
while True:
  s = str(n)
  if len(s) > 9: break
  # look for a pair that use all 10 digits between them
  for x in ps:
    if distinct_chars(x, s) == 10:
      printf("{x}, {n}")
  ps.append(s)
  n *= 2
```
  Solution: The numbers are: 4, 536870912.
  
  Where:
  
  2^2 = 4
  2^29 = 536870912
  
  LikeLike

	Jim Randell on Teaser 2438: [Nested quad…
	Jim Randell on Teaser 2438: [Nested quad…
	Jim Randell on Teaser 3315: Primal screa…
	Ruud on Teaser 3315: Primal screa…
	Frits on Teaser 3315: Primal screa…
	Ruud on Teaser 3315: Primal screa…
	Jim Randell on Teaser 3315: Primal screa…
	Jim Randell on Teaser 2443: [Phone masts…

Search

Recent Posts

Recent Comments

Archives

Categories

Subscribe

RSS Links

Site Stats

Meta

Recent Updates Page 8 Toggle Comment Threads | Keyboard Shortcuts

Jim Randell 8:13 am on 9 May 2025 Permalink | Reply Tags: by: Danny Roth ( 87 )

Rate this:

Share:

Jim Randell 8:14 am on 9 May 2025 Permalink | Reply

Frits 3:31 pm on 9 May 2025 Permalink | Reply

Jim Randell 4:19 pm on 9 May 2025 Permalink | Reply

Frits 3:18 pm on 10 May 2025 Permalink | Reply

Jim Randell 8:33 am on 10 May 2025 Permalink | Reply

Ruud 3:01 pm on 9 May 2025 Permalink | Reply

Frits 4:09 pm on 9 May 2025 Permalink | Reply

ruudvanderham 1:16 pm on 10 May 2025 Permalink | Reply

Reply Cancel reply

Jim Randell 9:42 am on 6 May 2025 Permalink | Reply Tags: by: Danny Roth ( 87 )

Rate this:

Share:

Jim Randell 9:42 am on 6 May 2025 Permalink | Reply

Frits 12:39 pm on 8 May 2025 Permalink | Reply

Jim Randell 7:14 am on 4 May 2025 Permalink | Reply Tags: by: Victor Bryant ( 144 )

Rate this:

Share:

Jim Randell 8:57 am on 4 May 2025 Permalink | Reply

Frits 4:37 pm on 4 May 2025 Permalink | Reply

Frits 6:48 pm on 4 May 2025 Permalink | Reply

Jim Randell 7:37 am on 1 May 2025 Permalink | Reply Tags: by: Graham Smithers ( 84 )

Rate this:

Share:

Jim Randell 7:37 am on 1 May 2025 Permalink | Reply

Frits 6:06 pm on 1 May 2025 Permalink | Reply

Jim Randell 8:04 am on 29 April 2025 Permalink | Reply Tags: by: C Higgins ( 37 ), by: H Bradley ( 37 )

Rate this:

Share:

Jim Randell 8:04 am on 29 April 2025 Permalink | Reply

Frits 12:32 pm on 30 April 2025 Permalink | Reply

Jim Randell 6:41 am on 27 April 2025 Permalink | Reply Tags: by: Colin Vout ( 38 )

Rate this:

Share:

Jim Randell 8:08 am on 27 April 2025 Permalink | Reply

Jim Randell 12:06 pm on 4 May 2025 Permalink | Reply

Pete Good 2:57 pm on 30 April 2025 Permalink | Reply

Jim Randell 3:02 pm on 30 April 2025 Permalink | Reply

Jim Randell 6:45 am on 24 April 2025 Permalink | Reply Tags: by: Bob Walker ( 10 )

Rate this:

Share:

Jim Randell 6:46 am on 24 April 2025 Permalink | Reply

Ruud 6:14 am on 28 April 2025 Permalink | Reply

Frits 10:51 am on 26 April 2025 Permalink | Reply

Jim Randell 8:18 am on 22 April 2025 Permalink | Reply Tags: by: Graham Smithers ( 84 )

Rate this:

Share:

Jim Randell 8:19 am on 22 April 2025 Permalink | Reply

Frits 3:35 pm on 22 April 2025 Permalink | Reply

Jim Randell 6:59 am on 20 April 2025 Permalink | Reply Tags: by: Andrew Skidmore ( 87 )

Rate this:

Share:

Jim Randell 7:49 am on 20 April 2025 Permalink | Reply

Frits 1:49 pm on 20 April 2025 Permalink | Reply

Jim Randell 10:08 am on 17 April 2025 Permalink | Reply Tags: by: Andrew Skidmore ( 87 )

Rate this:

Share:

Jim Randell 10:08 am on 17 April 2025 Permalink | Reply

Jim Randell 9:06 am on 15 April 2025 Permalink | Reply Tags: by: W A Thatcher ( 13 )

Rate this:

Share:

Jim Randell 9:08 am on 15 April 2025 Permalink | Reply

Frits 12:19 pm on 17 April 2025 Permalink | Reply

Jim Randell 2:39 pm on 17 April 2025 Permalink | Reply

Frits 12:08 pm on 17 April 2025 Permalink | Reply

Frits 12:41 pm on 17 April 2025 Permalink | Reply

Jim Randell 6:53 am on 13 April 2025 Permalink | Reply Tags: by: Mark Valentine ( 17 )

Rate this:

Jim Randell 8:13 am on 9 May 2025 Permalink | Reply
Tags: by: Danny Roth ( 87 )

Jim Randell 9:42 am on 6 May 2025 Permalink | Reply
Tags: by: Danny Roth ( 87 )

Jim Randell 7:14 am on 4 May 2025 Permalink | Reply
Tags: by: Victor Bryant ( 144 )

Jim Randell 7:37 am on 1 May 2025 Permalink | Reply
Tags: by: Graham Smithers ( 84 )

Jim Randell 8:04 am on 29 April 2025 Permalink | Reply
Tags: by: C Higgins ( 37 ), by: H Bradley ( 37 )

Jim Randell 6:41 am on 27 April 2025 Permalink | Reply
Tags: by: Colin Vout ( 38 )

Jim Randell 6:45 am on 24 April 2025 Permalink | Reply
Tags: by: Bob Walker ( 10 )

Jim Randell 8:18 am on 22 April 2025 Permalink | Reply
Tags: by: Graham Smithers ( 84 )

Jim Randell 6:59 am on 20 April 2025 Permalink | Reply
Tags: by: Andrew Skidmore ( 87 )

Jim Randell 10:08 am on 17 April 2025 Permalink | Reply
Tags: by: Andrew Skidmore ( 87 )

Jim Randell 9:06 am on 15 April 2025 Permalink | Reply
Tags: by: W A Thatcher ( 13 )

Jim Randell 6:53 am on 13 April 2025 Permalink | Reply
Tags: by: Mark Valentine ( 17 )

Jim Randell 8:32 am on 11 April 2025 Permalink | Reply
Tags: by: Graham Smithers ( 84 )

Jim Randell 8:27 am on 8 April 2025 Permalink | Reply
Tags: by: Robin Nayler ( 16 )

Jim Randell 7:13 am on 6 April 2025 Permalink | Reply
Tags: by: Victor Bryant ( 144 )

Jim Randell 10:30 am on 4 April 2025 Permalink | Reply
Tags: by: C Higgins ( 37 ), by: H Bradley ( 37 )

Jim Randell 8:59 am on 2 April 2025 Permalink | Reply
Tags: by: Nick MacKinnon ( 56 )

Jim Randell 2:42 am on 30 March 2025 Permalink | Reply
Tags: by: John Owen ( 33 )

Jim Randell 3:50 pm on 28 March 2025 Permalink | Reply
Tags: by: Andrew Skidmore ( 87 )

Jim Randell 8:39 am on 25 March 2025 Permalink | Reply
Tags: by: Victor Bryant ( 144 )