Sunday Times Teaser 2647 – Happy Medium

by Victor Bryant

In order to conduct a seance, Adam, Alan, Andy, Eden, Eric, Fred, Gary, Glen, John, Mike, Pete and Tony sat around a table of radius one metre. Twelve equally spaced points on the edge of the table represented different letters.

A light started at the centre of the table and then, after moving to one of the 12 points, moved between the points in a way that spelt out the name of one of those present, finally returning to the centre. It then repeated this process twice, first to spell a day of the week and second to spell a month.

The individual legs of these paths were all straight lines whose lengths were a whole number of centimetres.

Which three words did it spell out?

One Comment Leave one →

brian gladman permalink

This teaser has ambiguous wording in that ‘represented different letters’ could mean that each point represents more than one letter. In fact it seems that it is intended to mean: ‘represented a different letter’.


# Note that, starting at point 0, the points that are reachable in
# integer distances are at 0, 2, 6 and 10 around the circle.  This
# means that the 12 letters form two disjoint sets at even and odd
# positions. So we need to find  pairs of words,  one from days of
# the week and one from months,  each having six or less different
# letters and for which the two sets of letters are diisjoint. One
# of these sets must also be able to cover the letters in a name.

from collections import defaultdict
from itertools import permutations

names = ( 'Adam', 'Alan', 'Andy', 'Eden', 'Eric', 'Fred',
          'Gary', 'Glen', 'John', 'Mike', 'Pete', 'Tony' )

days = ( 'Monday', 'Tuesday', 'Wednesday', 'Thursday',
         'Friday', 'Saturday', 'Sunday' )

months = ( 'January', 'February', 'March', 'April', 'May',
           'June', 'July', 'August', 'September', 'October',
           'November', 'December' )

# check whether words in a list  can be formed with the given
# arrangement of six letters (at either odd or even positions)
def valid(word_list, p):
  for word in word_list:
    # the starting position for the first letter
    pos = p.index(word[0])
    for ltr in word[1:]:
      # the next position
      next_pos = p.index(ltr)
      # which cannot be 2 or 4 away from where we are now
      if (next_pos - pos) % 6 in (2, 4):
        # this word is impossible
        return False
      pos = next_pos
    # this word is possible
  return True

# check if two words fit into a six letter sequence
# around the circle - valid moves are to adjacent
# and opposite letters (indexes 0, 1, 3 and 5)
def compatible(word_1, word_2):
  # use lower case letters
  w1, w2 = word_1.lower(), word_2.lower()
  # we cannot have more than six different letters
  ltrs = set((w1 + w2))
  if len(ltrs) <= 6:
    # pad with spaces if necessary to make six positions
    ltrs = tuple(ltrs) + (' ',) * (6 - len(ltrs))
    # check if we can allocate letters to the six
    # positions in a way that makes both words valid
    for p in permutations(ltrs[1:]):
      if valid((w1, w2), (ltrs[0],) + p):
        # the sequence is valid if we can
        return True
  # otherwise it is not
  return False

for month in months:
  s_month = set(month.lower())
  # only consider months with six or less letters
  if len(s_month) <= 6:
    for day in days:
      s_day = set(day.lower())
      # only consider days with six or less letters
      if len(s_day) <= 6:
        # only days and months with disjoint sets of letters
        if not (s_month & s_day):
          # names must be in only one set and be compatible with it
          for name in names:
            s_name = set(name.lower())
            # name and day of week are in the same set of letters
            if not (s_name & s_month) and compatible(name, day):
              print('({:s} | {:s}) & {:s}'.format(name, day, month))
            # name and month are in the same set of letters
            if not (s_name & s_day) and compatible(name, month):
              print('({:s} | {:s}) & {:s}'.format(name, month, day))

# Note that, starting at point 0, the points that are reachable in

# integer distances are at 0, 2, 6 and 10 around the circle. This

# means that the 12 letters form two disjoint sets at even and odd

# positions. So we need to find pairs of words, one from days of

# the week and one from months, each having six or less different

# letters and for which the two sets of letters are diisjoint. One

# of these sets must also be able to cover the letters in a name.

from collections import defaultdict

from itertools import permutations

names = ( 'Adam', 'Alan', 'Andy', 'Eden', 'Eric', 'Fred',

'Gary', 'Glen', 'John', 'Mike', 'Pete', 'Tony' )

days = ( 'Monday', 'Tuesday', 'Wednesday', 'Thursday',

'Friday', 'Saturday', 'Sunday' )

months = ( 'January', 'February', 'March', 'April', 'May',

'June', 'July', 'August', 'September', 'October',

'November', 'December' )

# check whether words in a list can be formed with the given

# arrangement of six letters (at either odd or even positions)

def valid(word_list, p):

for word in word_list:

# the starting position for the first letter

pos = p.index(word[0])

for ltr in word[1:]:

# the next position

next_pos = p.index(ltr)

# which cannot be 2 or 4 away from where we are now

if (next_pos - pos) % 6 in (2, 4):

# this word is impossible

return False

pos = next_pos

# this word is possible

return True

# check if two words fit into a six letter sequence

# around the circle - valid moves are to adjacent

# and opposite letters (indexes 0, 1, 3 and 5)

def compatible(word_1, word_2):

# use lower case letters

w1, w2 = word_1.lower(), word_2.lower()

# we cannot have more than six different letters

ltrs = set((w1 + w2))

if len(ltrs) <= 6:

# pad with spaces if necessary to make six positions

ltrs = tuple(ltrs) + (' ',) * (6 - len(ltrs))

# check if we can allocate letters to the six

# positions in a way that makes both words valid

for p in permutations(ltrs[1:]):

if valid((w1, w2), (ltrs[0],) + p):

# the sequence is valid if we can

return True

# otherwise it is not

return False

for month in months:

s_month = set(month.lower())

# only consider months with six or less letters

if len(s_month) <= 6:

for day in days:

s_day = set(day.lower())

# only consider days with six or less letters

if len(s_day) <= 6:

# only days and months with disjoint sets of letters

if not (s_month & s_day):

# names must be in only one set and be compatible with it

for name in names:

s_name = set(name.lower())

# name and day of week are in the same set of letters

if not (s_name & s_month) and compatible(name, day):

print('({:s} | {:s}) & {:s}'.format(name, day, month))

# name and month are in the same set of letters

if not (s_name & s_day) and compatible(name, month):

print('({:s} | {:s}) & {:s}'.format(name, month, day))

Sunday Times Teaser 2647 – Happy Medium

by Victor Bryant

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta