Sunday Times Teaser 3136 – Fill Cells Mentally, My Dear Watson

by BRG on October 28, 2022

by Stephen Hogg

Published Sunday October 30 202 (link)

Moriarty’s papers were alight. Holmes memorised a 3×3 grid of different 4-digit values in ascending order as illustrated, from A (lowest) to I (highest), noticing that one numeral wasn’t used. Three cells, isolated from one another (no corner or edge contact), held squares of squares. Three others, similarly isolated, held cubes of non-squares. The other three held squares of non-squares. Holmes told Watson these features, specifying only the lowest value. “Not square,” remarked Watson.

“True, and many grids match these facts. However, if I told you the positions of the squares of squares in the grid, you could deduce a majority of the other eight values (apart from the lowest one)” replied Holmes.

In ascending order, which values did Watson now know certainly?

From → Uncategorized

2 Comments Leave one →

Brian Gladman permalink


from itertools import combinations, product
from collections import defaultdict
from math import isqrt

# four digit squares of non-squares
pw2 = tuple(str(x ** 2) for x in range(32, 100) if x != isqrt(x) ** 2)

# four digit cubes of non-squares
pw3 = tuple(str(x ** 3) for x in range(10, 22) if x != isqrt(x) ** 2)

# four digit 4th powers
pw4 = tuple(str(x ** 4) for x in range(6, 10))

# possible grid layouts for Cubes, Quad powers and Squares
                                            # C Q C
cqs = (((0, 2, 7), (1, 6, 8), (3, 4, 5)),   # S S S
                                            # Q C Q

                                            # C S Q
       ((0, 5, 6), (2, 3, 8), (1, 4, 7)))   # Q S C
                                            # C S Q

# map the minimum cube (A) and the position of
# 4th powers in the grid to possible solutions
mv2sols = defaultdict(list)

# consider the two grid configurations
for gc, (cp, qp, rp) in enumerate(cqs):
  gr = {}
  
  # pick three cubes of non-squares
  for pc3 in combinations(pw3, 3):
    sc = set('0123456789').difference(''.join(pc3))
    if not sc:
      continue
    gr.update((i, j) for i, j in zip(cp, pc3))

    # pick three 4th powers greater than the least cube value
    for pq3 in combinations((n for n in pw4 if n > pc3[0]), 3):
      scq = sc.difference(''.join(pq3))
      # check for incorrect order or all digits used
      if pq3[0] > pc3[1] or pc3[2] < pq3[1] or not scq:
        continue
      gr.update((i, j) for i, j in zip(qp, pq3))

      if gc == 0:
        # squares occupy the middle row
        l_ps3 = list(combinations((n for n in pw2
                  if (pc3[1] < n < pq3[1] and scq.difference(n))), 3))
      else:
        # squares occupy the middle column
        p1 = (n for n in pw2 if pc3[0] < n < pq3[0])
        p2 = (n for n in pw2 if pq3[1] < n < pc3[1])
        p3 = (n for n in pw2 if pc3[2] < n < pq3[2])
        l_ps3 = list(product(p1, p2, p3))
      
      for ps3 in l_ps3:
        if len(scq.difference(''.join(ps3))) == 1:
          gr.update((i, j) for i, j in zip(rp, ps3))
          if (nl := list(v for k, v in sorted(gr.items()))):
            mv2sols[pc3[0], gc].append(nl)

# consider solutions for each (A, gc) value     
for (a, gc), l_solns in mv2sols.items():
  # collect grid values common to all solutions
  cs = set(l_solns[0])
  for s in l_solns[1:]:
    cs.intersection_update(s)
  # solutions must determine at least five of the 
  # last eight values (B..I)
  if len(cs) >= 6:
    print(f"{', '.join(sorted(cs))}")

from itertools import combinations, product

from collections import defaultdict

from math import isqrt

# four digit squares of non-squares

pw2 = tuple(str(x ** 2) for x in range(32, 100) if x != isqrt(x) ** 2)

# four digit cubes of non-squares

pw3 = tuple(str(x ** 3) for x in range(10, 22) if x != isqrt(x) ** 2)

# four digit 4th powers

pw4 = tuple(str(x ** 4) for x in range(6, 10))

# possible grid layouts for Cubes, Quad powers and Squares

# C Q C

cqs = (((0, 2, 7), (1, 6, 8), (3, 4, 5)), # S S S

# Q C Q

# C S Q

((0, 5, 6), (2, 3, 8), (1, 4, 7))) # Q S C

# C S Q

# map the minimum cube (A) and the position of

# 4th powers in the grid to possible solutions

mv2sols = defaultdict(list)

# consider the two grid configurations

for gc, (cp, qp, rp) in enumerate(cqs):

gr = {}

# pick three cubes of non-squares

for pc3 in combinations(pw3, 3):

sc = set('0123456789').difference(''.join(pc3))

if not sc:

continue

gr.update((i, j) for i, j in zip(cp, pc3))

# pick three 4th powers greater than the least cube value

for pq3 in combinations((n for n in pw4 if n > pc3[0]), 3):

scq = sc.difference(''.join(pq3))

# check for incorrect order or all digits used

if pq3[0] > pc3[1] or pc3[2] < pq3[1] or not scq:

continue

gr.update((i, j) for i, j in zip(qp, pq3))

if gc == 0:

# squares occupy the middle row

l_ps3 = list(combinations((n for n in pw2

if (pc3[1] < n < pq3[1] and scq.difference(n))), 3))

else:

# squares occupy the middle column

p1 = (n for n in pw2 if pc3[0] < n < pq3[0])

p2 = (n for n in pw2 if pq3[1] < n < pc3[1])

p3 = (n for n in pw2 if pc3[2] < n < pq3[2])

l_ps3 = list(product(p1, p2, p3))

for ps3 in l_ps3:

if len(scq.difference(''.join(ps3))) == 1:

gr.update((i, j) for i, j in zip(rp, ps3))

if (nl := list(v for k, v in sorted(gr.items()))):

mv2sols[pc3[0], gc].append(nl)

# consider solutions for each (A, gc) value

for (a, gc), l_solns in mv2sols.items():

# collect grid values common to all solutions

cs = set(l_solns[0])

for s in l_solns[1:]:

cs.intersection_update(s)

# solutions must determine at least five of the

# last eight values (B..I)

if len(cs) >= 6:

print(f"{', '.join(sorted(cs))}")

John Z permalink

Slightly empirical solution in that I decided to discard one of the two possible configurations. This kept code length to a minimum.


'''
      A B C
      D E F
      G H I

'A' can only be a cube of a non square so
Cubes of non squares can only be in ACG, ACH, AFG, AGI or ACI
Squares of squares can only be in BGI, CDI or CGI (can't be in A)
Squares of non squares are in the remaing three

Cubes of ns in ACG rules out all Sq of Sq

Cubes of ns in ACH allows Sq of Sq in BGI and vv

Cubes of ns in AFG allows Sq of Sq in CDI and vv

Cubes of ns in AGI rules out all Sq of Sq

Cubes of ns in ACI rules out all Sq of Sq

'''
from math import isqrt
from itertools import combinations

#create tuple of squares of squares
n4 = tuple(i ** 4 for i in range(10)  if 999 < i ** 4 < 10000)

#create tuple of cubes of non squares
n3 = tuple(i ** 3 for i in range(22)  if 999 < i ** 3 < 10000 and
           isqrt(i) ** 2 != i)

#create tuple of squares of non squares
n2 = tuple(i ** 2 for i in range(100)  if 999 < i ** 2 < 10000 and
           isqrt(i) ** 2 != i)


'''
Try Sq of Sq (n4) in CDI so Cubes of Ns (n3) in AFG and Sq of Ns in BEH;
we ignore the squares of non squares as there are so many, we can easily find
some that will slot into place in BEH. (The other possibility Sq of Sq in BGI
doesn't look promising)
'''

sols = {x:(0, '') for x in n3}

for A, F, G in combinations(n3, 3):
  for C, D, I in combinations(n4, 3):

    # 'noticing that one numeral wasn’t used'
    if len(set(str(A) + str(F) + str(G) + str(C) + str(D) + str(I))) == 10:
      continue
    if A > C or D > F or G > I:
      continue

    # count the solutions for the 'A' values
    sols[A] = (sols[A][0] + 1, f'{A=}, {C=}, {D=}, {F=}, {G=}, {I=}')

# p
for x in sols.items():
  if x[1][0] == 1:
    print(x[1][1])

'''

A B C

D E F

G H I

'A' can only be a cube of a non square so

Cubes of non squares can only be in ACG, ACH, AFG, AGI or ACI

Squares of squares can only be in BGI, CDI or CGI (can't be in A)

Squares of non squares are in the remaing three

Cubes of ns in ACG rules out all Sq of Sq

Cubes of ns in ACH allows Sq of Sq in BGI and vv

Cubes of ns in AFG allows Sq of Sq in CDI and vv

Cubes of ns in AGI rules out all Sq of Sq

Cubes of ns in ACI rules out all Sq of Sq

'''

from math import isqrt

from itertools import combinations

#create tuple of squares of squares

n4 = tuple(i ** 4 for i in range(10) if 999 < i ** 4 < 10000)

#create tuple of cubes of non squares

n3 = tuple(i ** 3 for i in range(22) if 999 < i ** 3 < 10000 and

isqrt(i) ** 2 != i)

#create tuple of squares of non squares

n2 = tuple(i ** 2 for i in range(100) if 999 < i ** 2 < 10000 and

isqrt(i) ** 2 != i)

'''

Try Sq of Sq (n4) in CDI so Cubes of Ns (n3) in AFG and Sq of Ns in BEH;

we ignore the squares of non squares as there are so many, we can easily find

some that will slot into place in BEH. (The other possibility Sq of Sq in BGI

doesn't look promising)

'''

sols = {x:(0, '') for x in n3}

for A, F, G in combinations(n3, 3):

for C, D, I in combinations(n4, 3):

# 'noticing that one numeral wasn’t used'

if len(set(str(A) + str(F) + str(G) + str(C) + str(D) + str(I))) == 10:

continue

if A > C or D > F or G > I:

continue

# count the solutions for the 'A' values

sols[A] = (sols[A][0] + 1, f'{A=}, {C=}, {D=}, {F=}, {G=}, {I=}')

# p

for x in sols.items():

if x[1][0] == 1:

print(x[1][1])

Sunday Times Teaser 3136 – Fill Cells Mentally, My Dear Watson

by Stephen Hogg

Published Sunday October 30 202 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta