Question

Let’s say I have the word “CAT”. These words differ from “CAT” by one letter (not the full list)

• CUT
• CAP
• PAT
• FAT
• COT
• etc.

Is there an elegant way to generate this? Obviously, one way to do it is through brute force.

pseduo code:

while (0 to length of word)
    while (A to Z)
        replace one letter at a time, and check if the resulting word is a valid word

If I had a 10 letter word, the loop would run 26 * 10 = 260 times.

Is there a better, elegant way to do this?

Answer 1

Given a list of words, for example with

words = set(line.strip().lower() for line in open('/usr/share/dict/words'))

you can build and index of “wildcarded” words, where you replace each character of the word with a wildcard (say “?”), so that for example “gat” and “fat” both get indexed to “?at”:

def wildcard(s, idx):
    return s[:idx] + '?' + s[idx+1:]

def wildcarded(s):
    for idx in xrange(len(s)):
        yield wildcard(s, idx)

# list(wildcarded('cat')) returns ['?at', 'c?t', 'ca?']

from collections import defaultdict
index = defaultdict(list)

for word in words:
    for w in wildcarded(word):
        index[w].append(word)

Now if you want to look for all the words that differ by one letter from “cat”, just look for “?at”, “c?t” and “ca?” and concatenate the results:

def near_words(word):
    ret = []
    for w in wildcarded(word):
        ret += index[w]
    return ret

print near_words('cat')
# outputs ['cat', 'bat', 'zat', 'jat', 'kat', 'rat', 'sat', 'pat', 'hat', 'oat', 'gat', 'vat', 'nat', 'fat', 'lat', 'wat', 'eat', 'yat', 'mat', 'tat', 'cat', 'cut', 'cot', 'cit', 'cay', 'car', 'cap', 'caw', 'cat', 'can', 'cam', 'cal', 'cad', 'cab', 'cag']
print near_words('stack')
# outputs ['stack', 'stack', 'smack', 'spack', 'slack', 'snack', 'shack', 'swack', 'stuck', 'stack', 'stick', 'stock', 'stank', 'stack', 'stark', 'stauk', 'stalk', 'stack']

If the maximum word length is L and the number of words is N, the index is made of O(NL) pointers, while the lookup algorithm runs in time O(L + number of results).

If you want to look for all the words that differ by K letters instead of 1 this approach doesn’t generalize well, but it is a very hard problem in full generality (it is the problem of finding neighbors in Hamming spaces).