Sunday Times Teaser 2645 – One Square

by BRG on June 2, 2013

by Andrew Skidmore

Published Sunday June 02 2013 (link)

I have consistently replaced digits by letters, using different letters for different digits, and in this way I have found that FIVE — FOUR squared is ONE.

Now if I were to tell you whether or not THREE is divisible by 3, and whether or not FOUR is divisible by 4, then you could work out FIVE.
What number is FIVE?

A subsequent amendment to the teaser specified that FIVE > FOUR.

From → Uncategorized

2 Comments Leave one →

BRG permalink

There is an ambiguity in the puzzle since it is unclear whether FIVE has to be larger than FOUR. The following program allows either choice to be made.


from collections import defaultdict as df_dict

# set to True to output details of the solution
detail = False
# set to -1 to allow FIVE - FOUR to be negative
is_neg = 1

# Whether or not THREE is divisible by 3 and FOUR is divisible by
# 4 gives four possible outcomes so we have a dictionary for each
d4 = [df_dict(list), df_dict(list), df_dict(list), df_dict(list)]

# let ONE == n ** 2 so that n is in the range 10..31 inclusive
for n in range(10, 32):
  one = n * n
  O, N, E = (int(x) for x in str(one))
  # O, N and E must be different
  if len(set((O, N, E))) != 3:
    continue
  # we have O and UR from OUR is in the range 0..99 inclusive
  for ur in range(100):
    # form OUR and ensure that O, U, R, N and E are all different
    our = 100 * O + ur
    if len(set(str(our) + str(one))) != 5:
      continue
    O, U, R = (int(x) for x in str(our))
    # choose the sign of FIVE - FOUR
    for sign in set((is_neg, 1)):
      # form IVE and check it has 3 digits with a correct E value
      ive = our + sign * n
      if not (100 <= ive < 1000) or E != ive % 10:
        continue
      I, V, E = (int(x) for x in str(ive))
      # check that we now have seven different digits
      t = (E, I, N, O, R, U, V)
      if len(set(t)) != 7:
        continue
      # now try F values from the remaining digits
      for F in set(range(10)) - set(t):
        # and form FOUR and FIVE
        four = 1000 * F + our
        five = 1000 * F + ive
        # compute THREE mod 3
        mod_3 = (sum(set(range(10)) - set(t + (F,))) + R + 2 * E) % 3
        # create an index for the four different divisibility outcomes
        ix = 2 * (1 if mod_3 else 0) + (1 if four % 4 else 0)
        # and (with premonition!) index FIVE values on ONE
        d4[ix][one] += [(four, five)]

# for each of the four possible divisibility outcomes
for d in d4:
  # create a list of unique (FOUR, FIVE) pairs for each ONE value
  unique = [(one,) + p45[0] for one, p45 in d.items() if len(p45) == 1]
  # we have a solution if we have only one unique value
  if len(unique) == 1:
    fs = 'FIVE = {0[2]:d} (ONE = {0[0]:d}, FOUR = {0[1]:d})'
    print(fs.format(unique[0]))

if detail:
  print()
  for d in d4:
    for one, p45 in d.items():
      print(one, sorted(p45))
    print()

from collections import defaultdict as df_dict

# set to True to output details of the solution

detail = False

# set to -1 to allow FIVE - FOUR to be negative

is_neg = 1

# Whether or not THREE is divisible by 3 and FOUR is divisible by

# 4 gives four possible outcomes so we have a dictionary for each

d4 = [df_dict(list), df_dict(list), df_dict(list), df_dict(list)]

# let ONE == n ** 2 so that n is in the range 10..31 inclusive

for n in range(10, 32):

one = n * n

O, N, E = (int(x) for x in str(one))

# O, N and E must be different

if len(set((O, N, E))) != 3:

continue

# we have O and UR from OUR is in the range 0..99 inclusive

for ur in range(100):

# form OUR and ensure that O, U, R, N and E are all different

our = 100 * O + ur

if len(set(str(our) + str(one))) != 5:

continue

O, U, R = (int(x) for x in str(our))

# choose the sign of FIVE - FOUR

for sign in set((is_neg, 1)):

# form IVE and check it has 3 digits with a correct E value

ive = our + sign * n

if not (100 <= ive < 1000) or E != ive % 10:

continue

I, V, E = (int(x) for x in str(ive))

# check that we now have seven different digits

t = (E, I, N, O, R, U, V)

if len(set(t)) != 7:

continue

# now try F values from the remaining digits

for F in set(range(10)) - set(t):

# and form FOUR and FIVE

four = 1000 * F + our

five = 1000 * F + ive

# compute THREE mod 3

mod_3 = (sum(set(range(10)) - set(t + (F,))) + R + 2 * E) % 3

# create an index for the four different divisibility outcomes

ix = 2 * (1 if mod_3 else 0) + (1 if four % 4 else 0)

# and (with premonition!) index FIVE values on ONE

d4[ix][one] += [(four, five)]

# for each of the four possible divisibility outcomes

for d in d4:

# create a list of unique (FOUR, FIVE) pairs for each ONE value

unique = [(one,) + p45[0] for one, p45 in d.items() if len(p45) == 1]

# we have a solution if we have only one unique value

if len(unique) == 1:

fs = 'FIVE = {0[2]:d} (ONE = {0[0]:d}, FOUR = {0[1]:d})'

print(fs.format(unique[0]))

if detail:

print()

for d in d4:

for one, p45 in d.items():

print(one, sorted(p45))

print()

The analysis in my original code above is fine but the code itself is really quite bizarre. Here is how I would do it today:


d = dict()
# ONE is a three digit square
for sr in range(10, 32):
  O, N, E = (int(d) for d in str(sr * sr))
  
  # (R - E)^2 == E mod 10 ==> R^2 == E.(E - 1) mod 2 ==> R even  
  for ur in range(0, 100, 2):
    U, R = divmod(ur, 10)
    # check the E/R constraint and avoid duplicate digits 
    if ((E - R) ** 2 - E) % 10 or len({E, N, O, R, U}) != 5:
      continue
    
    # IVE = OUR + n (note the teaser amendment: FIVE > FOUR)
    for sgn in (-1, 1):
      if not 100 < (t := 100 * O + ur + sr * sgn) < 1000:
        continue
      I, V, _E = (int(d) for d in str(t))
      
      # there are now three so far unused digits
      s3 = set(range(10)).difference([E, I, N, O, R, U, V])      
      if _E != E or len(s3) != 3:
        continue
      
      # note that s3 is now {T, H, F}      
      for F in s3 - {0}:
        four = 1000 * F + 100 * O + ur
        five = 1000 * F + 100 * I + + 10 * V + E
        # calculate THREE mod 3
        n3_m3 = (sum(s3) - F + R + 2 * E) % 3
        key = (sgn, n3_m3, four % 4)
        d[key] = d.get(key, set()) | {(sr * sr, four, five)}

show_pos = True
show_neg = False

for k, ls in d.items():
  if len(ls) == 1:
    one, four, five = ls.pop()
    if k[0] > 0 and show_pos or k[0] < 0 and show_neg:
      print(f"FIVE = {five} [ONE = {one}, FOUR = {four}]")

d = dict()

# ONE is a three digit square

for sr in range(10, 32):

O, N, E = (int(d) for d in str(sr * sr))

# (R - E)^2 == E mod 10 ==> R^2 == E.(E - 1) mod 2 ==> R even

for ur in range(0, 100, 2):

U, R = divmod(ur, 10)

# check the E/R constraint and avoid duplicate digits

if ((E - R) ** 2 - E) % 10 or len({E, N, O, R, U}) != 5:

continue

# IVE = OUR + n (note the teaser amendment: FIVE > FOUR)

for sgn in (-1, 1):

if not 100 < (t := 100 * O + ur + sr * sgn) < 1000:

continue

I, V, _E = (int(d) for d in str(t))

# there are now three so far unused digits

s3 = set(range(10)).difference([E, I, N, O, R, U, V])

if _E != E or len(s3) != 3:

continue

# note that s3 is now {T, H, F}

for F in s3 - {0}:

four = 1000 * F + 100 * O + ur

five = 1000 * F + 100 * I + + 10 * V + E

# calculate THREE mod 3

n3_m3 = (sum(s3) - F + R + 2 * E) % 3

key = (sgn, n3_m3, four % 4)

d[key] = d.get(key, set()) | {(sr * sr, four, five)}

show_pos = True

show_neg = False

for k, ls in d.items():

if len(ls) == 1:

one, four, five = ls.pop()

if k[0] > 0 and show_pos or k[0] < 0 and show_neg:

print(f"FIVE = {five} [ONE = {one}, FOUR = {four}]")

Frits permalink

Forcing a comment.

With today you mean “in 2023”. I do miss comment timestamps

Reply

Sunday Times Teaser 2645 – One Square

by Andrew Skidmore

Published Sunday June 02 2013 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta