Jane Street puzzle writeup: Top Score (Give or Take)

Starting out this puzzle proved to be far more challenging than its predecessors. Giving no direct clues apart form the title.

This article outlines the process we followed in solving this intricate puzzle.

Naive beginnings

Starting out we simply assumed that the numbers meant, we had to order the words in the two respective groups by some other metric. Since they were all alphabetically ordered which usually is a clue towards finding a different order.

So we thought about different ways to score words instinctively we looked at scrabble scoring and wrote a quick script to order the words by their scrabble score and replace the numbers with the respective words. This however proved to be a wrong assumption since multiple words had the same score so no absolute order could be determined.

Analyzing the Words

Our next approach was to simply look at and rearrange the words in hopes that some pattern might become evident. This however was not the case. We did notice that paring up the words of the two groups no words had the same length.

We tried removing the amount of letters of the shorter word from the longer one:

But as you may see this didn’t accomplish anything. Removing letters the words had in common also didn’t help.

Finally looking at the title

After hitting roadblock after roadblock we came to the conclusion that our approach was wrong. So we decided to divert more focus toward the title. Specifically the “Give or Take“ part. We were aware that “score” could also have different meanings (e.g. “film music”) however we didn’t yet see how this could be significant.

So we wrote another script to generate words one letter away from our word. We did this by using a list of English words which we subsequently normalized (sorting the letters of each word alphabetically) to achieve a lookup table of letters to possible words.

We than removed a letter form the word at every position and appended a letter to the word.

def normalize_word(word):
  return ''.join(sorted(word))

def find_words_with_distance_1(target, word_list):
    # Create dict
    word_dict = {}
    for word in word_list:
        normalized = normalize_word(word)
        if normalized not in word_dict.keys():
            word_dict[normalized] = set()
        word_dict[normalized].add(word)

    word_chars = list(normalize_word(target))
    possible_words = set()

    # Delete Letters
    for i in range(len(word_chars)):
        modified = word_chars[:i] + word_chars[i+1:]
        key = ''.join(modified)
        if key in word_dict:
            possible_words.update(word_dict[key])

    # Insert letters
    for letter in 'abcdefghijklmnopqrstuvwxyz':
        for i in range(len(word_chars) + 1):
            modified = word_chars[:i] + [letter] + word_chars[i:]
            key = normalize_word(modified)
            if key in word_dict:
                possible_words.update(word_dict[key])

    return possible_words

This left us with a giant list of words. So time to simplify.

Attempt One - Using scrabble scoring

Our first attempt to narrow down the list involved using Scrabble scores to prioritize the highest-scoring words. However, this was a flawed strategy since longer words (especially those containing "Q" and "Z") were disproportionately favored, making it ineffective for identifying a "taking" element.

Attempt Two - Recognizing an obscure Pattern

Late at night I was staring at the google sheet we set up for this puzzle when suddenly I had a epiphany. I saw that one could convert the word “premise” to “empire” and “stickers“ to “strikes”. My mind auto completed “The empire strikes back”. Which I first dismissed as a funny accident, later I saw that is was also possible to build more movie titles like “Star Wars“ and “Raiders of the lost ark“. This is were we remembered that we discussed “Top score” possibly meaning something else.

So we tried matching films to the “key” by firstly ignoring the numbers and using them only as placeholders. We later realized that all films fitting the key are listed within the Compositions by John Williams Article. So we were soon able to complete the key.

We noticed that the letters removed and added were identical when the two words shared the same number. This led us to consider whether the number represented the index of the added or removed letter within a specific phrase. This resulted in:

F I L M C O M P O S E R J W

This refers to John Williams, the composer behind the scores of these films. His name is a proper noun and also the solution to this puzzle.