Sunday Times Teaser 2786 – Out of Order

by Victor Bryant

Published: 14 February 2016 (link)

I have written down five positive whole numbers whose sum is less than 100. If you wrote the numbers in words, then you would find that each of them begins with a different letter of the alphabet. (Surprisingly, the same is true of the five numbers obtained by increasing each of my five numbers by one.) If you write my five numbers in words and put them in alphabetical order, then they will be in decreasing order.

What (in decreasing order) are my five numbers?

2 Comments Leave one →

Brian Gladman permalink

Not very elegant but it gets the job done.


# map initial letters to numbers between 2 and 100
l2n = { 'e': ((8, 11, 18) + tuple(range(80, 90))),
        'f': (4, 5, 14, 15) + tuple(range(40, 60)),
        'n': (9, 19) + tuple(range(90, 100)),
        's': (6, 7, 16, 17) + tuple(range(60, 80)),
        't': (2, 3, 10, 12, 13) + tuple(range(20, 40)) }

# create a map from numbers to their initial letters
n2l = dict((y, x) for x in l2n for y in l2n[x]) 

# there must be one number from each of the above groups
# and they must also be in decreasing numerical order
# when selected in alphabetical order
for n1 in l2n['e']:
  for n2 in l2n['f']:
    if n2 < n1 and n1 + n2 < 100:
      for n3 in l2n['n']:
        if n3 < n2 and n1 + n2 + n3 < 100:
          for n4 in l2n['s']:
            if n4 < n3:
              for n5 in l2n['t']:
                if n5 < n4:
                  nbrs = (n1, n2, n3, n4, n5)
                  # the numbers must have a sum less than 100 and have
                  # different initial letters when increased by 1
                  if (sum(nbrs) < 100 and 
                           len(set(n2l[n + 1] for n in nbrs)) == 5):
                    s = ' and '.join(str(x) for x in nbrs)
                    s = s.replace(' and ', ', ', 3)
                    print('The numbers are {}.'.format(s))

# map initial letters to numbers between 2 and 100

l2n = { 'e': ((8, 11, 18) + tuple(range(80, 90))),

'f': (4, 5, 14, 15) + tuple(range(40, 60)),

'n': (9, 19) + tuple(range(90, 100)),

's': (6, 7, 16, 17) + tuple(range(60, 80)),

't': (2, 3, 10, 12, 13) + tuple(range(20, 40)) }

# create a map from numbers to their initial letters

n2l = dict((y, x) for x in l2n for y in l2n[x])

# there must be one number from each of the above groups

# and they must also be in decreasing numerical order

# when selected in alphabetical order

for n1 in l2n['e']:

for n2 in l2n['f']:

if n2 < n1 and n1 + n2 < 100:

for n3 in l2n['n']:

if n3 < n2 and n1 + n2 + n3 < 100:

for n4 in l2n['s']:

if n4 < n3:

for n5 in l2n['t']:

if n5 < n4:

nbrs = (n1, n2, n3, n4, n5)

# the numbers must have a sum less than 100 and have

# different initial letters when increased by 1

if (sum(nbrs) < 100 and

len(set(n2l[n + 1] for n in nbrs)) == 5):

s = ' and '.join(str(x) for x in nbrs)

s = s.replace(' and ', ', ', 3)

print('The numbers are {}.'.format(s))

Jim Randell permalink

I wrote a recursive solution (using some routines from the enigma.py library). I wasn’t that worried about speed, so I generate sequences of 5 numbers in decreasing numerical order, but increasing alphabetical order, and then apply the condition that the initials are all different if the numbers are increased by one. It runs in 77ms.


from enigma import int2words, irange, printf

N = 5 # how many numbers in the sequence
T = 100 # sum must be less than this

# map numbers to their initial letter
m = dict((i, int2words(i)[0]) for i in irange(1, T - 1))

# generate sequences of N numbers in decreasing numerical order,
# but increasing alphabetical order, that sum less than T
def solve(ns):
  # are we done?
  if len(ns) == N:
    yield ns
  else:
    # add in a lower number
    (n0, t0) = (ns[-1], sum(ns))
    for n in irange(n0 - 1, 1, step=-1):
      t = t0 + n
      if not(t  m[n0]): continue
      yield from solve(ns + [n])

# check the numbers in ns all start with different letters when offset by i
def check(ns, i=0):
  return len(set(m[n + i] for n in ns)) == len(ns)

# start with the largest number
for n in irange(5, 89):
  for ns in solve([n]):
    # check the starting letters are all different when offset by 1
    if not check(ns, 1): continue
    # output a solution
    printf("{ns} sum={t}", t=sum(ns))

from enigma import int2words, irange, printf

N = 5 # how many numbers in the sequence

T = 100 # sum must be less than this

# map numbers to their initial letter

m = dict((i, int2words(i)[0]) for i in irange(1, T - 1))

# generate sequences of N numbers in decreasing numerical order,

# but increasing alphabetical order, that sum less than T

def solve(ns):

# are we done?

if len(ns) == N:

yield ns

else:

# add in a lower number

(n0, t0) = (ns[-1], sum(ns))

for n in irange(n0 - 1, 1, step=-1):

t = t0 + n

if not(t m[n0]): continue

yield from solve(ns + [n])

# check the numbers in ns all start with different letters when offset by i

def check(ns, i=0):

return len(set(m[n + i] for n in ns)) == len(ns)

# start with the largest number

for n in irange(5, 89):

for ns in solve([n]):

# check the starting letters are all different when offset by 1

if not check(ns, 1): continue

# output a solution

printf("{ns} sum={t}", t=sum(ns))

I note that the the initial letters are also all different when the numbers are increased by 2, but this condition isn’t sufficiently strong to replace the additional condition in the question and still arrive at a unique solution.

Sunday Times Teaser 2786 – Out of Order

by Victor Bryant

Published: 14 February 2016 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta