Sunday Times Teaser 3289 – Spot Check

by BRG on October 5, 2025

by Peter Good

Published Sunday October 05 2025 (link)

Jack has a set of 28 standard dominoes: each domino has a spot pattern containing 0 to 6 spots at either end and every combination ([0 0], [0 1] and so on up to [6 6]) is represented in the set. He discarded a non-blank domino and arranged the remaining dominoes into six “groups”, each of which contained a positive cube number of spots; a group might comprise a single domino. He then discarded another non-blank domino and rearranged the remaining dominoes into six groups each of which again contained a positive cube number of spots. He managed to do this the maximum possible number of times.

How many dominoes did Jack discard, and how many spots in total were there on the dominoes that remained at the end?

From → Uncategorized

4 Comments Leave one →

BRG permalink

To be published.

Reply

Frits permalink

There are also other variations of domino distributions that have the same end result.

# the 28 dominoes
dominoes = tuple((i, j) for i in range(7) for j in range(i, 7))
# the total number of spots
n_spots = sum(a + b for a, b in dominoes)

# make total spots <t> with <k> elements from list <ns>
def decompose(t, k, ns, ss=[]):
  if k == 1:
    if t in ns and t >= ss[-1]:
      yield ss + [t]
  else:
    for i, n in enumerate(ns):
      if n > t: break
      yield from decompose(t - n, k - 1, ns[i:], ss + [n])

# can we make total <t> with remaining dominoes <d>
def solve(t, d, ss=[]):
  if t == 0:
    yield ss, d
  else:  
    for dom, cnt in d.items():
      if cnt < 1: continue
      if dom > t: break
      # domino sums must not be decreasing
      if ss and dom < ss[-1]: continue
      # decrement counter
      d_ = {k: v if k != dom else v - 1 for k, v in d.items()}
      yield from solve(t - dom, d_, ss + [dom])
  
# can we make <k> cubes with remaining dominoes?
def make(cs, k, d, ss=[]):
  if k == 0:
    yield ss
  else:
    # try to make cs[0] with remaining dominoes
    for x, d_ in solve(cs[0], d):
      # if we have two of the same cubes then demand an order
      if not ss or sum(ss[-1]) != cs[0] or x >= ss[-1]:
        yield from make(cs[1:], k - 1, d_, ss + [x])
    
# dictionary of number of dominoes per possible sum
d = {k: sum([a + b == k for a, b in dominoes]) for k in range(1, 13)}
  
cbs = []
# collect positive cubes
n = 1 
while(n ** 3 + 5 <= n_spots):
  cbs.append(n**3)
  n += 1

ans = []
mx = 0

# play another round of discarding a non-blank domino
def play(d, spots, sols, lev=0, ss=[]):
  global mx, ans
  if lev > mx:
    ans = []
  if lev >= mx:  
    mx = lev
    # store examples for the maximum
    ans.append([x for x in sols if x])  
  
  # deepcopy intermediate solutions
  sols_ = [x.copy() for x in sols]  
  
  # choose a non-blank domino to discard
  for discard in d.keys():
    # we have not used up all dominoes for this sum
    if d[discard] == 0: continue
    n = spots - discard
    d_ = {k: (v if k != discard else v - 1) for k, v in d.items()}
    for cs in decompose(n, 6, cbs):
      for cubes6 in make(cs, 6, d_):
        # we have found a way to distribute dominoes to six cubes
        sols_[lev] = [n, cubes6]
        # play another round
        play(d_, n, sols_, lev + 1, ss + [discard])
        break # try to discard another non-blank domino
      else:
        continue
      break

# keep playing rounds until no longer six cubes be formed
play(d, n_spots, [[] for _ in range(30)])

print("examples:")
remaining_spots = set()
for sols in ans:
  for i, x in enumerate(sols):
    if not x: continue
    (sm, lst) = x
    if x: print(sm, "-->", lst)
  remaining_spots.add(str(sols[-1][0]))  
  print()  
      
      
print("answer: number of dominoes discarded by Jack:", mx)
print("        remaining spots:", ' or '.join(remaining_spots))

100

101

102

# the 28 dominoes

dominoes = tuple((i, j) for i in range(7) for j in range(i, 7))

# the total number of spots

n_spots = sum(a + b for a, b in dominoes)

# make total spots <t> with <k> elements from list <ns>

def decompose(t, k, ns, ss=[]):

if k == 1:

if t in ns and t >= ss[-1]:

yield ss + [t]

else:

for i, n in enumerate(ns):

if n > t: break

yield from decompose(t - n, k - 1, ns[i:], ss + [n])

# can we make total <t> with remaining dominoes <d>

def solve(t, d, ss=[]):

if t == 0:

yield ss, d

else:

for dom, cnt in d.items():

if cnt < 1: continue

if dom > t: break

# domino sums must not be decreasing

if ss and dom < ss[-1]: continue

# decrement counter

d_ = {k: v if k != dom else v - 1 for k, v in d.items()}

yield from solve(t - dom, d_, ss + [dom])

# can we make <k> cubes with remaining dominoes?

def make(cs, k, d, ss=[]):

if k == 0:

yield ss

else:

# try to make cs[0] with remaining dominoes

for x, d_ in solve(cs[0], d):

# if we have two of the same cubes then demand an order

if not ss or sum(ss[-1]) != cs[0] or x >= ss[-1]:

yield from make(cs[1:], k - 1, d_, ss + [x])

# dictionary of number of dominoes per possible sum

d = {k: sum([a + b == k for a, b in dominoes]) for k in range(1, 13)}

cbs = []

# collect positive cubes

n = 1

while(n ** 3 + 5 <= n_spots):

cbs.append(n**3)

n += 1

ans = []

mx = 0

# play another round of discarding a non-blank domino

def play(d, spots, sols, lev=0, ss=[]):

global mx, ans

if lev > mx:

ans = []

if lev >= mx:

mx = lev

# store examples for the maximum

ans.append([x for x in sols if x])

# deepcopy intermediate solutions

sols_ = [x.copy() for x in sols]

# choose a non-blank domino to discard

for discard in d.keys():

# we have not used up all dominoes for this sum

if d[discard] == 0: continue

n = spots - discard

d_ = {k: (v if k != discard else v - 1) for k, v in d.items()}

for cs in decompose(n, 6, cbs):

for cubes6 in make(cs, 6, d_):

# we have found a way to distribute dominoes to six cubes

sols_[lev] = [n, cubes6]

# play another round

play(d_, n, sols_, lev + 1, ss + [discard])

break # try to discard another non-blank domino

else:

continue

break

# keep playing rounds until no longer six cubes be formed

play(d, n_spots, [[] for _ in range(30)])

print("examples:")

remaining_spots = set()

for sols in ans:

for i, x in enumerate(sols):

if not x: continue

(sm, lst) = x

if x: print(sm, "-->", lst)

remaining_spots.add(str(sols[-1][0]))

print()

print("answer: number of dominoes discarded by Jack:", mx)

print(" remaining spots:", ' or '.join(remaining_spots))

Frits permalink

@Brian, please delete this post.

Reply

Frits permalink

There are also other variations of domino distributions that have the same end result.
Domino (0, 0) has been ignored as we ares asked for a positive cube number of spots.

from collections import defaultdict

# make total spots <t> with <k> numbers from list <ns>
def decompose(t, k, ns, ss=[]):
  if k == 1:
    if t in ns and t >= ss[-1]:
      yield ss + [t]
  else:
    for i, n in enumerate(ns):
      if n > t: break
      yield from decompose(t - n, k - 1, ns[i:], ss + [n])

# can we make total <t> with remaining dominoes <d>
def determine_dominoes(t, d, ss=[]):
  if t == 0:
    yield ss, d
  else:  
    for dom, cnt in d.items():
      if cnt < 1: continue
      if dom > t: break
      # domino sums must not be decreasing
      if ss and dom < ss[-1]: continue
      # decrement counter
      d_ = {k: v if k != dom else v - 1 for k, v in d.items()}
      yield from determine_dominoes(t - dom, d_, ss + [dom])
  
# can we make <k> cubes from <cs> with remaining dominoes?
def make(cs, k, d, ss=[]):
  if k == 0:
    yield ss
  else:
    # try to make cs[0] with remaining dominoes
    for x, d_ in determine_dominoes(cs[0], d):
      # if we have two of the same cubes then demand an order
      if not ss or sum(ss[-1]) != cs[0] or x >= ss[-1]:
        yield from make(cs[1:], k - 1, d_, ss + [x])
    
# play a round of discarding a non-blank domino
def play(d, spots, sols, lev=0, ss=[]):
  global mx, answs
  if lev > mx:
    answs = []
    mx = lev
  if lev >= mx:  
    # store examples for the answer
    answs.append([x for x in sols if x])  
  
  # deepcopy intermediate solutions
  sols_ = [x.copy() for x in sols]  
  
  # choose a non-blank domino to discard
  for discard in d.keys():
    # we should not have used up all dominoes for this sum
    if d[discard] == 0: continue
    n = spots - discard
    # with new total <n> it must be possible to form 6 cubes
    if n not in six_cubes: continue
    # decrement counter
    d_ = {k: (v if k != discard else v - 1) for k, v in d.items()}
    
    # find a way to make <n> with 6 cubes
    for cs in six_cubes[n]:
      # find dominoes for each of the 6 cubes
      for dominoes_per_cube in make(cs, 6, d_):
        # store intermediate solution
        sols_[lev] = [n, dominoes_per_cube]
        # play another round
        play(d_, n, sols_, lev + 1, ss + [discard])
        break # try to discard another non-blank domino
      else:
        continue
      break

answs, mx = [], 0

# the 28 dominoes
dominoes = tuple((i, j) for i in range(7) for j in range(i, 7))
# the total number of spots
n_spots = sum(a + b for a, b in dominoes)
      
# dictionary of number of dominoes per possible positive sum
d = {k: sum([a + b == k for a, b in dominoes]) for k in range(1, 13)}  
      
# generate positive cubes
cbs, n = [], 1      
while(n ** 3 + 5 <= n_spots):
  cbs.append(n**3)
  n += 1
  
# determine all total number of spots for which six cubes can be formed
six_cubes = defaultdict(list)
for n in range(6, n_spots):
  # find a way to make <n> with 6 cubes
  for cs in decompose(n, 6, cbs):
    six_cubes[n].append(cs)

# keep playing rounds until no longer six cubes can be formed
play(d, n_spots, [[] for _ in range(len(dominoes))])

print("examples:")
remaining_spots = set()
for ans in answs:
  for i, x in enumerate(ans):
    if not x: break
    (sm, lst) = x
    if x: print(sm, "-->", lst)
  remaining_spots.add(str(ans[-1][0]))  
  print()  
      
print("answer: number of dominoes discarded by Jack:", mx)
print("        remaining spots:", ' or '.join(remaining_spots))

100

101

102

103

104

105

106

107

108

109

110

111

112

113

from collections import defaultdict

# make total spots <t> with <k> numbers from list <ns>

def decompose(t, k, ns, ss=[]):

if k == 1:

if t in ns and t >= ss[-1]:

yield ss + [t]

else:

for i, n in enumerate(ns):

if n > t: break

yield from decompose(t - n, k - 1, ns[i:], ss + [n])

# can we make total <t> with remaining dominoes <d>

def determine_dominoes(t, d, ss=[]):

if t == 0:

yield ss, d

else:

for dom, cnt in d.items():

if cnt < 1: continue

if dom > t: break

# domino sums must not be decreasing

if ss and dom < ss[-1]: continue

# decrement counter

d_ = {k: v if k != dom else v - 1 for k, v in d.items()}

yield from determine_dominoes(t - dom, d_, ss + [dom])

# can we make <k> cubes from <cs> with remaining dominoes?

def make(cs, k, d, ss=[]):

if k == 0:

yield ss

else:

# try to make cs[0] with remaining dominoes

for x, d_ in determine_dominoes(cs[0], d):

# if we have two of the same cubes then demand an order

if not ss or sum(ss[-1]) != cs[0] or x >= ss[-1]:

yield from make(cs[1:], k - 1, d_, ss + [x])

# play a round of discarding a non-blank domino

def play(d, spots, sols, lev=0, ss=[]):

global mx, answs

if lev > mx:

answs = []

mx = lev

if lev >= mx:

# store examples for the answer

answs.append([x for x in sols if x])

# deepcopy intermediate solutions

sols_ = [x.copy() for x in sols]

# choose a non-blank domino to discard

for discard in d.keys():

# we should not have used up all dominoes for this sum

if d[discard] == 0: continue

n = spots - discard

# with new total <n> it must be possible to form 6 cubes

if n not in six_cubes: continue

# decrement counter

d_ = {k: (v if k != discard else v - 1) for k, v in d.items()}

# find a way to make <n> with 6 cubes

for cs in six_cubes[n]:

# find dominoes for each of the 6 cubes

for dominoes_per_cube in make(cs, 6, d_):

# store intermediate solution

sols_[lev] = [n, dominoes_per_cube]

# play another round

play(d_, n, sols_, lev + 1, ss + [discard])

break # try to discard another non-blank domino

else:

continue

break

answs, mx = [], 0

# the 28 dominoes

dominoes = tuple((i, j) for i in range(7) for j in range(i, 7))

# the total number of spots

n_spots = sum(a + b for a, b in dominoes)

# dictionary of number of dominoes per possible positive sum

d = {k: sum([a + b == k for a, b in dominoes]) for k in range(1, 13)}

# generate positive cubes

cbs, n = [], 1

while(n ** 3 + 5 <= n_spots):

cbs.append(n**3)

n += 1

# determine all total number of spots for which six cubes can be formed

six_cubes = defaultdict(list)

for n in range(6, n_spots):

# find a way to make <n> with 6 cubes

for cs in decompose(n, 6, cbs):

six_cubes[n].append(cs)

# keep playing rounds until no longer six cubes can be formed

play(d, n_spots, [[] for _ in range(len(dominoes))])

print("examples:")

remaining_spots = set()

for ans in answs:

for i, x in enumerate(ans):

if not x: break

(sm, lst) = x

if x: print(sm, "-->", lst)

remaining_spots.add(str(ans[-1][0]))

print()

print("answer: number of dominoes discarded by Jack:", mx)

print(" remaining spots:", ' or '.join(remaining_spots))

Sunday Times Teaser 3289 – Spot Check

by Peter Good

Published Sunday October 05 2025 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta