Sunday Times Teaser 3298 – Bletchley Park

To make a programmed solution feasible in a reasonable time we have to assume that the encoded plaintext includes the word HOLMES and this, in turn, makes it possible to recognise that C must stand for L with the first four letters spelling the word KILL.


from collections import defaultdict
from itertools import permutations

letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

# The encoded text - if we guess that the first encoded word is KILL
# then C codes as L and HOLMES, if present, must be the second word
code = "DKCCVTCSZQRZYTAZXTTX"

# read words into a dictionary indexed on word length
# I used the file 'google-10000-english.txt' from here:
# https://github.com/first20hours/google-10000-english
path = "words_in_frequency_order.txt"
words = defaultdict(set)
with open(path, "r") as inf:
  for line in inf:
    if len(ln := line.strip()):
      words[len(ln)] |= {ln.upper()}

# the initial decoding dictionary from the known words (KILL and HOLMES)
d = dict(zip('DKCVTSZQ', 'KILHOMES'))
# the encoded letters which still need to be mapped for decoding
rct_ltrs = ''.join(sorted(set(c for c in code if c not in 'DKCVTSZQ')))
# the plaintext letters that are still uncoded
rpt_ltrs = set(letters).difference('KILLHOLMES')

# consider all mappings between ciphertext and plaintext letters
for ltrs in permutations(rpt_ltrs, len(rct_ltrs)):
  d_ = d.copy()
  d_.update(zip(rct_ltrs, ltrs))
  # the final ten letters of the ciphertext (encoding two words)
  pt = ''.join(d_[c] for c in code[-10:])
  # split the result into two words and see if both
  # the resulting words are in the word list
  for i in range(1, len(pt) - 1):
    fw, sw = pt[:i], pt[i:]
    try:
      if fw in words[i] and sw in words[10 - i]:
        print('KILL', 'HOLMES', fw, sw)
    except KeyError:
      break

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

from collections import defaultdict

from itertools import permutations

letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

# The encoded text - if we guess that the first encoded word is KILL

# then C codes as L and HOLMES, if present, must be the second word

code = "DKCCVTCSZQRZYTAZXTTX"

# read words into a dictionary indexed on word length

# I used the file 'google-10000-english.txt' from here:

# https://github.com/first20hours/google-10000-english

path = "words_in_frequency_order.txt"

words = defaultdict(set)

with open(path, "r") as inf:

for line in inf:

if len(ln := line.strip()):

words[len(ln)] |= {ln.upper()}

# the initial decoding dictionary from the known words (KILL and HOLMES)

d = dict(zip('DKCVTSZQ', 'KILHOMES'))

# the encoded letters which still need to be mapped for decoding

rct_ltrs = ''.join(sorted(set(c for c in code if c not in 'DKCVTSZQ')))

# the plaintext letters that are still uncoded

rpt_ltrs = set(letters).difference('KILLHOLMES')

# consider all mappings between ciphertext and plaintext letters

for ltrs in permutations(rpt_ltrs, len(rct_ltrs)):

d_ = d.copy()

d_.update(zip(rct_ltrs, ltrs))

# the final ten letters of the ciphertext (encoding two words)

pt = ''.join(d_[c] for c in code[-10:])

# split the result into two words and see if both

# the resulting words are in the word list

for i in range(1, len(pt) - 1):

fw, sw = pt[:i], pt[i:]

try:

if fw in words[i] and sw in words[10 - i]:

print('KILL', 'HOLMES', fw, sw)

except KeyError:

break

Reply

Frits permalink

The 10,000th word is “poison”, you almost missed it.

Reply

John Z. permalink


AZ = 'ABCDEFGHIJKLMNOPQRDTUVWXYZ'

# coded message
cm = 'DKCCVTCSZQRZYTAZXTTX'
# consider displacements from 1 - 25 (Ceasar code)
for d in range(1, 26):
  tt = str.maketrans(AZ, AZ[d:] + AZ[:d])
  dc = cm.translate(tt)
  # we assume the word 'HOLMES' appears in the message
  x = dc.find('HOLMES')
  if x > 0:
    print(dc)
    exit()
    
# Ceasar code has not worked; try another approach
for i in range(len(cm) - 6):
  # slide 'HOLMES' along the coded message; there must be 6 different letters
  if len(set(cm[i: i + 6])) != 6:
    continue
  # make translation table, lower case to better see decoded part
  tt = str.maketrans( cm[i: i + 6], 'holmes')
  dc = cm.translate(tt)
  
  # the coded message containing 'holmes' and other decoded letters
  print(dc, '\n')

# mental pattern matching on the first line of printout
# --ll holmes -e-o-e -oo-
# makes the message apparent (spaces added manually)
# access to an online English word list is needed to formalise

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

AZ = 'ABCDEFGHIJKLMNOPQRDTUVWXYZ'

# coded message

cm = 'DKCCVTCSZQRZYTAZXTTX'

# consider displacements from 1 - 25 (Ceasar code)

for d in range(1, 26):

tt = str.maketrans(AZ, AZ[d:] + AZ[:d])

dc = cm.translate(tt)

# we assume the word 'HOLMES' appears in the message

x = dc.find('HOLMES')

if x > 0:

print(dc)

exit()

# Ceasar code has not worked; try another approach

for i in range(len(cm) - 6):

# slide 'HOLMES' along the coded message; there must be 6 different letters

if len(set(cm[i: i + 6])) != 6:

continue

# make translation table, lower case to better see decoded part

tt = str.maketrans( cm[i: i + 6], 'holmes')

dc = cm.translate(tt)

# the coded message containing 'holmes' and other decoded letters

print(dc, '\n')

# mental pattern matching on the first line of printout

# --ll holmes -e-o-e -oo-

# makes the message apparent (spaces added manually)

# access to an online English word list is needed to formalise

Reply

Frits permalink


code = "DKCCVTCSZQRZYTAZXTTX"

teaser_words = ("SECRET AGENT ROBERT HOLMES HOTEL FOREIGN MISSION").split()

danger_words = ("DANGER LIFE DEAD DEATH HURT MURDER SHOOT KILL SLAY HIT " +
                "STAB HARM DESTROY MAIM CRIPPLE INJURE INJURY DIE " +
                "EXECUTE BUTCHER STRANGLE LIQUIDATE ELIMINATE TORTURE " +
                "DISPATCH POISON").split()

imminent_words = ("BREAKFAST BF HOUR HOURS TODAY ASAP SOON IMMEDIATELY " +
                  "DAY EVENING TONIGHT AFTERNOON NOON BEFORE AFTER WHILE " +
                  "MORNING AM PM DAYTIME DELAY EARLY EARLIER LATE LATER " +
                  "MIDNIGHT MINUTE MINUTES NOW PRESENT SECOND TIME " +
                  "CLOCK OCLOCK TOMORROW MOMENT QUICK QUICKLY").split()

# can we fit word <w> in code <cd> using dictionary <d>
def fit(w, cd, d):
  ln = len(w)
  # process all positions in the code
  for i in range(len(cd) - ln + 1):
    # can we find a slot for the new word
    if " " in (cdw := cd[i:i + ln]): continue
    d_ = d.copy()
    # check every position of the new word
    for j in range(ln):
      c, cdwc = w[j], cdw[j]
      if cdwc in d_:
        if d_[cdwc] != c: break
      elif c in d_.values(): # already used for another letter
        break
      else: # new letter fits
        d_[cdwc] = c
    else: # no break
      # word <w> fits, so blank it out in code
      yield w, i, d_, cd[:i] + " " * ln + cd[i + ln:]

print("candidate solutions:\n--------------------\n")
for tw in teaser_words:
  for w1, i1, d1, cd1 in fit(tw, code, dict()):
    for dw in danger_words:
      for w2, i2, d2, cd2 in fit(dw, cd1, d1):
        for iw in imminent_words:
          for w3, i3, d3, cd3 in fit(iw, cd2, d2):
           # 4th word must fit into one gap
           if len(cd3.split()) != 1: continue

           splits = {i + len(w) for i, w in [(i1, w1), (i2, w2), (i3, w3)]}
           for i, k in enumerate(code):
             if i and i in splits | {i1, i2, i3}:
               print(" ", end="")
             print('.' if k not in d3 else d3[k], end="")
           print()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

code = "DKCCVTCSZQRZYTAZXTTX"

teaser_words = ("SECRET AGENT ROBERT HOLMES HOTEL FOREIGN MISSION").split()

danger_words = ("DANGER LIFE DEAD DEATH HURT MURDER SHOOT KILL SLAY HIT " +

"STAB HARM DESTROY MAIM CRIPPLE INJURE INJURY DIE " +

"EXECUTE BUTCHER STRANGLE LIQUIDATE ELIMINATE TORTURE " +

"DISPATCH POISON").split()

imminent_words = ("BREAKFAST BF HOUR HOURS TODAY ASAP SOON IMMEDIATELY " +

"DAY EVENING TONIGHT AFTERNOON NOON BEFORE AFTER WHILE " +

"MORNING AM PM DAYTIME DELAY EARLY EARLIER LATE LATER " +

"MIDNIGHT MINUTE MINUTES NOW PRESENT SECOND TIME " +

"CLOCK OCLOCK TOMORROW MOMENT QUICK QUICKLY").split()

# can we fit word <w> in code <cd> using dictionary <d>

def fit(w, cd, d):

ln = len(w)

# process all positions in the code

for i in range(len(cd) - ln + 1):

# can we find a slot for the new word

if " " in (cdw := cd[i:i + ln]): continue

d_ = d.copy()

# check every position of the new word

for j in range(ln):

c, cdwc = w[j], cdw[j]

if cdwc in d_:

if d_[cdwc] != c: break

elif c in d_.values(): # already used for another letter

break

else: # new letter fits

d_[cdwc] = c

else: # no break

# word <w> fits, so blank it out in code

yield w, i, d_, cd[:i] + " " * ln + cd[i + ln:]

print("candidate solutions:\n--------------------\n")

for tw in teaser_words:

for w1, i1, d1, cd1 in fit(tw, code, dict()):

for dw in danger_words:

for w2, i2, d2, cd2 in fit(dw, cd1, d1):

for iw in imminent_words:

for w3, i3, d3, cd3 in fit(iw, cd2, d2):

# 4th word must fit into one gap

if len(cd3.split()) != 1: continue

splits = {i + len(w) for i, w in [(i1, w1), (i2, w2), (i3, w3)]}

for i, k in enumerate(code):

if i and i in splits | {i1, i2, i3}:

print(" ", end="")

print('.' if k not in d3 else d3[k], end="")

print()

Reply

BRG permalink

I quite like aspects of both Jim Randell’s and Frits’ code so here is a version that uses a mix of each:


# The encoded text
code = "DKCCVTCSZQRZYTAZXTTX"

# read words into a dictionary indexed on word length
# I used the file 'google-10000-english.txt' from here:
# https://github.com/first20hours/google-10000-english
path = "words_in_frequency_order.txt"
words = dict()
with open(path, "r") as inf:
  for line in inf:
    if 2 < (ln := len((wd := line.strip().upper()))):
      words[ln] = words.get(ln, []) + [wd]
      
# update the dictionary <d> from the map <ctxt -> ptxt> but only
# when( a) no characters in the latter map remain unchanged, and
# (b) no inconsistencies arise between the dictionary and the map
def update(d, ctxt, ptxt):
  assert len(ctxt) == len(ptxt)
  d = d.copy()
  for k, v in zip(ctxt, ptxt):
    if k == v:
      return
    elif k in d:
      if v != d[k]:
        return
    elif v in d.values():
      return
    else:
      d[k] = v
  return d

# find words from dictionary <wd> (indexed on word length) that can
# can be matched to a sub-sequence of the encoded sequence <cds> in
# a way that gives a consistent decoding dictionary <d>
def fit_word(wd, cds, d):
  # find next code sub-sequence
  while cds[0] == ' ':
    cds = cds[1:]
  ln = cds.index(' ') if ' ' in cds else len(cds)
  # consider possible positions for a word to fit
  for p in range(ln):
    # the lengths of words to consider
    for nc in range(1, ln - p + 1):
      for w in wd.get(nc, []):
        if (d_ := update(d, cds[p : p + nc], w)):
          cds_ = cds[:p] + ' ' + cds[p + nc:]
          yield cds_, d_

# find a position for HOLMES
for cds, d in fit_word({6:['HOLMES']}, code, {}):
  # now find three more words in the remaining encoded text
  for cds1, d1 in fit_word(words, cds, d):
    for cds2, d2 in fit_word(words, cds1, d1):
      for cds3, d3 in fit_word(words, cds2, d2):
        if not cds3.strip():
          print(''.join(d3[c] for c in code))

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

# The encoded text

code = "DKCCVTCSZQRZYTAZXTTX"

# read words into a dictionary indexed on word length

# I used the file 'google-10000-english.txt' from here:

# https://github.com/first20hours/google-10000-english

path = "words_in_frequency_order.txt"

words = dict()

with open(path, "r") as inf:

for line in inf:

if 2 < (ln := len((wd := line.strip().upper()))):

words[ln] = words.get(ln, []) + [wd]

# update the dictionary <d> from the map <ctxt -> ptxt> but only

# when( a) no characters in the latter map remain unchanged, and

# (b) no inconsistencies arise between the dictionary and the map

def update(d, ctxt, ptxt):

assert len(ctxt) == len(ptxt)

d = d.copy()

for k, v in zip(ctxt, ptxt):

if k == v:

return

elif k in d:

if v != d[k]:

return

elif v in d.values():

return

else:

d[k] = v

return d

# find words from dictionary <wd> (indexed on word length) that can

# can be matched to a sub-sequence of the encoded sequence <cds> in

# a way that gives a consistent decoding dictionary <d>

def fit_word(wd, cds, d):

# find next code sub-sequence

while cds[0] == ' ':

cds = cds[1:]

ln = cds.index(' ') if ' ' in cds else len(cds)

# consider possible positions for a word to fit

for p in range(ln):

# the lengths of words to consider

for nc in range(1, ln - p + 1):

for w in wd.get(nc, []):

if (d_ := update(d, cds[p : p + nc], w)):

cds_ = cds[:p] + ' ' + cds[p + nc:]

yield cds_, d_

# find a position for HOLMES

for cds, d in fit_word({6:['HOLMES']}, code, {}):

# now find three more words in the remaining encoded text

for cds1, d1 in fit_word(words, cds, d):

for cds2, d2 in fit_word(words, cds1, d1):

for cds3, d3 in fit_word(words, cds2, d2):

if not cds3.strip():

print(''.join(d3[c] for c in code))

Reply

Paul Byrne permalink

Well done Brian!

Although I don’t understand all the coding it’s interesting seeing how you tackle these puzzles and again you rose to the challenge!

I gained the impression you enjoyed this one.!

Reply

John Z. permalink


# coded message
cm = 'DKCCVTCSZQRZYTAZXTTX'
# minimum word length; if < 3 execution time is very long
mwl = 4
      
# read words into a dictionary indexed on word length (Credit: Brian)
path = "words_in_frequency_order.txt"
words = dict()
with open(path, "r") as inf:
  for line in inf:
    ln = len((wd := line.strip()))
    words[ln] = words.get(ln, []) + [wd]
      
# finds new words 'matching' with pds; produces addition to translation table 
# pdcm = partially decoded message, pds: partially decoded string
def tryword(pds, pdcm):
  # consider words to try (wtt)
  for wtt in words[len(pds)]:
    # check for anything that can eliminate the candidate word
    if (len(set(wtt)) == len(set(pds)) and
        not any(((b.islower() and a!= b) or (b.isupper() and a in pdcm)) 
                                             for a, b in zip(wtt, pds))):

      # AOK: result is partial translation table to add to complete table
      yield {ord(a): ord(b) for a, b in zip(pds, wtt) if a.isupper()}

# produces complete translation tables
# lower case in string shows letter has been decoded, upper case is undecoded
# pdcm: partially decoded message, tt: translation table, zones to decode
def  decoder(pdcm, tt, zones, wc = 1):
  if wc == 4:
    if len(zones) == 0: # > 0: four words found but message not fully decoded
      yield tt
  else:
    # get next undecoded zone
    z = zones[0]
    # letter counts of words
    for lc in range(mwl, z[1] - z[0] + 1):
      # remaining zone or zones after 'inserting' next word
      tzones = zones[1:] if z[0] + lc == z[1] else ([[z[0] + lc, z[1]]] if 
         len(zones) == 1 else [[z[0] + lc, z[1]], zones[1]])
      # look for candidate words to 'insert' in the zone designated by 'z'
      for a in tryword(pdcm[z[0]: z[0] + lc], pdcm):
        yield from decoder(cm.translate(tt | a), tt | a, tzones, wc + 1)
  
for i in range(len(cm) - 6):
  # slide 'HOLMES' along the coded message; there must be 6 different letters
  if len(set(cm[i: i + 6])) == 6:
    
    # make translation table, decoded letters are lower case 
    tt = str.maketrans( cm[i: i + 6], 'holmes')
    # decoded message so far
    dcm = cm.translate(tt)
    # undecoded zones of the message
    zones = [[a, b] for a, b in [[0, i], [i + 6, len(cm)]] if b - a > 0]

    # <decoder> yields translation tables to apply to the coded message
    for ntt in decoder(dcm, tt, zones):
      print(cm.translate(ntt).upper())

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

# coded message

cm = 'DKCCVTCSZQRZYTAZXTTX'

# minimum word length; if < 3 execution time is very long

mwl = 4

# read words into a dictionary indexed on word length (Credit: Brian)

path = "words_in_frequency_order.txt"

words = dict()

with open(path, "r") as inf:

for line in inf:

ln = len((wd := line.strip()))

words[ln] = words.get(ln, []) + [wd]

# finds new words 'matching' with pds; produces addition to translation table

# pdcm = partially decoded message, pds: partially decoded string

def tryword(pds, pdcm):

# consider words to try (wtt)

for wtt in words[len(pds)]:

# check for anything that can eliminate the candidate word

if (len(set(wtt)) == len(set(pds)) and

not any(((b.islower() and a!= b) or (b.isupper() and a in pdcm))

for a, b in zip(wtt, pds))):

# AOK: result is partial translation table to add to complete table

yield {ord(a): ord(b) for a, b in zip(pds, wtt) if a.isupper()}

# produces complete translation tables

# lower case in string shows letter has been decoded, upper case is undecoded

# pdcm: partially decoded message, tt: translation table, zones to decode

def decoder(pdcm, tt, zones, wc = 1):

if wc == 4:

if len(zones) == 0: # > 0: four words found but message not fully decoded

yield tt

else:

# get next undecoded zone

z = zones[0]

# letter counts of words

for lc in range(mwl, z[1] - z[0] + 1):

# remaining zone or zones after 'inserting' next word

tzones = zones[1:] if z[0] + lc == z[1] else ([[z[0] + lc, z[1]]] if

len(zones) == 1 else [[z[0] + lc, z[1]], zones[1]])

# look for candidate words to 'insert' in the zone designated by 'z'

for a in tryword(pdcm[z[0]: z[0] + lc], pdcm):

yield from decoder(cm.translate(tt | a), tt | a, tzones, wc + 1)

for i in range(len(cm) - 6):

# slide 'HOLMES' along the coded message; there must be 6 different letters

if len(set(cm[i: i + 6])) == 6:

# make translation table, decoded letters are lower case

tt = str.maketrans( cm[i: i + 6], 'holmes')

# decoded message so far

dcm = cm.translate(tt)

# undecoded zones of the message

zones = [[a, b] for a, b in [[0, i], [i + 6, len(cm)]] if b - a > 0]

# <decoder> yields translation tables to apply to the coded message

for ntt in decoder(dcm, tt, zones):

print(cm.translate(ntt).upper())

Reply

Sunday Times Teaser 3298 – Bletchley Park

by Peter Good

Published Sunday December 07 2025 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta