• • ━ • • • • • • ━ ━ • • ━ • ━ •
It decodes to Fehmic, which you might remember as a variant of "Vehmic", which means related to the Vehm, a tribunal system that had its heyday from the 13th to the 15th century in in Westphalia.
And the locations?
And the locations?
If I haven't missed anything, they are this puzzle's red herring.
(Or not. Stiv, the puzzle's creator, states in a comment that if something is ordered that's probably a hint that it must be re-ordered. So the locations serve as initial ordering criterion and are a hint to look for another crierion. Too subtle for me, I'm afraid.)
How to split up the code?
Or, more explicitly: How did I find the breaks between the letters in the stretch of dits and dahs?
I wrote a program for that, of course.
One approach is to tackle the code recursively: Assume that the first letter is an E, chop it off and recurse on the rest of the string. and accumulate the result as you go. When you reach the end of the string, check the result, e.g. EEDHZC against a dictionary. If it is in the dictionary, print it.
This approach works well here: The code is short and we know that the answer must be six letters long, so we can stop short if we reach that limit. There are 371 possible six-letter-combinations that can be made from the given string. You could even just print them and sift through the possibilities without a dictionary. (I'm not sure, FEHMIC would have stood out to me as possible answer, though.)
But for longer codes, especially if you have an ancoded sentence without letter or word breaks, it falls flat quickly: It generates too many possible solutions, nearly all of them gibberish.
So I usually use the other approach: Write a routine to encode a word into Morse code. Then run that code on a file of dictionary words and search for the given pattern. That's a bit brute-force-ish, but thatsolution will always be linear in the size of the dictionary, whereas trying to find combinations is only feasible for small codes.
I also find that this approach can work for finding the splits between words in sentences: Run the input code against each word in a dictionary file. Convert the word to Morse and if you find the Morse code in your input, highlight its position and print it together with the word, e.g.:
-.-----..-###########-.....-...-....-...-.. KNOW
Now sort the output lexicographically. (The hash mark comes before the dot and dash.) You get a river of hashes flowing from the top left to the bottom right. Now try to find patterns and assemble adjacent bits. A text editor that can make column selections helps a lot.
This is trial and error: A small dictionary may miss words; a large dictionary makes the output large too and it's hard to see patterns. Start with a small dict to find common words like articles, pronound or conjunctions. Then work on the gaps between those.
(For what it's worth, I like using Scowl for this, which has word lists arranged into thematical groups (common, proper, abbreviations, UK, US, Canadian, ...) and into word frequency ranges, so you can pick the 10-percentile of common words, for example.)
Anyway, I used that second approach here: Read a dictionary file, convert each word into Morse and compare. It's straightforward to program and fast if you must match a single input. It's also easy to modify and I can also print all words plus code unconditionally and grep the output with wildcards.
When I had an inkling that the Morse signals should be sorted, but didn't yet see how, I tries a variant of that approach: Convert each word in a dictionary file, then count the dots and dashes. If we have 12 dots and 5 dashes, print the word. That yielded several pages of words. I skimmed them, but must have blinked when I got to FEHMIC.
