Introduction

If you want Levenshtein matching to stay inside a single word, the main change is not inside the dynamic-programming recurrence itself. The change is in what strings you feed into it. Instead of computing edit distance against an entire sentence or allowing matches to cross spaces, tokenize the text into words and compare the query only against each individual token.

Why Plain Levenshtein Is Too Permissive

Levenshtein distance works on arbitrary strings. If you compare a query against a whole sentence, the algorithm has no idea that spaces mark word boundaries. It will happily find a low-edit path that effectively spans multiple words.

For example, if your query is cart, comparing it to a full string such as red car toy can produce matches that are technically low-edit but semantically wrong for a single-word search.

If the requirement is "match only one word at a time," then the correct approach is to define the matching units as words before computing edit distance.

Step 1: Tokenize the Text

Start by splitting the text into word candidates.

1import re
2
3def tokenize(text):
4    return re.findall(r"\b\w+\b", text.lower())
5
6
7text = "A cart, a car, and a carpet."
8print(tokenize(text))

Output:

['a', 'cart', 'a', 'car', 'and', 'a', 'carpet']

Now each candidate is a single word, which prevents any match from crossing a space or punctuation boundary.

Step 2: Apply Levenshtein Per Word

You can keep a standard Levenshtein implementation and simply run it against each token.

1def levenshtein(a, b):
2    dp = [[0] * (len(b) + 1) for _ in range(len(a) + 1)]
3
4    for i in range(len(a) + 1):
5        dp[i][0] = i
6    for j in range(len(b) + 1):
7        dp[0][j] = j
8
9    for i in range(1, len(a) + 1):
10        for j in range(1, len(b) + 1):
11            cost = 0 if a[i - 1] == b[j - 1] else 1
12            dp[i][j] = min(
13                dp[i - 1][j] + 1,
14                dp[i][j - 1] + 1,
15                dp[i - 1][j - 1] + cost,
16            )
17
18    return dp[-1][-1]
19
20
21query = "crt"
22words = tokenize("A cart, a car, and a carpet.")
23
24for word in words:
25    print(word, levenshtein(query, word))

This preserves the usual edit-distance rules while enforcing the single-word constraint through tokenization.

Step 3: Filter by Threshold

Usually you do not want every word ranked forever. You want words within some maximum edit distance.

1def find_single_word_matches(query, text, max_distance=1):
2    matches = []
3    for word in tokenize(text):
4        distance = levenshtein(query.lower(), word)
5        if distance <= max_distance:
6            matches.append((word, distance))
7    return matches
8
9
10print(find_single_word_matches("crt", "A cart, a car, and a carpet.", max_distance=1))

Output:

[('cart', 1)]

This is the usual practical answer: tokenize, compare per word, then threshold.

Useful Optimization: Length Filtering

If you know the maximum allowed edit distance k, you can skip words whose lengths differ too much:

1def find_single_word_matches(query, text, max_distance=1):
2    matches = []
3    q = query.lower()
4
5    for word in tokenize(text):
6        if abs(len(word) - len(q)) > max_distance:
7            continue
8
9        distance = levenshtein(q, word)
10        if distance <= max_distance:
11            matches.append((word, distance))
12
13    return matches

This is a cheap and effective pruning rule because edit distance must be at least the absolute length difference.

If You Need the Best Match Only

Sometimes you do not want all acceptable matches. You want the best single-word match.

1def best_single_word_match(query, text):
2    candidates = []
3    for word in tokenize(text):
4        candidates.append((word, levenshtein(query.lower(), word)))
5    return min(candidates, key=lambda item: item[1], default=None)
6
7
8print(best_single_word_match("crt", "A cart, a car, and a carpet."))

This is useful for autocomplete suggestions, OCR cleanup, and fuzzy dictionary lookup.

When You Need Better Performance

If the text contains many words or you search repeatedly, computing full dynamic programming for every token can be expensive. Common optimizations include:

• length filtering before distance computation
• banded Levenshtein when a threshold is known
• BK-trees for repeated dictionary lookup
• caching normalized tokens

But those are optimizations on top of the same core rule: only compare against single words, not against the full sentence.

Common Pitfalls

One common mistake is trying to modify the Levenshtein recurrence to understand spaces specially. In many cases, that adds complexity you do not need. Tokenization already enforces the single-word boundary cleanly.

Another issue is forgetting normalization. Case differences, punctuation, and accents can make two words look farther apart than users expect.

Developers also sometimes compare the query against every substring of the text. That reintroduces cross-word matches and usually makes the search slower at the same time.

Finally, choose the threshold carefully. A threshold that is too low misses obvious typos, while a threshold that is too high starts accepting unrelated words.

Summary

• To limit Levenshtein matching to a single word, tokenize first and compare the query against each token separately.
• The core Levenshtein algorithm usually does not need to change.
• Filter by a maximum edit distance to keep only meaningful matches.
• Use length-difference pruning to avoid unnecessary work.
• If performance matters, add threshold-aware or indexed search techniques on top of the same per-word matching strategy.