Sunday Times Teaser 3292 – Doctor Hoo’s TARDSI

by BRG on October 26, 2025

by Stephen Hogg

Published Sunday October 26 2025 (link)

My blood pressure was 160 systolic over 100 diastolic. I knew 120 over 80 is “normal”, so Doctor Hoo was concerned. She loaned me a TARDSI (Test And Record Diastolic Systolic Indicator) for a few days. I logged 12 blood pressure readings, comprising 24 different values (12 systolic between 120 and 160, and 12 diastolic between 80 and 100). I noticed some curious things about these values. Each systolic:diastolic pair had no repeated digits nor common prime factors. The systolic and diastolic sets each had exactly six odd values, but the lowest and highest values in each set were the only primes. No value was a digit rearrangement of any other and the systolic set had no consecutive values.

Give the systolic:diastolic pair you can be sure I measured (as SSS:DD eg 123:74)

From → Uncategorized

3 Comments Leave one →

BRG permalink


from itertools import combinations, product
from collections import defaultdict
from math import gcd

# prime values up to 169
prms = {3, 5, 7, 11, 13}
prms = {2} | prms | {n for n in range(17, 160, 2) if all(n % p for p in prms)}

# filter out values with duplicate digits
f_dds = (lambda p, q, s = 1: (n for n in range(p, q, s)
                              if len(t := str(n)) == len(set(t))))

# find 12 value sequences in the range <p>..<q> meeting the constraints
def find_seqs(p, q, bp):
  # find prime values in p .. q with no duplicated digits
  pvs = tuple (n for n in f_dds(p, q) if n in prms)
  # consider prime pairs for the first and last of the 12 values
  for ps, pe in combinations(pvs, 2):
    # remove primes between these two values and if bp is 'dia' remove
    # values with 1's that would duplicate systolic 1's (credit Frits)
    vals = tuple(n for n in f_dds(ps + 1, pe)
              if not n in prms and (bp == 'sys' or '1' not in str(n)))
    
    # consider all arrangements of four intervening odd and even values
    for vs in combinations((n for n in vals if n & 1), 4):
      vso = (ps,) + vs + (pe,)    
      for vse in combinations((n for n in vals if ~n & 1), 6):
        
        # for systolic readings there are no consecutive values
        if bp == 'dia' or all({n + 1, n - 1}.isdisjoint(vso) for n in vse):
          veo = vse + vso
          # each value uses a unique set of digits
          if len({tuple(sorted(str(x))) for x in veo}) == 12:
            yield veo

# the twelve diastolic and systolic values 
dis = set(find_seqs( 80, 100, bp='dia'))
sys = set(find_seqs(120, 160, bp='sys'))

# pair the 12 diastolic values with the 12 systolic values in some order in
# such a way that all 12 pairings are co-prime with no duplicated digits
def pairs(ds, ss, seq=list()):
  if not ds:
    yield seq
  else:
    # the next diastolic value
    d = ds[0]
    # consider pairing it with one of the remaining systolic values
    for s in ss:
      # the pairings must be co-prime with no duplicate digits
      if len((t := str(d) + str(s))) == len(set(t)) and gcd(d, s) == 1:
        # continue to the remaining diastolic values
        yield from pairs(ds[1:], set(ss).difference([s]), seq + [(d, s)])

n_sols = 0
sdp_cnt = defaultdict(int)
# consider all arrangements of diastolic and systolic values 
for ds, ss in product(dis, sys):
  # form all valid pairings
  for ps in pairs(ds, ss):
    n_sols += 1
    print(f"{n_sols:3}: {', '.join(f'{d}:{s}' for d, s in ps)}")
    for d, s in ps:
      sdp_cnt[d, s] += 1

# look for a pairing that occurs in all solutions
for (d, s), v in sdp_cnt.items():
  if v == n_sols:
    print(f"\nSolution: {s}:{d}")

from itertools import combinations, product

from collections import defaultdict

from math import gcd

# prime values up to 169

prms = {3, 5, 7, 11, 13}

prms = {2} | prms | {n for n in range(17, 160, 2) if all(n % p for p in prms)}

# filter out values with duplicate digits

f_dds = (lambda p, q, s = 1: (n for n in range(p, q, s)

if len(t := str(n)) == len(set(t))))

# find 12 value sequences in the range <p>..<q> meeting the constraints

def find_seqs(p, q, bp):

# find prime values in p .. q with no duplicated digits

pvs = tuple (n for n in f_dds(p, q) if n in prms)

# consider prime pairs for the first and last of the 12 values

for ps, pe in combinations(pvs, 2):

# remove primes between these two values and if bp is 'dia' remove

# values with 1's that would duplicate systolic 1's (credit Frits)

vals = tuple(n for n in f_dds(ps + 1, pe)

if not n in prms and (bp == 'sys' or '1' not in str(n)))

# consider all arrangements of four intervening odd and even values

for vs in combinations((n for n in vals if n & 1), 4):

vso = (ps,) + vs + (pe,)

for vse in combinations((n for n in vals if ~n & 1), 6):

# for systolic readings there are no consecutive values

if bp == 'dia' or all({n + 1, n - 1}.isdisjoint(vso) for n in vse):

veo = vse + vso

# each value uses a unique set of digits

if len({tuple(sorted(str(x))) for x in veo}) == 12:

yield veo

# the twelve diastolic and systolic values

dis = set(find_seqs( 80, 100, bp='dia'))

sys = set(find_seqs(120, 160, bp='sys'))

# pair the 12 diastolic values with the 12 systolic values in some order in

# such a way that all 12 pairings are co-prime with no duplicated digits

def pairs(ds, ss, seq=list()):

if not ds:

yield seq

else:

# the next diastolic value

d = ds[0]

# consider pairing it with one of the remaining systolic values

for s in ss:

# the pairings must be co-prime with no duplicate digits

if len((t := str(d) + str(s))) == len(set(t)) and gcd(d, s) == 1:

# continue to the remaining diastolic values

yield from pairs(ds[1:], set(ss).difference([s]), seq + [(d, s)])

n_sols = 0

sdp_cnt = defaultdict(int)

# consider all arrangements of diastolic and systolic values

for ds, ss in product(dis, sys):

# form all valid pairings

for ps in pairs(ds, ss):

n_sols += 1

print(f"{n_sols:3}: {', '.join(f'{d}:{s}' for d, s in ps)}")

for d, s in ps:

sdp_cnt[d, s] += 1

# look for a pairing that occurs in all solutions

for (d, s), v in sdp_cnt.items():

if v == n_sols:

print(f"\nSolution: {s}:{d}")

John Z permalink


from math import gcd
from itertools import combinations, permutations
printflag = 0
p = (2, 3, 5, 7, 11, 13)

pr80100 = tuple(x for x in range(81, 101, 2) if all(x % q for q in p))
pr120160 = tuple(x for x in range(121, 161, 2) if all(x % q for q in p) and
               len(str(x)) == 3)

# find the 12 systolic or diastolic values
# sd = 0 for diastolics; 1 for systolics
def find12(primes, sd):
  xstolics=[]
  # the lowest and highest values in each set were the only primes
  # make a list of potential xstolic prime end measurements
  for xlo, xhi in combinations(sorted(primes), 2): 
    xeven = (set(x for x in range(xlo + 1, xhi, 2)
                     if len(set(str(x))) == len(str(x))))
    xodd = (set(x for x in range(xlo + 2, xhi, 2)
                     if len(set(str(x))) == len(str(x)) and
                     (sd or x % 10 != 1))) - set(primes) #credit Frits
    # The xstolic set had exactly six odd values of which 2 are end primes
    # Hence there were exactly 6 even values
    if len(xeven) < 6 or len(xodd) < 4:
      continue
    for xe in combinations(xeven, 6):
      for xo in combinations(xodd, 4):
        ss = sorted(xe + (xlo,) + xo + (xhi,))
        # the systolic set had no consecutive values.
        if sd and any(ss[i + 1] - ss[i] == 1
             for i in range(len(ss) - 1)):
          continue
        # No value was a digit rearrangement of any other
        if any (set(str(a)) == set(str(b))
                for a, b in combinations(ss, 2)):
          continue
        
        xstolics.append((xe, (xlo,) + xo + (xhi,)))
  return xstolics
 
diastolics = find12(pr80100, 0)
systolics = find12(pr120160, 1)

count = 0
sols = []
for d in diastolics:
  for s in systolics:
    # consider even values of diastolics
    for de in permutations(d[0]):
      # pair with odd values of systolics and verify pairs are valid
      if all(gcd(z, d) == 1 and len(sd := str(z) + str(d)) == len(set(sd))
             for z, d in zip(s[1], de)):
        for do in permutations(d[1]):
          if all(gcd(z, d) == 1 and len(sd := str(z) + str(d)) == len(set(sd))
                 for z, d in zip(s[0], do)):
            count += 1
            sol = tuple(zip(s[1], de)) + tuple(zip(s[0], do))           
            sols.append(sol)
            if printflag:
              print(count)
              print(sol)

# find and print the systolic:diastolic pair common to all solutions
print('Solution =', set(sols[0]).intersection(*sols).pop())

from math import gcd

from itertools import combinations, permutations

printflag = 0

p = (2, 3, 5, 7, 11, 13)

pr80100 = tuple(x for x in range(81, 101, 2) if all(x % q for q in p))

pr120160 = tuple(x for x in range(121, 161, 2) if all(x % q for q in p) and

len(str(x)) == 3)

# find the 12 systolic or diastolic values

# sd = 0 for diastolics; 1 for systolics

def find12(primes, sd):

xstolics=[]

# the lowest and highest values in each set were the only primes

# make a list of potential xstolic prime end measurements

for xlo, xhi in combinations(sorted(primes), 2):

xeven = (set(x for x in range(xlo + 1, xhi, 2)

if len(set(str(x))) == len(str(x))))

xodd = (set(x for x in range(xlo + 2, xhi, 2)

if len(set(str(x))) == len(str(x)) and

(sd or x % 10 != 1))) - set(primes) #credit Frits

# The xstolic set had exactly six odd values of which 2 are end primes

# Hence there were exactly 6 even values

if len(xeven) < 6 or len(xodd) < 4:

continue

for xe in combinations(xeven, 6):

for xo in combinations(xodd, 4):

ss = sorted(xe + (xlo,) + xo + (xhi,))

# the systolic set had no consecutive values.

if sd and any(ss[i + 1] - ss[i] == 1

for i in range(len(ss) - 1)):

continue

# No value was a digit rearrangement of any other

if any (set(str(a)) == set(str(b))

for a, b in combinations(ss, 2)):

continue

xstolics.append((xe, (xlo,) + xo + (xhi,)))

return xstolics

diastolics = find12(pr80100, 0)

systolics = find12(pr120160, 1)

count = 0

sols = []

for d in diastolics:

for s in systolics:

# consider even values of diastolics

for de in permutations(d[0]):

# pair with odd values of systolics and verify pairs are valid

if all(gcd(z, d) == 1 and len(sd := str(z) + str(d)) == len(set(sd))

for z, d in zip(s[1], de)):

for do in permutations(d[1]):

if all(gcd(z, d) == 1 and len(sd := str(z) + str(d)) == len(set(sd))

for z, d in zip(s[0], do)):

count += 1

sol = tuple(zip(s[1], de)) + tuple(zip(s[0], do))

sols.append(sol)

if printflag:

print(count)

print(sol)

# find and print the systolic:diastolic pair common to all solutions

print('Solution =', set(sols[0]).intersection(*sols).pop())

John Z permalink

A slightly different approach where as soon as the solution can be identified, it is printed out and execution ends.


from math import gcd
from itertools import combinations, permutations

p = (3, 5, 7, 11, 13)

pr80100 = tuple(x for x in range(81, 101, 2) if all(x % q for q in p))
pr120160 = tuple(x for x in range(121, 161, 2) if all(x % q for q in p) and
               len(set(str(x))) == 3)

# verify that sys and dia even/odd or odd/even have no common factors or digits
verify = lambda a, b: all(gcd(z, d) == 1 and
                          len(set(str(z) + str(d))) == 5 for z, d in zip(a, b))

# find the sets of 12 systolic or sets of 12 diastolic values
def find12(primes, sd):
  xstolics=[]
  # the lowest and highest values in each set were the only primes
  # make a list of potential xstolic end measurements that are prime
  for xlo, xhi in combinations(primes, 2): 
    xeven = (set(x for x in range(xlo + 1, xhi, 2)
                     if len(set(str(x))) == len(str(x))))
    xodd = (set(x for x in range(xlo + 2, xhi, 2)
                     if len(set(str(x))) == len(str(x)))) - set(primes)
    # The xstolic set had exactly six odd values of which 2 are end primes
    # Hence there were exactly 6 even values
    if len(xeven) < 6 or len(xodd) < 4:
      continue
    for xe in combinations(xeven, 6):
      for xo in combinations(xodd, 4):
        ss = sorted(xe + (xlo,) + xo + (xhi,))
        # the systolic set had no consecutive values
        if sd and any(ss[i + 1] - ss[i] == 1 for i in range(len(ss) - 1)):
          continue
        # No value was a digit rearrangement of any other
        if any(set(str(a)) == set(str(b)) for a, b in combinations(ss, 2)):
          continue
        # append the 12 separated as even and odd to the list 
        xstolics.append((xe, (xlo,) + xo + (xhi,)))
  return xstolics
 
diastolics = find12(pr80100, 0)
systolics = find12(pr120160, 1)

# identify the systolic:diastolic pair you can be sure I measured; start by
# associating sets of 12 systolic and 12 diastolic values in all valid ways
def qsolve():
  count = 0
  for d in diastolics:
    for s in systolics:
      # consider permutations of even values of diastolics
      for de in permutations(d[0]):
        # pair with odd values of systolics and verify rules are obeyed
        if verify(s[1], de):
          # consider permutations of odd values of diastolics
          for do in permutations(d[1]):
            if verify(s[0], do):
              sol = set(zip(s[1], de)) | set(zip(s[0], do))
              # sift out the unique systolic : diastolic pair
              uniq_sd = uniq_sd & sol if count else sol
              count += 1
              if len(uniq_sd) == 1:
                return(uniq_sd.pop(), count)

# find and print the systolic:diastolic pair you can be sure I measured
sure = qsolve()
print(f'Solution = {sure[0][0]}:{sure[0][1]} found after {sure[1]} rounds')

from math import gcd

from itertools import combinations, permutations

p = (3, 5, 7, 11, 13)

pr80100 = tuple(x for x in range(81, 101, 2) if all(x % q for q in p))

pr120160 = tuple(x for x in range(121, 161, 2) if all(x % q for q in p) and

len(set(str(x))) == 3)

# verify that sys and dia even/odd or odd/even have no common factors or digits

verify = lambda a, b: all(gcd(z, d) == 1 and

len(set(str(z) + str(d))) == 5 for z, d in zip(a, b))

# find the sets of 12 systolic or sets of 12 diastolic values

def find12(primes, sd):

xstolics=[]

# the lowest and highest values in each set were the only primes

# make a list of potential xstolic end measurements that are prime

for xlo, xhi in combinations(primes, 2):

xeven = (set(x for x in range(xlo + 1, xhi, 2)

if len(set(str(x))) == len(str(x))))

xodd = (set(x for x in range(xlo + 2, xhi, 2)

if len(set(str(x))) == len(str(x)))) - set(primes)

# The xstolic set had exactly six odd values of which 2 are end primes

# Hence there were exactly 6 even values

if len(xeven) < 6 or len(xodd) < 4:

continue

for xe in combinations(xeven, 6):

for xo in combinations(xodd, 4):

ss = sorted(xe + (xlo,) + xo + (xhi,))

# the systolic set had no consecutive values

if sd and any(ss[i + 1] - ss[i] == 1 for i in range(len(ss) - 1)):

continue

# No value was a digit rearrangement of any other

if any(set(str(a)) == set(str(b)) for a, b in combinations(ss, 2)):

continue

# append the 12 separated as even and odd to the list

xstolics.append((xe, (xlo,) + xo + (xhi,)))

return xstolics

diastolics = find12(pr80100, 0)

systolics = find12(pr120160, 1)

# identify the systolic:diastolic pair you can be sure I measured; start by

# associating sets of 12 systolic and 12 diastolic values in all valid ways

def qsolve():

count = 0

for d in diastolics:

for s in systolics:

# consider permutations of even values of diastolics

for de in permutations(d[0]):

# pair with odd values of systolics and verify rules are obeyed

if verify(s[1], de):

# consider permutations of odd values of diastolics

for do in permutations(d[1]):

if verify(s[0], do):

sol = set(zip(s[1], de)) | set(zip(s[0], do))

# sift out the unique systolic : diastolic pair

uniq_sd = uniq_sd & sol if count else sol

count += 1

if len(uniq_sd) == 1:

return(uniq_sd.pop(), count)

# find and print the systolic:diastolic pair you can be sure I measured

sure = qsolve()

print(f'Solution = {sure[0][0]}:{sure[0][1]} found after {sure[1]} rounds')

Sunday Times Teaser 3292 – Doctor Hoo’s TARDSI

by Stephen Hogg

Published Sunday October 26 2025 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta