This post will derive an optimal Wordle-specific guessing strategy. The approach taken will be reducing the set of possible words a maximum amount for each guess; however, it doesn’t make sense to keep reducing the set of words until the final guess, so we’re reintroduced to our old friend, the explore-exploit tradeoff.

The first question we need to answer is, given six guesses, how many should be exploring which consonants and vowels are and aren’t present, and how many should exploit that knowledge to guess the word? These two options aren’t completely exclusive, but a common problem I see in my own family, is exploring after only the first word and getting stuck in a rut of limited guesses.

This can be interpreted as an optimization problem: How many guesses maximize the exploration and exploitation value? Meaning, how many guesses should explore the possible letter combinations and how many should use that to guess the word.

Taking inspiration from the Secretary Problem, let’s “reject” the first $\frac{N}{e}$ choices and “accept” the next best. Simply, let’s not consider the first $\frac{6}{e} \approx 2$ guesses toward our exploitation and then try guessing afterwards.

Another option is to maximize the gradient (ML people get hyped) over word-set size as the exploitation strategy. This would mean that you’d stop exploring letters after each following step stops reducing the set size as much.

This is hand-wavy because I mostly want to dive into the CS, but even this can be calculated… I’ll maybe do that as well. Instead, I’ll see when the letter frequencies plateau and conclude that guessing letters past that point just offer diminishing returns.

Here’s the list of all wordle words as of writing this, though I doubt it’ll change much. It might be helpful to have in case you want to run your own tests or follow along.

from matplotlib import pyplot as plt
from itertools import permutations

def letter_distribution(words):
    d = {}
    for word in words:
        for letter in word:
            d[letter] = d.get(letter, 0) + 1
    return d


def letter_placement(words):
    d = {0: {}, 1: {}, 2: {}, 3: {}, 4: {}}
    for word in words:
        for i, letter in enumerate(word):
            d[i][letter] = d[i].get(letter, 0) + 1
    return d


def score_placement(word, letter_places):
    score = 0
    for i, letter in enumerate(word):
        score += letter_places[i][letter]
    return score


def subset_from_letters(word : str, words : set) -> set:
    return set(wordle for wordle in words \
               if set(wordle).issubset(word))

# map's lambda takes the first 5 characters of each line
# in wordles.txt, removing the \n character
words = set(map(lambda x: x[:5], open("wordles.txt", "r")))

letter_dist = letter_distribution(words)
dist = sorted(letter_dist.items(), key=lambda x: x[1], reverse=True)

plt.bar([x[0] for x in dist], [y[1] for y in dist])
plt.show()

print(set(word for word in subset_from_letters("seaor", words) \
					if len(set(word)) == 5))

print(set(word for word in subset_from_letters("iltnu", words) \
					if len(set(word)) == 5))

print(set(word for word in subset_from_letters("dycpm", words) \
					if len(set(word)) == 5))

letter_places = letter_placement(words)

first = {'aeros', 'soare', 'arose'}
second = {'unlit', 'until'}

for word in first:
    print(word, score_placement(word, letter_places))

for word in second:
    print(word, score_placement(word, letter_places))

exploit_count = 3
letters = ''.join([letter for letter, count in dist[:exploit_count * 5]])

for word in permutations(letters):
    first = set(w for w in subset_from_letters(word[:5], words) \
                if len(set(w)) == 5)
    second = set(w for w in subset_from_letters(word[5:10], words) \
                 if len(set(w)) == 5)
    third = set(w for w in subset_from_letters(word[10:15], words) \
                if len(set(w)) == 5)

    if first and second and third:
        print(first, second, third)
        break

Solution

It was mentioned in a Hacker News comment that there are actually two lists: one for guessing and another for possible answers. Using this, I updated the best first couple words. I’ll also include these, but deriving it is simple with the code above. You can also view updated code as a PDF.

I’m sure there are different approaches to determining the best starting word. Some people like the most vowels (in that case use URAEI) while others would prioritize positions (then choose SLATE). I think knocking out the most potential words would help me the most, so that’s why I chose this method.

A benefit of this is that after only two steps of exploration, you have information about ten unique letters. Another step will now put you at fifteen, over half of the alphabet. I hope this comes in handy and you enjoyed the read!