Sunday Times Teaser 3279 – It’s a Doddle!

by BRG on July 27, 2025

by Stephen Hogg

Published Sunday July 27 2025 (link)

The Holmes’s new maths tutor, Dr Moriarty, wrote several two-figure by three-figure whole number multiplications on the board (with no answer repeated). Young Sherlock whispered to his brother, “That first one’s a doddle and the three-figure number is prime.” Mycroft replied, “Yes, it is a doddle, but the answer is also a DODDLE.” Sherlock looked puzzled. Mycroft explained that a DODDLE is a number with “Descending-Order Digits left to right — all different — DivisibLe Exactly by each digit.” Mycroft continued, “All of the above applies to the second multiplication as well.”

Sherlock noticed that just one other answer, to the final problem, was a DODDLE, with the three-figure value being odd, but not prime.

What is the answer to the final problem?

From → Uncategorized

5 Comments Leave one →

BRG permalink


# create the set of three digit primes
pr = {3, 5, 7, 11, 13, 17, 19, 23, 29, 31}
pr3d = {n for n in range(101, 1000, 2) if all(n % p for p in pr)}

# return True if <n> is a DODDLE
def is_doddle(n):
  ds = [int(d) for d in str(n)]
  return (all(d and ds[i] > d for i, d in enumerate(ds[1:]))
                  and not any(n % d for d in ds))

# collect two sets of DODDLEs: <d_prm> when their associated three
# digit number is prime and <d_odd> when it is odd but not prime
d_prm, d_odd = set(), set()
for d2 in range(10, 100):
  for d3 in range(101, 1000, 2):
    if is_doddle((dd := d2 * d3)):
      d_odd.add(dd)
      if d3 in pr3d:
        d_prm.add(dd)

# check for the correct number of DODDLEs: two or 
# more 'odd prime' and exactly one 'odd non-prime'
if len(d_prm) >= 2 and len(r := d_odd - d_prm) == 1:
  print(f"Answer: {r.pop()}")

# create the set of three digit primes

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

pr3d = {n for n in range(101, 1000, 2) if all(n % p for p in pr)}

# return True if <n> is a DODDLE

def is_doddle(n):

ds = [int(d) for d in str(n)]

return (all(d and ds[i] > d for i, d in enumerate(ds[1:]))

and not any(n % d for d in ds))

# collect two sets of DODDLEs: <d_prm> when their associated three

# digit number is prime and <d_odd> when it is odd but not prime

d_prm, d_odd = set(), set()

for d2 in range(10, 100):

for d3 in range(101, 1000, 2):

if is_doddle((dd := d2 * d3)):

d_odd.add(dd)

if d3 in pr3d:

d_prm.add(dd)

# check for the correct number of DODDLEs: two or

# more 'odd prime' and exactly one 'odd non-prime'

if len(d_prm) >= 2 and len(r := d_odd - d_prm) == 1:

print(f"Answer: {r.pop()}")

Here is an alternative (faster) version:


from number_theory import is_prime, divisor_pairs
from itertools import combinations

# collect two sets of DODDLEs: <d_prm> when their associated three
# digit number is prime and <d_odd> when it is odd but not prime
d_prm, d_odd = set(), set()
# consider four and five digit DODDLEs 
for nd in (4, 5):
  for ds in combinations('987654321', nd):
    dv = int(''.join(ds))
    # a DODDLE must be divisible by each of its digits ...
    if all(dv % int(s) == 0 for s in ds):
      # ... and have two digit and odd three digit divisors
      for a, b in divisor_pairs(dv):
        if 10 < a < 100 and 100 < b < 1000 and b & 1:
          d_odd.add(dv)
          if is_prime(b):
            d_prm.add(dv)

# check for the correct number of DODDLEs: two or
# more 'odd prime' and exactly one 'odd non-prime'
if len(d_prm) >= 2 and len(r := d_odd - d_prm) == 1:
  print(f"Answer: {r.pop()}")

from number_theory import is_prime, divisor_pairs

from itertools import combinations

# collect two sets of DODDLEs: <d_prm> when their associated three

# digit number is prime and <d_odd> when it is odd but not prime

d_prm, d_odd = set(), set()

# consider four and five digit DODDLEs

for nd in (4, 5):

for ds in combinations('987654321', nd):

dv = int(''.join(ds))

# a DODDLE must be divisible by each of its digits ...

if all(dv % int(s) == 0 for s in ds):

# ... and have two digit and odd three digit divisors

for a, b in divisor_pairs(dv):

if 10 < a < 100 and 100 < b < 1000 and b & 1:

d_odd.add(dv)

if is_prime(b):

d_prm.add(dv)

# check for the correct number of DODDLEs: two or

# more 'odd prime' and exactly one 'odd non-prime'

if len(d_prm) >= 2 and len(r := d_odd - d_prm) == 1:

print(f"Answer: {r.pop()}")

JohnZ permalink


from itertools import combinations

# create the set of three digit primes
pr = {3, 5, 7, 11, 13, 17, 19, 23, 29, 31}
pr3d = {n for n in range(101, 1000, 2) if all(n % p for p in pr)}

# consider DODDLEs with 4 or 5 digits i.e. 10 * 100 to 99 * 999 
# make a list of potential DODDLEs (the digits followed by the number)
dod = list((d, sum(d[i] * 10 ** (i) for i in range(k))) for k in (4, 5)
             for d in combinations(range(1, 10), k))
  
# sift out the DODDLEs based on the division criterion
dod = tuple(n for dd, n in dod if all((n % d == 0 for d in dd)))

# form the set of DODDLEs for all odd 3-digit numbers
solo = {a * b for a in range(10, 100)
                for b in set(range(101, 1000, 2)) if a * b in dod}

# form the set of DODDLEs for all prime 3-digit numbers
solp = {a * b for a in range(10, 100) for b in pr3d if a * b in dod}

# the solution requires two DODDLEs derived from 3-digit primes and
# exactly one different DODDLE derived from an odd 3-digit non-prime 
if len(solp) >= 2 and len(r := solo - solp) == 1:
  print(f"Answer: {r.pop()}")

from itertools import combinations

# create the set of three digit primes

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

pr3d = {n for n in range(101, 1000, 2) if all(n % p for p in pr)}

# consider DODDLEs with 4 or 5 digits i.e. 10 * 100 to 99 * 999

# make a list of potential DODDLEs (the digits followed by the number)

dod = list((d, sum(d[i] * 10 ** (i) for i in range(k))) for k in (4, 5)

for d in combinations(range(1, 10), k))

# sift out the DODDLEs based on the division criterion

dod = tuple(n for dd, n in dod if all((n % d == 0 for d in dd)))

# form the set of DODDLEs for all odd 3-digit numbers

solo = {a * b for a in range(10, 100)

for b in set(range(101, 1000, 2)) if a * b in dod}

# form the set of DODDLEs for all prime 3-digit numbers

solp = {a * b for a in range(10, 100) for b in pr3d if a * b in dod}

# the solution requires two DODDLEs derived from 3-digit primes and

# exactly one different DODDLE derived from an odd 3-digit non-prime

if len(solp) >= 2 and len(r := solo - solp) == 1:

print(f"Answer: {r.pop()}")

Frits permalink


from number_theory import is_prime
from itertools import combinations

# determine valid two-digit by three-digit whole number multiplications 
div_pairs = lambda n: tuple((i, dm[0]) for i in range(11, 100) 
                      if not (dm := divmod(n, i))[1] and 99 < dm[0] < 1000)

doddles = set()                    
# generate DODDLEs                answer = (a)bcde
for a in [5, 6, 7, 8, 9, 0]:
  for b, c, d, e in combinations(range(a - 1 if a else 9, 0, -1), 4):
    abcde = 10000 * a + 1000 * b + 100 * c + 10 * d + e
    if any(abcde % x for x in ([a, b, c, d, e] if a else [b, c, d, e])):
      continue
    # two-digit by three-digit whole number multiplications   
    if not (ps := div_pairs(abcde)): continue
    doddles.add((abcde, ps))

sols = set()          
# exactly 3 of the answers on the board are DODDLEs
for selection in combinations(doddles, 3):
  for doddle, ps in selection:
    # find the requested answer
    if any(d3 % 2 and not is_prime(d3) for _, d3 in ps): 
      # check if the two other answers have a three-figure prime number
      for doddle2, ps2 in selection:
        if doddle2 == doddle: continue
        if all(not is_prime(d3) for _, d3 in ps2): break
      else: # no break
        sols.add(doddle)

print("answer:", ' or '.join(str(s) for s in sols))

from number_theory import is_prime

from itertools import combinations

# determine valid two-digit by three-digit whole number multiplications

div_pairs = lambda n: tuple((i, dm[0]) for i in range(11, 100)

if not (dm := divmod(n, i))[1] and 99 < dm[0] < 1000)

doddles = set()

# generate DODDLEs answer = (a)bcde

for a in [5, 6, 7, 8, 9, 0]:

for b, c, d, e in combinations(range(a - 1 if a else 9, 0, -1), 4):

abcde = 10000 * a + 1000 * b + 100 * c + 10 * d + e

if any(abcde % x for x in ([a, b, c, d, e] if a else [b, c, d, e])):

continue

# two-digit by three-digit whole number multiplications

if not (ps := div_pairs(abcde)): continue

doddles.add((abcde, ps))

sols = set()

# exactly 3 of the answers on the board are DODDLEs

for selection in combinations(doddles, 3):

for doddle, ps in selection:

# find the requested answer

if any(d3 % 2 and not is_prime(d3) for _, d3 in ps):

# check if the two other answers have a three-figure prime number

for doddle2, ps2 in selection:

if doddle2 == doddle: continue

if all(not is_prime(d3) for _, d3 in ps2): break

else: # no break

sols.add(doddle)

print("answer:", ' or '.join(str(s) for s in sols))

Frits permalink

“just one other answer, to the final problem, was a DODDLE”.

It seems that we have different interpretations of this line. I regard “other answer” as an answer on the board and not a theoretically possible answer.

Reply
- BRG permalink
  
  My interpretation of the phrase you quote is as follows:
  
  If we create the set of all DODDLEs derived from all 3-digit primes \(\{P\}\) (with \(|\{P\}|\ge 2\)) and the set of all DODDLEs derived from all odd 3-digit non-primes \(\{O\}\), I interpret the phrase you quote to imply that \(|\{O\}\; -\; \{P\}| == 1\).
  
  I agree that \(\{O\}\; -\; \{P\}\) is on the board.
  
  Reply

Sunday Times Teaser 3279 – It’s a Doddle!

by Stephen Hogg

Published Sunday July 27 2025 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta