Sunday Times Teaser 3316 – The Odd One Out

by BRG on April 12, 2026

by Peter Good

Published Sunday April 12 2026 (link)

George drew a 3 × 3 grid and wrote an odd digit in each square. Martha did the same and her grid was identical to George’s except for the digit in one square. Both grids contained eight different three-digit prime numbers, reading across the three rows, down the three columns and down the two diagonals. Remarkably, all eight of George’s primes were also primes when read backwards but only seven of Martha’s primes had this property.

Which prime number in Martha’s grid was the odd one out?

From → Uncategorized

2 Comments Leave one →

BRG permalink


from itertools import permutations

# three digit primes (as strings) with only odd digits
prms = {3, 5, 7, 11, 13, 17, 19, 23, 29, 31}
prms = {t for n in range(101, 1000, 2) if all(n % p for p in prms)
        and set((t := str(n))).issubset('13579')}

# primes (as strings) that are also primes when reversed
rprms = {p for p in prms if p[::-1] in prms}

# consider possible rows
for r3 in permutations(rprms, 3):
  # obtain columns and diagonal values
  c3 = list(''.join(x) for x in zip(*r3))
  d2 = [r3[0][0] + r3[1][1] + r3[2][2],
        r3[0][2] + r3[1][1] + r3[2][0]]
  # check for reversible primes
  if rprms.issuperset(c3 + d2):
    # there are eight different primes
    if len(set(list(r3) + c3 + d2)) == 8:
      # now change one digit 
      for r in (0, 1, 2):
        for c in (0, 1, 2):
          r3c = list(r3)
          for v in '13579':
            if v == r3[r][c]:
              continue
            s = list(r3c[r])
            s[c] = v
            r3c[r] = ''.join(s)
            # find the eight revised values
            c3c = list(''.join(x) for x in zip(*r3c))
            d2c = [r3c[0][0] + r3c[1][1] + r3c[2][2],
                   r3c[0][2] + r3c[1][1] + r3c[2][0]]
            mvals = tuple(v for v in list(r3c) + c3c + d2c if v in prms)
            # Martha's values must be eight different primes
            if len(mvals) == len(set(mvals)) == 8:
              # look for a single value that is not a reversible prime
              if len(tnr := tuple(v for v in mvals if v not in rprms)) == 1:
                print(f"Answer {tnr[0]} [({' '.join(r3)}) {r3[r]} -> {r3c[r]}]")

from itertools import permutations

# three digit primes (as strings) with only odd digits

prms = {3, 5, 7, 11, 13, 17, 19, 23, 29, 31}

prms = {t for n in range(101, 1000, 2) if all(n % p for p in prms)

and set((t := str(n))).issubset('13579')}

# primes (as strings) that are also primes when reversed

rprms = {p for p in prms if p[::-1] in prms}

# consider possible rows

for r3 in permutations(rprms, 3):

# obtain columns and diagonal values

c3 = list(''.join(x) for x in zip(*r3))

d2 = [r3[0][0] + r3[1][1] + r3[2][2],

r3[0][2] + r3[1][1] + r3[2][0]]

# check for reversible primes

if rprms.issuperset(c3 + d2):

# there are eight different primes

if len(set(list(r3) + c3 + d2)) == 8:

# now change one digit

for r in (0, 1, 2):

for c in (0, 1, 2):

r3c = list(r3)

for v in '13579':

if v == r3[r][c]:

continue

s = list(r3c[r])

s[c] = v

r3c[r] = ''.join(s)

# find the eight revised values

c3c = list(''.join(x) for x in zip(*r3c))

d2c = [r3c[0][0] + r3c[1][1] + r3c[2][2],

r3c[0][2] + r3c[1][1] + r3c[2][0]]

mvals = tuple(v for v in list(r3c) + c3c + d2c if v in prms)

# Martha's values must be eight different primes

if len(mvals) == len(set(mvals)) == 8:

# look for a single value that is not a reversible prime

if len(tnr := tuple(v for v in mvals if v not in rprms)) == 1:

print(f"Answer {tnr[0]} [({' '.join(r3)}) {r3[r]} -> {r3c[r]}]")

BRG permalink

For interest, here is a tidied up and commented version of the Claude Artificial Intelligence solution to this teaser published here by GeoffR.


from number_theory import Primes
from itertools import product

prms = Primes(1000)
# a true/false array where prms[n] is true when <n> is prime
prms = bytearray((1 if p in prms else 0 for p in range(1000)))

# only odd digits are used in the 3 x 3 grid
dgts = (1, 3, 5, 7, 9)

# map digit triples to true/false for primes and reversed primes
fprms = {(a, b, c):prms[100 * a + 10 * b + c] for a, b, c in product(dgts, repeat=3)}
rprms = {(a, b, c):prms[100 * c + 10 * b + a] for a, b, c in product(dgts, repeat=3)}

# map digit triples to true/false for bi-directional primes
bdprms = {t: fprms[t] and rprms[t] for t in product(dgts, repeat=3)}

# find possible grids for George
g_grids = []
# consider and check digit triples for rows one, two and three
for a, b, c in product(dgts, repeat=3):
  if not bdprms[a, b, c]:
    continue
  for d, e, f in product(dgts, repeat=3):
    if not bdprms[d, e, f]:
      continue
    for g, h, i in product(dgts, repeat=3):
      if not bdprms[g, h, i]:
        continue
      # now check columns and diagonal values
      if (bdprms[a, d, g] and bdprms[b, e, h] and bdprms[c, f, i]
          and bdprms[a, e, i] and bdprms[c, e, g]):
        # form the reversible prime values
        rpvals = {100 * x + 10 * y + z for x, y, z in
          [(a, b, c), (d, e, f), (g, h, i),
           (a, d, g), (b, e, h), (c, f, i),
           (a, e, i), (c, e, g)]}
        # which must all be different
        if len(rpvals) == 8:
          g_grids.append((a, b, c, d, e, f, g, h, i))

# consider the possible grids for George
for gs in g_grids:
  # consider the cell and digit that is changed for Martha
  for pos in range(9):
    for md in dgts:
      if md == gs[pos]:
        continue
      mg = list(gs); mg[pos] = md
      # compose Martha's row, column and diagonal triples
      a, b, c, d, e, f, g, h, i = mg  
      rpvals = [(a, b, c), (d, e, f), (g, h, i),
                (a, d, g), (b, e, h), (c, f, i),
                (a, e, i), (c, e, g)]
      # which must all be primes
      if not all(fprms[t] for t in rpvals):
        continue
      # Marthas prime values
      vals = [100 * t[0] + 10 * t[1] + t[2] for t in rpvals]
      if len(set(vals)) != 8:
        continue
      # of which only one is a non-reversible prime
      nrp = [t for t in rpvals if not rprms[t]]
      if len(nrp) == 1: print(vals)
      if len(nrp) == 1:
        # find the answer (the one that is not reversible)
        ans = int(''.join(str(d) for d in nrp[0]))
        print(f"Grid: {mg[:3]}, {mg[3:6]}, {mg[6:]}")
        print(f"Answer: {ans} ({int(str(ans)[::-1])} is not prime)\n")

from number_theory import Primes

from itertools import product

prms = Primes(1000)

# a true/false array where prms[n] is true when <n> is prime

prms = bytearray((1 if p in prms else 0 for p in range(1000)))

# only odd digits are used in the 3 x 3 grid

dgts = (1, 3, 5, 7, 9)

# map digit triples to true/false for primes and reversed primes

fprms = {(a, b, c):prms[100 * a + 10 * b + c] for a, b, c in product(dgts, repeat=3)}

rprms = {(a, b, c):prms[100 * c + 10 * b + a] for a, b, c in product(dgts, repeat=3)}

# map digit triples to true/false for bi-directional primes

bdprms = {t: fprms[t] and rprms[t] for t in product(dgts, repeat=3)}

# find possible grids for George

g_grids = []

# consider and check digit triples for rows one, two and three

for a, b, c in product(dgts, repeat=3):

if not bdprms[a, b, c]:

continue

for d, e, f in product(dgts, repeat=3):

if not bdprms[d, e, f]:

continue

for g, h, i in product(dgts, repeat=3):

if not bdprms[g, h, i]:

continue

# now check columns and diagonal values

if (bdprms[a, d, g] and bdprms[b, e, h] and bdprms[c, f, i]

and bdprms[a, e, i] and bdprms[c, e, g]):

# form the reversible prime values

rpvals = {100 * x + 10 * y + z for x, y, z in

[(a, b, c), (d, e, f), (g, h, i),

(a, d, g), (b, e, h), (c, f, i),

(a, e, i), (c, e, g)]}

# which must all be different

if len(rpvals) == 8:

g_grids.append((a, b, c, d, e, f, g, h, i))

# consider the possible grids for George

for gs in g_grids:

# consider the cell and digit that is changed for Martha

for pos in range(9):

for md in dgts:

if md == gs[pos]:

continue

mg = list(gs); mg[pos] = md

# compose Martha's row, column and diagonal triples

a, b, c, d, e, f, g, h, i = mg

rpvals = [(a, b, c), (d, e, f), (g, h, i),

(a, d, g), (b, e, h), (c, f, i),

(a, e, i), (c, e, g)]

# which must all be primes

if not all(fprms[t] for t in rpvals):

continue

# Marthas prime values

vals = [100 * t[0] + 10 * t[1] + t[2] for t in rpvals]

if len(set(vals)) != 8:

continue

# of which only one is a non-reversible prime

nrp = [t for t in rpvals if not rprms[t]]

if len(nrp) == 1: print(vals)

if len(nrp) == 1:

# find the answer (the one that is not reversible)

ans = int(''.join(str(d) for d in nrp[0]))

print(f"Grid: {mg[:3]}, {mg[3:6]}, {mg[6:]}")

print(f"Answer: {ans} ({int(str(ans)[::-1])} is not prime)\n")

Sunday Times Teaser 3316 – The Odd One Out

by Peter Good

Published Sunday April 12 2026 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta