Sunday Times Teaser 3260 – Alphabet Soup

by BRG on 16 March 2025

by Peter Good

Published Sunday March 16 2025 (link)

Clark had four dice with each of the 24 faces containing a different letter of the alphabet. Up to four could be rotated then placed side by side to spell out words on the topmost faces. Clark could spell out any of the words in just one of the following sayings:

“Don’t rock the boat”, “Easy come, easy go”, “Give a dog a bad name”, “If the cap fits wear it”, “Life is what you make it”, “Make love not war”, “You reap what you sow”, “If you can’t beat them join them”, “Don’t bury your head in the sand”, and “Time and tide wait for no man”.

It was impossible to have any arrangement of 24 letters that could spell the words in this saying but also spell the words in one of the others.

Which saying was Clark able to spell out?

From → Uncategorized

4 Comments Leave one →

BRG permalink

from itertools import combinations, permutations

phrases = [p.split() for p in [
  'Don’t rock the boat',
  'Easy come, easy go',
  'Give a dog a bad name',
  'If the cap fits wear it',
  'Life is what you make it',
  'Make love not war',
  'You reap what you sow',
  'If you can’t beat them join them',
  'Don’t bury your head in the sand', 
  'Time and tide wait for no man']]

# simplify the phrases, store the words in phrases in inverse
# length order and the phrases in number of words order 
phrases = [(sorted(set(''.join(c.lower() for c in word if c.isalpha())
    for word in phr), key=lambda x: -len(x)), ' '.join(phr)) for phr in phrases]
phrases.sort(key=lambda x: len(x[0]))

# place the characters in each word in the phrase in <phr>
# onto one of the four dice in <dice>
def place_on_dice(phr, dice):
  if not phr:
    yield dice
  else:
    # speed up: credit Frits
    if not dice:
      dice = ['', '', '', '']
      arrange = combinations
    else:
      arrange = permutations
    # the next word to place
    wrd = list(phr[0])
    
    # letters cannot be on the same dice
    if any(len(set(wrd).intersection(d)) > 1 for d in dice):
      return
    
    # the dice numbers (in 0..3) available for letter assignment
    av_dice  = [n for n in range(4) if len(dice[n]) < 6]

# collect letters and the dice number they are on (if a letter 
    # is already on a die, we don't need to allocate this letter but 
    # we can't use this die for another letter)
    ltr_dnbr = [(l, n) for n in av_dice for l in wrd if l in dice[n]]

# letters must be on different dice 
    dnbrs = list(dn for l, dn in ltr_dnbr)
    if any(dnbrs.count(n) > 1 for n in dnbrs):
      return
    
    # remove letters already present on dice (and their related dice)
    for l, n in ltr_dnbr:
      wrd.remove(l)
      av_dice.remove(n)
      
    # now assign the unassigned letters on all arrangements 
    # of the available dice
    for dns in arrange(av_dice, len(wrd)):
      dice_ = dice.copy()
      for l, n in zip(wrd, dns):
        dice_[n] += l
      yield from place_on_dice(phr[1:], dice_)

# check whether a dice can be created to make the phrase <rp1>
# and then be extended to make at least one more phrase
def test(rp1):
  for d1 in place_on_dice(rp1, None):
    for rp2, p2 in phrases:
        if rp2 != rp1:
          for d2 in place_on_dice(rp2, d1):
            print(f'dice [{' '.join(sorted(d2))}] can make "{p1}" and "{p2}"')
            return None
  return d1

# look for a phrase that uses a dice arrangement that cannot be extended            
for rp1, p1 in phrases:
  if (d := test(rp1)):
    print(f'\nSolution: "{p1}" (example dice: [{' '.join(sorted(d))}])')

from itertools import combinations, permutations

phrases = [p.split() for p in [

'Don’t rock the boat',

'Easy come, easy go',

'Give a dog a bad name',

'If the cap fits wear it',

'Life is what you make it',

'Make love not war',

'You reap what you sow',

'If you can’t beat them join them',

'Don’t bury your head in the sand',

'Time and tide wait for no man']]

# simplify the phrases, store the words in phrases in inverse

# length order and the phrases in number of words order

phrases = [(sorted(set(''.join(c.lower() for c in word if c.isalpha())

for word in phr), key=lambda x: -len(x)), ' '.join(phr)) for phr in phrases]

phrases.sort(key=lambda x: len(x[0]))

# place the characters in each word in the phrase in <phr>

# onto one of the four dice in <dice>

def place_on_dice(phr, dice):

if not phr:

yield dice

else:

# speed up: credit Frits

if not dice:

dice = ['', '', '', '']

arrange = combinations

else:

arrange = permutations

# the next word to place

wrd = list(phr[0])

# letters cannot be on the same dice

if any(len(set(wrd).intersection(d)) > 1 for d in dice):

return

# the dice numbers (in 0..3) available for letter assignment

av_dice = [n for n in range(4) if len(dice[n]) < 6]

# collect letters and the dice number they are on (if a letter

# is already on a die, we don't need to allocate this letter but

# we can't use this die for another letter)

ltr_dnbr = [(l, n) for n in av_dice for l in wrd if l in dice[n]]

# letters must be on different dice

dnbrs = list(dn for l, dn in ltr_dnbr)

if any(dnbrs.count(n) > 1 for n in dnbrs):

return

# remove letters already present on dice (and their related dice)

for l, n in ltr_dnbr:

wrd.remove(l)

av_dice.remove(n)

# now assign the unassigned letters on all arrangements

# of the available dice

for dns in arrange(av_dice, len(wrd)):

dice_ = dice.copy()

for l, n in zip(wrd, dns):

dice_[n] += l

yield from place_on_dice(phr[1:], dice_)

# check whether a dice can be created to make the phrase <rp1>

# and then be extended to make at least one more phrase

def test(rp1):

for d1 in place_on_dice(rp1, None):

for rp2, p2 in phrases:

if rp2 != rp1:

for d2 in place_on_dice(rp2, d1):

print(f'dice [{' '.join(sorted(d2))}] can make "{p1}" and "{p2}"')

return None

return d1

# look for a phrase that uses a dice arrangement that cannot be extended

for rp1, p1 in phrases:

if (d := test(rp1)):

print(f'\nSolution: "{p1}" (example dice: [{' '.join(sorted(d))}])')

John Z permalink

Ever so slightly faster if line 31 is replaced by:

Python

def arrange(a, b): yield a[:b]

1
2
3

def arrange(a, b): yield a[:b]

This does the work required of ‘combinations’ which can be removed from the import list.

Reply

John Z permalink

Oops! Brian, yours works, mine doesn’t. I need to go back to the drawing board.

Reply

John Z. permalink

Frits, this should address your concerns. (and some improvements)
___
With a dose of inspiration from Brian’s solution

from itertools import permutations, combinations

# apostrophes removed manually
sayings = (
  "Dont rock the boat",
  "Easy come easy go",
  "Give a dog a bad name",
  "If the cap fits wear it",
  "Life is what you make it",
  "Make love not war",
  "You reap what you sow",
  "If you cant beat them join them",
  "Dont bury your head in the sand",
  "Time and tide wait for no man")

ss = tuple(sorted(set(s.lower().split()), # organise into words by length
                  key = len, reverse = True) for s in sayings)
lss = len(ss)

def makedice(words, dice):
  if len(words) == 0: # all of the letters / words are now assigned
    yield dice

else:
    # consider all possible letter to dice assignments for a word
    for L2d in permutations(range(4), len(words[0])):

# make next level of dice
      nld = [x.copy() for x in dice] # can't use (shallow) dice.copy here
      
      for i, n in enumerate(L2d):
        nld[n] |= {words[0][i]} # assign each letter in word to a die

# verify that dice follow rules
      if (all(len(x) < 7 for x in nld) and # 6 or fewer letters in each die
          # no same letter in 2 dice
          len(set.union(*nld)) == sum(len(x) for x in nld)):

# to next level
        yield from makedice(words[1:], nld)
      
flags = [0 for i in range(lss)] # clear pairings flags
for i, j in combinations(range(lss), 2): # consider all sayings pairs

if flags[i] & flags[j]: # have both sayings already been paired with others?
    continue

# dice for first + second saying, seed dice with four letters of 1st word
  for xydice in makedice(ss[i][1:] + ss[j], [set(a) for a in ss[i][0]]):
    print(sayings[i])
    print(sayings[j])
    print('Dice:', '  '.join('-'.join(x) for x in xydice), '\n')
  
    flags[i], flags[j] = 1, 1 # indicate sayings pairing possible
    break
  
# find and print saying which is never in a pair
for xdice in makedice(ss[i := flags.index(0)][1:], [set(a) for a in ss[i][0]]):
  print('solution:', sayings[i])
  print('Dice:', '   '.join('-'.join(x) for x in xdice))
  break

from itertools import permutations, combinations

# apostrophes removed manually

sayings = (

"Dont rock the boat",

"Easy come easy go",

"Give a dog a bad name",

"If the cap fits wear it",

"Life is what you make it",

"Make love not war",

"You reap what you sow",

"If you cant beat them join them",

"Dont bury your head in the sand",

"Time and tide wait for no man")

ss = tuple(sorted(set(s.lower().split()), # organise into words by length

key = len, reverse = True) for s in sayings)

lss = len(ss)

def makedice(words, dice):

if len(words) == 0: # all of the letters / words are now assigned

yield dice

else:

# consider all possible letter to dice assignments for a word

for L2d in permutations(range(4), len(words[0])):

# make next level of dice

nld = [x.copy() for x in dice] # can't use (shallow) dice.copy here

for i, n in enumerate(L2d):

nld[n] |= {words[0][i]} # assign each letter in word to a die

# verify that dice follow rules

if (all(len(x) < 7 for x in nld) and # 6 or fewer letters in each die

# no same letter in 2 dice

len(set.union(*nld)) == sum(len(x) for x in nld)):

# to next level

yield from makedice(words[1:], nld)

flags = [0 for i in range(lss)] # clear pairings flags

for i, j in combinations(range(lss), 2): # consider all sayings pairs

if flags[i] & flags[j]: # have both sayings already been paired with others?

continue

# dice for first + second saying, seed dice with four letters of 1st word

for xydice in makedice(ss[i][1:] + ss[j], [set(a) for a in ss[i][0]]):

print(sayings[i])

print(sayings[j])

print('Dice:', ' '.join('-'.join(x) for x in xydice), '\n')

flags[i], flags[j] = 1, 1 # indicate sayings pairing possible

break

# find and print saying which is never in a pair

for xdice in makedice(ss[i := flags.index(0)][1:], [set(a) for a in ss[i][0]]):

print('solution:', sayings[i])

print('Dice:', ' '.join('-'.join(x) for x in xdice))

break

Sunday Times Teaser 3260 – Alphabet Soup

by Peter Good

Published Sunday March 16 2025 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta