Europe’s Ultimate Coding Competition is in the books for another year!
With this in mind, we sat down with our 2025 CODE100 Champion, Nimrod Kor, to look back on how he solved the puzzle in the final round to secure victory.
The Challenge
Our final coding challenge asked participants to decrypt a secret message using a quirky encryption method. The message looked like gibberish at first glance:
f14h2f27o2y11 u42s12f14u14a36 u42j6w27a2 l38g12y5...
In addition to this, challengers had a key:
the quick brown fox jumps over the lazy dog
This sentence is a classic pangram, meaning it includes every letter of the alphabet.
Finally, we gave a series of clues, with the final one jumping out at Nimrod right away:
- Words encrypted this way only contain the letters a to z
- The key sentence is known to contain all letters of the alphabet
- Letters in the encryption don’t actually do much
Understanding the Encryption
So, encrypted words looked like this:
f14h2f27o2y11
At first, they seem like nonsense, but if we look closer we can see they are a mix of letters and numbers. But if letters don’t actually mean much, we can just focus on the letters, right?
Nimrod then looks back at the examples provided and saw:
"test" → h0n2i24q0
We see lots of letters (that we can ignore, because they’re just noise), with the numbers 0, 2, 24, and 0.
Could zero relate to the letter ‘T’?
Nimrod figured out that, numbers correspond to positions in the key sentence, each position maps to a letter in the key and that those letters are used to build the final word.
So, Nimrod turned to Python, and started writing code.
Extracting the Key
Nimrod first created a key variable from the key sentence:
key = "the quick brown fox jumps over the lazy dog"
This string is treated as a sequence of characters, so key[0] is 't', key[1] is 'h', and so on.
Any number in the encrypted string (like 14, 2, or 36) is treated as an index into this string.
In addition to this, our input data was stored as q_input, to clear up any confusion later on.
Breaking Up the Encryption
To sort the data, Nimrod imported the ‘re’ package (which allowed him to work with regular expressions), and used the split method to split the encrypted letters.
Now let’s look at this part a little more closely:
enc_letters = re.split(r"\D", enc_word)
This line uses a regular expression to split the encrypted word whenever a non-digit character appears (i.e., whenever it hits a letter). This, quite elegantly, leaves only the numbers.
For example:
enc_word = "f14h2f27o2y11"
re.split(r"\D", enc_word) => ['', '14', '2', '27', '2', '11']
Pretty nice, right?
Then the code filters out empty strings and converts each number to an integer:
[key[int(enc_l)] for enc_l in enc_letters if enc_l]
So we’re collecting characters from the key string at those numbered positions.
Finally, it joins those characters to form a word.
Putting It All Together
Here’s the full logic in action:
# RE has been imported, keys and q_input are stored as variables
if __name__ == "__main__":
enc_words = q_input.split(" ") # Split the encrypted sentence into words
words = [] # Create an array that we will populate later
for enc_word in enc_words: # Loop over the words
enc_letters = re.split(r"\D", enc_word) # Get only the numbers
word = "".join([key[int(enc_l)] for enc_l in enc_letters if enc_l]) # Map numbers to letters
words.append(word) # Add word to
print(" ".join(words))
This program:
- Splits the encrypted sentence into words
- Extracts digits from each word
- Uses those digits to index into the key sentence
- Reconstructs each decrypted word in the words array
- Joins and prints the final message with all words contained
Final Words
Kudos to Nimrod Kor for cracking the code so cleanly, and so efficiently and for being such a great challenger!
If you’re reading this and thinking “I could’ve solved that,” stay tuned for our next challenge because there’s always another puzzle just around the corner.