Sunday Times Teaser 3293 – Three Sisters

by BRG on November 2, 2025

by Victor Bryant

Published Sunday November 02 2025

I have three granddaughters Jay, Kay and Elle. I set Jay and Kay a test and asked each of them to produce a list of positive numbers that used just nine digits with no digit occurring more than once. I wanted the majority of the numbers in each list to be odd and the majority of the numbers in each list to be perfect squares.

Jay’s list (which contained more numbers than Kay’s) added up to give the year of Elle’s birth, whereas Kay’s list added up to give the year in which Elle will be 25.

In one of the lists the highest number was a perfect square.

What (in increasing order) were the numbers in that list?

From → Uncategorized

6 Comments Leave one →

BRG permalink

This solution is very slow without an arbitrary limit on the number of digits used in non-squares but it completes in a sensible time with a reasonable limit of no more than five digits used in this way.


from itertools import combinations, permutations, product
from collections import defaultdict

sqrs = list(n * n for n in range(1, 32) if len((t := str(n * n))) == len(set(t)))

# convert digits to numbers and vice versa
dgts_to_nbr = lambda dgts: int(''.join(map(str, dgts)))
nbr_to_dgts = lambda nbr: tuple(int(d) for d in str(nbr))

# find lists of square numbers that can be made from
# sets of digits with no repeated digits; return the
# lists and the remaining unused digits
def find_squares(sqrs, ns=()):
  # consider possible list lengths
  for nsq in range(2, 6):
    # and possible choices of squares
    for sqs in combinations(sqrs, nsq):
      dgts = ''.join(str(s) for s in sqs)
      # there must be no repeated digits
      if len(dgts) == len(set(dgts)):
        rd = ''.join(sorted(set('0123456789').difference(dgts)))
        yield sqs, tuple(int(d) for d in rd)

# find lists of numbers that can be made from the digits in <dgts>
def find_numbers(ns, dgts, lmt, ss=()):
  # there must be one digit left
  if len(dgts) == 1:
    # the sum must not be greater than the maximum expected sum
    if sum(ss) <= lmt:
      yield ss, dgts.pop()
  else:
    # consider how many numbers to make from the digits
    for nd in range(1, len(dgts)):
      # consider all possible numbers of this length
      for rd in permutations(dgts, nd):
        if rd[0]:
          n = dgts_to_nbr(rd)
          # continue to add further numbers if possible
          yield from find_numbers(ns - 1, dgts.difference(rd), lmt, ss + (n,))

# store number lists for Jay and Kay based on their birthday ranges
jd, kd = defaultdict(list), defaultdict(list)

# consider possible sequences of squares 
for sq, rd in find_squares(sqrs):
  # limit the maximum length of the digits not in squares
  if len(rd) > 5:
    continue
  # and then add numbers made from the remaining digits
  for ns, d in find_numbers(6 - len(sq), set(rd), 2050 - sum(sq)):
    # there must be more squares than non-squares
    if len(sq) > len(ns):
      nbrs = sq + ns
      # there must be more odd numbers than even ones
      if 2 * sum(n & 1 for n in nbrs) > len(nbrs):
        sn = tuple(sorted(nbrs))
        sm = sum(sn)
        if 2000 <= sm <= 2025:
          jd[sm].append(sn)
        if 2025 <= sm <= 2050:
          kd[sm - 25].append(sn)
         
# consider matching years for Jay and Kay
for ck in jd.keys() & kd.keys():
  # consider all pairings for Jay's and Kay's possible sequences
  for js, ks in product(jd[ck], kd[ck]):
    # Jay's list is longer and one has a square in its last position
    if len(js) > len(ks) and not {js[-1], ks[-1]}.isdisjoint(sqrs):
      print(f"{js}->{ck}  {ks}->{ck + 25}")

from itertools import combinations, permutations, product

from collections import defaultdict

sqrs = list(n * n for n in range(1, 32) if len((t := str(n * n))) == len(set(t)))

# convert digits to numbers and vice versa

dgts_to_nbr = lambda dgts: int(''.join(map(str, dgts)))

nbr_to_dgts = lambda nbr: tuple(int(d) for d in str(nbr))

# find lists of square numbers that can be made from

# sets of digits with no repeated digits; return the

# lists and the remaining unused digits

def find_squares(sqrs, ns=()):

# consider possible list lengths

for nsq in range(2, 6):

# and possible choices of squares

for sqs in combinations(sqrs, nsq):

dgts = ''.join(str(s) for s in sqs)

# there must be no repeated digits

if len(dgts) == len(set(dgts)):

rd = ''.join(sorted(set('0123456789').difference(dgts)))

yield sqs, tuple(int(d) for d in rd)

# find lists of numbers that can be made from the digits in <dgts>

def find_numbers(ns, dgts, lmt, ss=()):

# there must be one digit left

if len(dgts) == 1:

# the sum must not be greater than the maximum expected sum

if sum(ss) <= lmt:

yield ss, dgts.pop()

else:

# consider how many numbers to make from the digits

for nd in range(1, len(dgts)):

# consider all possible numbers of this length

for rd in permutations(dgts, nd):

if rd[0]:

n = dgts_to_nbr(rd)

# continue to add further numbers if possible

yield from find_numbers(ns - 1, dgts.difference(rd), lmt, ss + (n,))

# store number lists for Jay and Kay based on their birthday ranges

jd, kd = defaultdict(list), defaultdict(list)

# consider possible sequences of squares

for sq, rd in find_squares(sqrs):

# limit the maximum length of the digits not in squares

if len(rd) > 5:

continue

# and then add numbers made from the remaining digits

for ns, d in find_numbers(6 - len(sq), set(rd), 2050 - sum(sq)):

# there must be more squares than non-squares

if len(sq) > len(ns):

nbrs = sq + ns

# there must be more odd numbers than even ones

if 2 * sum(n & 1 for n in nbrs) > len(nbrs):

sn = tuple(sorted(nbrs))

sm = sum(sn)

if 2000 <= sm <= 2025:

jd[sm].append(sn)

if 2025 <= sm <= 2050:

kd[sm - 25].append(sn)

# consider matching years for Jay and Kay

for ck in jd.keys() & kd.keys():

# consider all pairings for Jay's and Kay's possible sequences

for js, ks in product(jd[ck], kd[ck]):

# Jay's list is longer and one has a square in its last position

if len(js) > len(ks) and not {js[-1], ks[-1]}.isdisjoint(sqrs):

print(f"{js}->{ck} {ks}->{ck + 25}")

I believe possible years for Jay and Kay are as follows:


The possible number sequences for Jay and Kay are:
JAY:
2000 [(256, 841, 903), (529, 630, 841)]
2004 [(256, 841, 907)]
2007 [(529, 637, 841)]
2008 [(49, 256, 1703)]
2025 [(4, 9, 625, 1387)]
KAY:
2000 [(4, 9, 625, 1387)]
2005 [(36, 289, 1705)]
2009 [(256, 841, 937)]
2015 [(529, 670, 841)]
2018 [(529, 673, 841)]
2019 [(49, 625, 1370)]
2025 [(361, 784, 905), (305, 784, 961)]

The possible number sequences for Jay and Kay are:

JAY:

2000 [(256, 841, 903), (529, 630, 841)]

2004 [(256, 841, 907)]

2007 [(529, 637, 841)]

2008 [(49, 256, 1703)]

2025 [(4, 9, 625, 1387)]

KAY:

2000 [(4, 9, 625, 1387)]

2005 [(36, 289, 1705)]

2009 [(256, 841, 937)]

2015 [(529, 670, 841)]

2018 [(529, 673, 841)]

2019 [(49, 625, 1370)]

2025 [(361, 784, 905), (305, 784, 961)]

Jim Randell permalink

@Brian: Some of the candidates you give only use 8 digits.

Reply
- BRG permalink
  
  Thanks Jim. I am making too many errors these days ;-(
  
  Reply
John Z. permalink

Leaving out the 8 digit lists and those that sum to 2000 which my code considers to be out of range (changed easily enough by replacing 2000 with 1999 in line 12 of my code), our 9 digit lists coincide.

Reply

JohnZ permalink


from itertools import combinations, permutations, product

# perfect squares without repeated digits
psq = {i * i for i in range(1, 32) if len(set(str(i * i))) == len(str(i * i))}

# si: index into nums, resn: the result numbers, resd: the digits in the result
def solver(si, resn, resd):
  # does number of digits used = 9?
  if len(resd) == 9:
    # Elle's dob is less than 25 years ago; odd numbers must be majority
    if sum(resn) > 2000 and sum(q & 1 for q in resn) * 2 > len(resn): 
      yield tuple(sorted(resn))
  # verify that perfect squares will remain a majority in list
  elif nsq * 2 > len(resn) + 1:
    for i, n in enumerate(nums[si:]):
      # sum must be less than max year & no repeat of digits & no overshoot
      if 2051 > sum(resn) + n[0] and not resd & n[1] and 10 > len(resd | n[1]):
        yield from solver(si + i + 1, resn + (n[0],), resd | n[1])
      
# potential solutions indexed by: no square at end (0), square at end (1)
sols = [[], []]
# get 2, 3, 4, 5 perfect squares to be used in lists
for nsq in range(2, 6):
  for sc in combinations(psq, nsq):
    cs = ''.join(map(str, sc)) # inspired by Brian's use of the map function
    css = set(cs)

    # check for sums of psq ok; no duplicate characters; .lt. 9 diff digits
    if sum(sc) > 2000 or len(cs) > len(css) or len(cs) > 8:
      continue
    # other numbers made from digits not in perfect squares
    nums = tuple((nn, set(n)) for j in range(1, 5)
           for n in permutations(set('0123456789') - css, j)
           if n[0] != '0' and 2000 > (nn := int(''.join(n))) and nn not in psq)
    
    # find lists of Jay's and Kay's numbers, save indexed on 'square at end'
    for sol in solver(0, sc, css):
      sols[sol[-1] in psq].append(sol)
      
# consider (not square on end) x (square) pairs of the lists found for printout
for jk in product(*sols):
  if len(jk[0]) != len(jk[1]):
    # Jay’s list (which contained more numbers than Kay’s)
    Kay, Jay = sorted(jk, key = len)
    sk, sj = sum(Kay), sum(Jay)
    # apply the last remaining Teaser constraint
    if sk - sj == 25:
      print('Jay:', Jay, sj, '  Kay:', Kay, sk)

from itertools import combinations, permutations, product

# perfect squares without repeated digits

psq = {i * i for i in range(1, 32) if len(set(str(i * i))) == len(str(i * i))}

# si: index into nums, resn: the result numbers, resd: the digits in the result

def solver(si, resn, resd):

# does number of digits used = 9?

if len(resd) == 9:

# Elle's dob is less than 25 years ago; odd numbers must be majority

if sum(resn) > 2000 and sum(q & 1 for q in resn) * 2 > len(resn):

yield tuple(sorted(resn))

# verify that perfect squares will remain a majority in list

elif nsq * 2 > len(resn) + 1:

for i, n in enumerate(nums[si:]):

# sum must be less than max year & no repeat of digits & no overshoot

if 2051 > sum(resn) + n[0] and not resd & n[1] and 10 > len(resd | n[1]):

yield from solver(si + i + 1, resn + (n[0],), resd | n[1])

# potential solutions indexed by: no square at end (0), square at end (1)

sols = [[], []]

# get 2, 3, 4, 5 perfect squares to be used in lists

for nsq in range(2, 6):

for sc in combinations(psq, nsq):

cs = ''.join(map(str, sc)) # inspired by Brian's use of the map function

css = set(cs)

# check for sums of psq ok; no duplicate characters; .lt. 9 diff digits

if sum(sc) > 2000 or len(cs) > len(css) or len(cs) > 8:

continue

# other numbers made from digits not in perfect squares

nums = tuple((nn, set(n)) for j in range(1, 5)

for n in permutations(set('0123456789') - css, j)

if n[0] != '0' and 2000 > (nn := int(''.join(n))) and nn not in psq)

# find lists of Jay's and Kay's numbers, save indexed on 'square at end'

for sol in solver(0, sc, css):

sols[sol[-1] in psq].append(sol)

# consider (not square on end) x (square) pairs of the lists found for printout

for jk in product(*sols):

if len(jk[0]) != len(jk[1]):

# Jay’s list (which contained more numbers than Kay’s)

Kay, Jay = sorted(jk, key = len)

sk, sj = sum(Kay), sum(Jay)

# apply the last remaining Teaser constraint

if sk - sj == 25:

print('Jay:', Jay, sj, ' Kay:', Kay, sk)

Frits permalink

Using itertools.combinations() was less efficient than select().


from collections import defaultdict
from functools import cache

# check for different digits 
check = lambda s: len(set(s)) == len(s)

nums = {str(n) for n in range(1, 2051) if check(str(n))}
sqs = [i2 for i in range(1, 45) if (i2 := str(i * i)) in nums]
dgts = set("0123456789")

@cache
# return numbers from <nums> that can be made from digits in <ds>
def filter(ds):
  return [x for x in nums if set(ds).issuperset(x)]

# generate <k> increasing numbers with minimum <m> that add to <t> 
# with digits from <ds> leaving one digit unused
def decompose(t, k, m=1, ds=set(), ss=[]):
  if k == 1:
    if (st := str(t)) in nums and (not ss or t > ss[-1]):
      if ds.issuperset(st) and len(ds - set(st)) == 1:
        yield ss + [t]
  else:
    # process numbers based on remaining digits
    for n in [x for x in filter(tuple(ds)) if m <= int(x) <= t // k]:
      i = int(n)
      yield from decompose(t - i, k - 1, i + 1, ds - set(n), ss + [i])

# select <k> elements out of <s> while not reusing any digits
def select(s, k, ds=set(), ss=[]):
  if k == 0: 
    # not using all digits
    if len(ds) < 10: 
      yield [int(x) for x in ss]
  else:
    for i, n in enumerate(s):
      if ds.isdisjoint(n):
        yield from select(s[i + 1:], k - 1, ds | set(n), ss + [n])

# find maximum of <m> numbers in the list for a specific year 
# Jay: 2000-2025, Kay: 2025-2050
def solve(yyyy, m):
  # Kay needs to have at least 3 numbers so Jay has at least 4 numbers
  mn_sqs = 3      if yyyy == 2000 else 2
  rng = range(26) if yyyy == 2000 else [0]
  m_yyyy = 2025   if yyyy == 2000 else yyyy
  # choose the number of squares 
  for n_sqs in range(mn_sqs, min(m + 1, 6)):
    # get squares for Jay or Kay
    for sel_sqs in select(sqs, n_sqs):
       # not overshooting
       if (t := sum(sel_sqs)) > m_yyyy: continue
       
       # remaining digits string
       r = ''.join(dgts.difference(''.join(str(x) for x in sel_sqs)))
       
       # there should be enough remaining digits to make yyyy - t  
       if (ln1 := len(str(yyyy - t))) >= (lnr := len(r)): continue  
       
       if ln1 == lnr - 1: 
         # exactly one extra number is needed with length len(r) - 1
         for inc in rng:
           if set(r).issuperset(str(yyyy - t + inc)): break
         else: # no break
           continue  
       
       # 975 + 864 = 1839
       if 1839 < yyyy - t < 2000 - 25  and "1" not in r: continue 
       # 987 + 65 = 1052
       if 1052 < yyyy - t < 1840:
         # either "1" is still available or we must form two xxx numbers
         if len(r) < 6 and "1" not in r: continue 
       
       # check years 2000 - 2025 for Jay, one year for Kay
       for inc in rng:
         # try to distribute remaining digits over <k> numbers
         for k in range(1, min(n_sqs, m - n_sqs + 1)):
           for oth in decompose(yyyy - t + inc, k, 1, set(r)):
             ns = sel_sqs + oth
             # majority odd numbers
             if 2 * sum(x % 2 for x in ns) <= len(ns): continue
             yield yyyy + inc, ns

# find Jay's list first as it is more restrictive
for yyyy_jay, jay in solve(2000, 99):
  for yyyy_kay, kay in solve(yyyy_jay + 25, len(jay) - 1):
    # in one of the lists the highest number was a perfect square.
    if sum(jamiroquai := [str(max(jay)) in sqs, str(max(kay)) in sqs]) == 1:
      print("answer:", sorted(jay) if jamiroquai[0] else sorted(kay))

from collections import defaultdict

from functools import cache

# check for different digits

check = lambda s: len(set(s)) == len(s)

nums = {str(n) for n in range(1, 2051) if check(str(n))}

sqs = [i2 for i in range(1, 45) if (i2 := str(i * i)) in nums]

dgts = set("0123456789")

@cache

# return numbers from <nums> that can be made from digits in <ds>

def filter(ds):

return [x for x in nums if set(ds).issuperset(x)]

# generate <k> increasing numbers with minimum <m> that add to <t>

# with digits from <ds> leaving one digit unused

def decompose(t, k, m=1, ds=set(), ss=[]):

if k == 1:

if (st := str(t)) in nums and (not ss or t > ss[-1]):

if ds.issuperset(st) and len(ds - set(st)) == 1:

yield ss + [t]

else:

# process numbers based on remaining digits

for n in [x for x in filter(tuple(ds)) if m <= int(x) <= t // k]:

i = int(n)

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

# select <k> elements out of <s> while not reusing any digits

def select(s, k, ds=set(), ss=[]):

if k == 0:

# not using all digits

if len(ds) < 10:

yield [int(x) for x in ss]

else:

for i, n in enumerate(s):

if ds.isdisjoint(n):

yield from select(s[i + 1:], k - 1, ds | set(n), ss + [n])

# find maximum of <m> numbers in the list for a specific year

# Jay: 2000-2025, Kay: 2025-2050

def solve(yyyy, m):

# Kay needs to have at least 3 numbers so Jay has at least 4 numbers

mn_sqs = 3 if yyyy == 2000 else 2

rng = range(26) if yyyy == 2000 else [0]

m_yyyy = 2025 if yyyy == 2000 else yyyy

# choose the number of squares

for n_sqs in range(mn_sqs, min(m + 1, 6)):

# get squares for Jay or Kay

for sel_sqs in select(sqs, n_sqs):

# not overshooting

if (t := sum(sel_sqs)) > m_yyyy: continue

# remaining digits string

r = ''.join(dgts.difference(''.join(str(x) for x in sel_sqs)))

# there should be enough remaining digits to make yyyy - t

if (ln1 := len(str(yyyy - t))) >= (lnr := len(r)): continue

if ln1 == lnr - 1:

# exactly one extra number is needed with length len(r) - 1

for inc in rng:

if set(r).issuperset(str(yyyy - t + inc)): break

else: # no break

continue

# 975 + 864 = 1839

if 1839 < yyyy - t < 2000 - 25 and "1" not in r: continue

# 987 + 65 = 1052

if 1052 < yyyy - t < 1840:

# either "1" is still available or we must form two xxx numbers

if len(r) < 6 and "1" not in r: continue

# check years 2000 - 2025 for Jay, one year for Kay

for inc in rng:

# try to distribute remaining digits over <k> numbers

for k in range(1, min(n_sqs, m - n_sqs + 1)):

for oth in decompose(yyyy - t + inc, k, 1, set(r)):

ns = sel_sqs + oth

# majority odd numbers

if 2 * sum(x % 2 for x in ns) <= len(ns): continue

yield yyyy + inc, ns

# find Jay's list first as it is more restrictive

for yyyy_jay, jay in solve(2000, 99):

for yyyy_kay, kay in solve(yyyy_jay + 25, len(jay) - 1):

# in one of the lists the highest number was a perfect square.

if sum(jamiroquai := [str(max(jay)) in sqs, str(max(kay)) in sqs]) == 1:

print("answer:", sorted(jay) if jamiroquai[0] else sorted(kay))

Sunday Times Teaser 3293 – Three Sisters

by Victor Bryant

Published Sunday November 02 2025

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta