Sunday Times Teaser 3189 – Telling Tiles

by BRG on November 3, 2023

by Victor Bryant

Published Sunday November 05 2023

I have four tiles with a digit written on each of them: I shall refer to these as A, B, C and D. I have rearranged the tiles in various ways to make two 2-figure numbers and I have then multiplied those two numbers together (eg, CB times AD). In this way I have found as many answers as possible with this particular set of tiles and I have discovered that

I. The number of different answers is AB.

II. Of those answers B consist of the four digits A, B, C, D in some order.

III. There are C other 4-figure answers.

What are A, B, C and D respectively?

From → Uncategorized

2 Comments Leave one →

BRG permalink


from itertools import product

# consider all arrangements of four tiles each with digits in 0..9
for d4 in product(range(10), repeat=4):
  A, B, C, D = d4

  set_pr = set()
  # pair the digits - the index of the value paired with A
  for i in (1, 2, 3):
    # the indexes of the other two digits
    j, k =  (n for n in (1, 2, 3) if n != i)
    # collect the products of all two 2-digit values
    for n1 in (10 * A + d4[i], 10 * d4[i] + A):
      if n1 >= 10:
        for n2 in (10 * d4[j] + d4[k], 10 * d4[k] + d4[j]):
          if n2 >= 10:
            set_pr.add(n1 * n2)

  # the number of different products equals AB
  if len(set_pr) == 10 * A + B > 0:
  
    # the number of different four digit products equals B + C
    if len(n4 := set(n for n in set_pr if n >= 1000)) == B + C:
  
      # the number of different four digit products using
      # the digits A, B, C and D in some order equals B
      t = sorted(str(n) for n in d4)
      if len(set(n for n in n4 if sorted(str(n)) == t)) == B:
        print(f"(A, B, C, D) = ({A}, {B}, {C}, {D}) -> {sorted(set_pr)}")

from itertools import product

# consider all arrangements of four tiles each with digits in 0..9

for d4 in product(range(10), repeat=4):

A, B, C, D = d4

set_pr = set()

# pair the digits - the index of the value paired with A

for i in (1, 2, 3):

# the indexes of the other two digits

j, k = (n for n in (1, 2, 3) if n != i)

# collect the products of all two 2-digit values

for n1 in (10 * A + d4[i], 10 * d4[i] + A):

if n1 >= 10:

for n2 in (10 * d4[j] + d4[k], 10 * d4[k] + d4[j]):

if n2 >= 10:

set_pr.add(n1 * n2)

# the number of different products equals AB

if len(set_pr) == 10 * A + B > 0:

# the number of different four digit products equals B + C

if len(n4 := set(n for n in set_pr if n >= 1000)) == B + C:

# the number of different four digit products using

# the digits A, B, C and D in some order equals B

t = sorted(str(n) for n in d4)

if len(set(n for n in n4 if sorted(str(n)) == t)) == B:

print(f"(A, B, C, D) = ({A}, {B}, {C}, {D}) -> {sorted(set_pr)}")

Here is an approach based on a manual analysis leading to an approach suggested by Tony Smith on the Sunday Times Teaser Discussion Group.


from itertools import combinations, permutations

# The maximum number of different product values that can be made
# depends on the number of different digits in (A, B, C, D):
#
#   no of different digits   number of product values
#            1                        1
#            2                        2
#            3                        6
#            4                       12
#
# If there are four different digits with A = 0, there are only six 
# different products of two digit numbers since half the products 
# involving A will be single digit numbers. Hence in this situation 
# (A, B) = (0, 6) with at most six 4-digit numbers; here B + C <= 6
# which leads to A = C = 0 which does not provide six product values. 
# Hence AB = 12 and (A, B, C, D) are four different non-zero digits. 

A, B = 1, 2
# consider possible values for C and D
for C, D in combinations(range(3, 10), 2):
  c4 = (A, B, C, D)
  # collect products of all possible pairs of 2-digit numbers
  set_pr = set()
  for p4 in permutations(c4, 4):
    set_pr.add((10 * p4[0] + p4[1]) * (10 * p4[2] + p4[3]))
  
  # look for product sets that contain a four digit value
  # that contains the digits (A, B, C, D) in some order
  p = tuple(sorted(str(n) for n in c4))
  if p in set(tuple(sorted(str(n))) for n in set_pr):
    print(F"{c4} -> {sorted(set_pr)}")

from itertools import combinations, permutations

# The maximum number of different product values that can be made

# depends on the number of different digits in (A, B, C, D):

# no of different digits number of product values

# 1 1

# 2 2

# 3 6

# 4 12

# If there are four different digits with A = 0, there are only six

# different products of two digit numbers since half the products

# involving A will be single digit numbers. Hence in this situation

# (A, B) = (0, 6) with at most six 4-digit numbers; here B + C <= 6

# which leads to A = C = 0 which does not provide six product values.

# Hence AB = 12 and (A, B, C, D) are four different non-zero digits.

A, B = 1, 2

# consider possible values for C and D

for C, D in combinations(range(3, 10), 2):

c4 = (A, B, C, D)

# collect products of all possible pairs of 2-digit numbers

set_pr = set()

for p4 in permutations(c4, 4):

set_pr.add((10 * p4[0] + p4[1]) * (10 * p4[2] + p4[3]))

# look for product sets that contain a four digit value

# that contains the digits (A, B, C, D) in some order

p = tuple(sorted(str(n) for n in c4))

if p in set(tuple(sorted(str(n))) for n in set_pr):

print(F"{c4} -> {sorted(set_pr)}")

John Z permalink


from itertools import permutations

for A, B, C, D in permutations('123456789', 4):
  sabcd = {A, B, C, D}

  # make a set of all possible products
  s = set(int(J + K) * int(L + M)
          for J, K, L, M in permutations((A, B, C, D), 4))
  ab, b, c = int(A + B), int(B), int(C)

  # The number of different answers is AB.
  if len(s) == ab:
    
    # get 4 digit products a set of strings
    t = tuple(set(str(x)) for x in s if x >= 1000)

    # # The number of different 4 digit answers is B + C.
    if len(t) == b + c:
      
      # number of 4 digit products that have the digits A B C D must equal B
      if (cc := sum(sabcd == x for x in t)) == b:
      
        print(f'{A=}, {B=}, {C=}, {D=}')
        print(sorted(s))

from itertools import permutations

for A, B, C, D in permutations('123456789', 4):

sabcd = {A, B, C, D}

# make a set of all possible products

s = set(int(J + K) * int(L + M)

for J, K, L, M in permutations((A, B, C, D), 4))

ab, b, c = int(A + B), int(B), int(C)

# The number of different answers is AB.

if len(s) == ab:

# get 4 digit products a set of strings

t = tuple(set(str(x)) for x in s if x >= 1000)

# # The number of different 4 digit answers is B + C.

if len(t) == b + c:

# number of 4 digit products that have the digits A B C D must equal B

if (cc := sum(sabcd == x for x in t)) == b:

print(f'{A=}, {B=}, {C=}, {D=}')

print(sorted(s))

Sunday Times Teaser 3189 – Telling Tiles

by Victor Bryant

Published Sunday November 05 2023

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta