Sunday Times Teaser 3329 – Ten Cards

by BRG on 12 July 2026

by Howard Williams

Published Sunday July 12 2026 (link)

I have ten cards on which are written 20 different positive integers, with one integer on each side of the cards. The total of the integers on the front of the ten cards equals the total of the integers on the back. The total of the integers on each card is also the same.

The numbers on the front of the first nine cards are 2, 15, 17, 21, 24, 31, 35, 36 and 44. If I told you how many prime numbers are on the cards you should be able to tell me the two numbers on the tenth card.

In ascending order, what are the numbers on card ten?

From → Uncategorized

6 Comments Leave one →

BRG permalink


# primes below one hundred
prms = {2, 3, 5, 7} | {n for n in range(11, 99, 2) if n % 3 and n % 5 and n % 7}

# the numbers on the front of nine of the ten cards
fronts = {2, 15, 17, 21, 24, 31, 35, 36, 44}

# with N as the sum of the numnbers on each card and X on the front
# of card 10 we obtain: 2.(225 + X) = 10.N -> N = 45 + X / 5

# index the last card values on the numbers of primes on the cards
np2s = dict()

# with x as X // 5 (N - X = 45 - 4.x -> x < 12)
for x in range(1, 12):
  X, N = 5 * x, 45 + x
  # collect the twenty numbers on the cards and ensure all are different
  if len(nbrs := fronts | {N - n for n in fronts} | {X, N - X}) == 20:
    np = sum(n in prms for n in nbrs)
    np2s[np] = np2s.get(np, []) + [sorted((X, N - X))]

# output any unique solutions
for k, vs in np2s.items():
  (f, s), *_ = vs
  if not _:
    print(f"The numbers on card ten are {f} and {s}.")

# primes below one hundred

prms = {2, 3, 5, 7} | {n for n in range(11, 99, 2) if n % 3 and n % 5 and n % 7}

# the numbers on the front of nine of the ten cards

fronts = {2, 15, 17, 21, 24, 31, 35, 36, 44}

# with N as the sum of the numnbers on each card and X on the front

# of card 10 we obtain: 2.(225 + X) = 10.N -> N = 45 + X / 5

# index the last card values on the numbers of primes on the cards

np2s = dict()

# with x as X // 5 (N - X = 45 - 4.x -> x < 12)

for x in range(1, 12):

X, N = 5 * x, 45 + x

# collect the twenty numbers on the cards and ensure all are different

if len(nbrs := fronts | {N - n for n in fronts} | {X, N - X}) == 20:

np = sum(n in prms for n in nbrs)

np2s[np] = np2s.get(np, []) + [sorted((X, N - X))]

# output any unique solutions

for k, vs in np2s.items():

(f, s), *_ = vs

if not _:

print(f"The numbers on card ten are {f} and {s}.")

John Z. permalink


# get primes up to 100
p = {3, 5, 7}
p |= {2} | {n for n in range(11, 100, 2) if all(n % x for x in p)}

# the front of the first nine cards (which contain primes 2, 17 and 31)
f9 = (2, 15, 17, 21, 24, 31, 35, 36, 44)
f9s = set(f9)
f9t = sum(f9)

# dictionary of front and back values of tenth card indexed by number of primes
npr10 = dict()

# consider total of front and back of each card
for tfb in range(max(f9) + 1, 100):

  # values on the back of the first 9 cards
  b9 = [tfb - f for f in f9]
  b9s = set(b9)
  b9t = 9 * tfb - f9t # total of 9 back values
  
  # difference between the totals of the front 9 and back 9
  diff = abs(f9t - b9t) # also = 2 * f9t - 9 * tfb

  # the values of the front and back of the tenth card
  f10b10 = ((tfb - diff) // 2, (tfb + diff) // 2)
  
  # all cards must be positive and different
  if min(f10b10) > 0 and len(ac := (f9s | b9s | set(f10b10))) == 20:
    
    # the number of primes in the set of all cards
    np = len(ac & p)
    npr10[np] = npr10.get(np, []) + [f10b10]

# find unique dictionary value
for k, (b, *_) in npr10.items():
  if (not _):
    print(k, "primes, answer:", *sorted(b))

# get primes up to 100

p = {3, 5, 7}

p |= {2} | {n for n in range(11, 100, 2) if all(n % x for x in p)}

# the front of the first nine cards (which contain primes 2, 17 and 31)

f9 = (2, 15, 17, 21, 24, 31, 35, 36, 44)

f9s = set(f9)

f9t = sum(f9)

# dictionary of front and back values of tenth card indexed by number of primes

npr10 = dict()

# consider total of front and back of each card

for tfb in range(max(f9) + 1, 100):

# values on the back of the first 9 cards

b9 = [tfb - f for f in f9]

b9s = set(b9)

b9t = 9 * tfb - f9t # total of 9 back values

# difference between the totals of the front 9 and back 9

diff = abs(f9t - b9t) # also = 2 * f9t - 9 * tfb

# the values of the front and back of the tenth card

f10b10 = ((tfb - diff) // 2, (tfb + diff) // 2)

# all cards must be positive and different

if min(f10b10) > 0 and len(ac := (f9s | b9s | set(f10b10))) == 20:

# the number of primes in the set of all cards

np = len(ac & p)

npr10[np] = npr10.get(np, []) + [f10b10]

# find unique dictionary value

for k, (b, *_) in npr10.items():

if (not _):

print(k, "primes, answer:", *sorted(b))

Frits permalink

@John,

Nice trick at lines 36 and 37.

You can also use “f10b10 = (5 * tfb – f9t, f9t – 4 * tfb)”.

Why do you use an upper limit of 99 for variable tfb?

Reply
- John Z. permalink
  
  The value of 99 is arbitrary. The exact upper limit of tfb is f9t // 4 or 56. Above this limit one of the values of the tenth card becomes negative. A more compact version with the algebra worked out is posted below.
  
  The ‘trick’ at lines 36 and 37 is a variant of Brian’s lines 25-27 in Teaser 3228.
  
  Reply

John Z. permalink


# get primes up to 100
p = {3, 5, 7}
p |= {2} | {n for n in range(11, 100, 2) if all(n % x for x in p)}

# the front of the first nine cards (which contain primes 2, 17 and 31)
f9 = (2, 15, 17, 21, 24, 31, 35, 36, 44)
f9s, f9t = set(f9), sum(f9)

# dictionary of front and back values of tenth card indexed by number of primes
npr10 = dict()

# consider total of front and back of each card; < f9t // 4 for values > 0
for tfb in range(max(f9) + 2, f9t // 4 + 1):

  # values on the back of the first 9 cards
  b9 = [tfb - f for f in f9]
  b9s, b9t = set(b9), 9 * tfb - f9t # set of and total of 9 back values

  # the values of the front and back of the tenth card
  f10b10 = (5 * tfb - f9t, f9t - 4 * tfb)
  
  # all cards must be different (and positive)
  if len(ac := (f9s | b9s | set(f10b10))) == 20:
    
    # np is the number of primes in the set of all cards
    npr10[np] = npr10.get(np := len(ac & p), []) + [f10b10]

# find unique dictionary value
for k, (b, *_) in npr10.items():
  if (not _):
    print(k, "primes, answer:", *sorted(b))

# get primes up to 100

p = {3, 5, 7}

p |= {2} | {n for n in range(11, 100, 2) if all(n % x for x in p)}

# the front of the first nine cards (which contain primes 2, 17 and 31)

f9 = (2, 15, 17, 21, 24, 31, 35, 36, 44)

f9s, f9t = set(f9), sum(f9)

# dictionary of front and back values of tenth card indexed by number of primes

npr10 = dict()

# consider total of front and back of each card; < f9t // 4 for values > 0

for tfb in range(max(f9) + 2, f9t // 4 + 1):

# values on the back of the first 9 cards

b9 = [tfb - f for f in f9]

b9s, b9t = set(b9), 9 * tfb - f9t # set of and total of 9 back values

# the values of the front and back of the tenth card

f10b10 = (5 * tfb - f9t, f9t - 4 * tfb)

# all cards must be different (and positive)

if len(ac := (f9s | b9s | set(f10b10))) == 20:

# np is the number of primes in the set of all cards

npr10[np] = npr10.get(np := len(ac & p), []) + [f10b10]

# find unique dictionary value

for k, (b, *_) in npr10.items():

if (not _):

print(k, "primes, answer:", *sorted(b))

GeoffR permalink

I used AI to fix the range of front and back card totals before writing the program.


from number_theory import is_prime

from collections import defaultdict
nums = defaultdict(list)

from collections import Counter

# Sum of front of nine cards = sum (2, 15, 17, 21, 24, 31, 35, 36, 44) = 225

# Let S = front and back total on one card
# Sum of 20 numbers = 10S

# Front total = Back total = 5S
# Front of card 10 = 5S - 225

# Back of card 10 = S - front of card 10 = S - (5S - 225)
# Back of card 10 = 225 - 4S

# 5S - 225 >= 1 gives S >= 46
# 225 - 4S >= 1 guves S <= 56

# check possible ranges of total front and back totals
for S in range( 46, 56+1):
  bs_cnt = 0
  fs_cnt = 0
  
  card10_front = 5 * S - 225
  front_nums = [2, 15, 17, 21, 24, 31, 35, 36, 44, 5*S-225]

  card10_back = 225 - 4 * S
  back_nums = [S-2, S-15, S-17, S-21, S-24, S-31,
               S-35, S-36, S-44, 225-4*S]
  
  # check ten cards have 20 different positive integers, front and back
  combined = list(set(front_nums) | set(back_nums)) 
  if len(combined) != 20:
    continue
  
  # front card number primes
  for fs in front_nums:
    if is_prime (fs):
      fs_cnt += 1
        
  # back card number primes
  for bs in back_nums:
    if is_prime(bs):
      bs_cnt += 1

  # add values to dictionary
  nums[S] = [fs_cnt, bs_cnt, front_nums, back_nums]
  
  # find the sum (fs_cnt + bs_cnt) that occurs exactly once across all S totals
  sum_counts = Counter(v[0] + v[1] for v in nums.values())

  
# find unique sum of front and back cards
unique_S = [k for k, v in nums.items() if sum_counts[v[0] + v[1]] == 1]

for S in unique_S:
  fs_cnt, bs_cnt, front_nums, back_nums = nums[S]
  Card10_front = front_nums[9]  # 10 cards
  Card10_back = back_nums[9]    

  C10_low, C10_high = sorted([Card10_front, Card10_back])
  print(f"S={S}, primes={fs_cnt + bs_cnt} no., Card 10 values = {C10_low}, {C10_high}")

from number_theory import is_prime

from collections import defaultdict

nums = defaultdict(list)

from collections import Counter

# Sum of front of nine cards = sum (2, 15, 17, 21, 24, 31, 35, 36, 44) = 225

# Let S = front and back total on one card

# Sum of 20 numbers = 10S

# Front total = Back total = 5S

# Front of card 10 = 5S - 225

# Back of card 10 = S - front of card 10 = S - (5S - 225)

# Back of card 10 = 225 - 4S

# 5S - 225 >= 1 gives S >= 46

# 225 - 4S >= 1 guves S <= 56

# check possible ranges of total front and back totals

for S in range( 46, 56+1):

bs_cnt = 0

fs_cnt = 0

card10_front = 5 * S - 225

front_nums = [2, 15, 17, 21, 24, 31, 35, 36, 44, 5*S-225]

card10_back = 225 - 4 * S

back_nums = [S-2, S-15, S-17, S-21, S-24, S-31,

S-35, S-36, S-44, 225-4*S]

# check ten cards have 20 different positive integers, front and back

combined = list(set(front_nums) | set(back_nums))

if len(combined) != 20:

continue

# front card number primes

for fs in front_nums:

if is_prime (fs):

fs_cnt += 1

# back card number primes

for bs in back_nums:

if is_prime(bs):

bs_cnt += 1

# add values to dictionary

nums[S] = [fs_cnt, bs_cnt, front_nums, back_nums]

# find the sum (fs_cnt + bs_cnt) that occurs exactly once across all S totals

sum_counts = Counter(v[0] + v[1] for v in nums.values())

# find unique sum of front and back cards

unique_S = [k for k, v in nums.items() if sum_counts[v[0] + v[1]] == 1]

for S in unique_S:

fs_cnt, bs_cnt, front_nums, back_nums = nums[S]

Card10_front = front_nums[9] # 10 cards

Card10_back = back_nums[9]

C10_low, C10_high = sorted([Card10_front, Card10_back])

print(f"S={S}, primes={fs_cnt + bs_cnt} no., Card 10 values = {C10_low}, {C10_high}")

Sunday Times Teaser 3329 – Ten Cards

by Howard Williams

Published Sunday July 12 2026 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta