Spell Checker - Problem

Given a misspelled word and a dictionary of correct words, implement a spell checker that suggests the closest match using edit distance (Levenshtein distance).

The edit distance between two strings is the minimum number of single-character operations (insertions, deletions, or substitutions) required to change one string into another.

Return the word from the dictionary that has the minimum edit distance to the misspelled word. If there are multiple words with the same minimum distance, return the lexicographically smallest one.

Input & Output

Example 1 — Basic Case

$ Input: word = "teh", dictionary = ["cat", "dog", "the", "hat"]

› Output: "the"

💡 Note: Edit distances: 'teh' to 'cat' = 3, to 'dog' = 3, to 'the' = 1 (swap e and h), to 'hat' = 2. Minimum is 1, so return 'the'.

Example 2 — Multiple Matches

$ Input: word = "abc", dictionary = ["ab", "ac", "bc"]

› Output: "ab"

💡 Note: Edit distances: 'abc' to 'ab' = 1 (delete c), to 'ac' = 1 (delete b), to 'bc' = 1 (delete a). All have distance 1, return lexicographically smallest: 'ab'.

Example 3 — Exact Match

$ Input: word = "hello", dictionary = ["hello", "world"]

› Output: "hello"

💡 Note: Perfect match exists with distance 0, so return 'hello'.

Constraints

1 ≤ word.length ≤ 100
1 ≤ dictionary.length ≤ 100
1 ≤ dictionary[i].length ≤ 100
word and dictionary[i] consist of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 32 M Microsoft 28 A Amazon 24 🍎 Apple 18

The key insight is using dynamic programming to calculate edit distance efficiently. The optimal approach uses space-optimized DP with two arrays instead of a full 2D table. Time: O(n × m × k), Space: O(min(m,k))

Common Approaches

✓ Brute Force with Basic Edit Distance

⏱️ Time: O(n × 3^max(m,k)) Space: O(max(m,k))

For each word in the dictionary, calculate the edit distance to the misspelled word using a simple recursive function. Track the minimum distance and corresponding word.

Dynamic Programming with 2D Table

⏱️ Time: O(n × m × k) Space: O(m × k)

For each dictionary word, build a 2D DP table where dp[i][j] represents the minimum edit distance between the first i characters of the misspelled word and first j characters of the dictionary word.

Space-Optimized Dynamic Programming

⏱️ Time: O(n × m × k) Space: O(min(m, k))

Optimize the DP approach by observing that we only need the previous row to calculate the current row. Use two 1D arrays alternating between previous and current row.

Brute Force with Basic Edit Distance — Algorithm Steps

Iterate through each word in dictionary
Calculate edit distance recursively for each word
Track minimum distance and best match
Return the lexicographically smallest word among ties

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare with Each Word

Iterate through dictionary words one by one

Recursive Distance

Calculate edit distance using recursive calls

Track Best Match

Keep minimum distance and corresponding word

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

int min(int a, int b) {
    return a < b ? a : b;
}

int editDistanceRecursive(const char* s1, const char* s2, int i, int j, int len1, int len2) {
    if (i == len1) return len2 - j;
    if (j == len2) return len1 - i;
    
    if (s1[i] == s2[j]) {
        return editDistanceRecursive(s1, s2, i + 1, j + 1, len1, len2);
    }
    
    int insert = editDistanceRecursive(s1, s2, i, j + 1, len1, len2);
    int delete = editDistanceRecursive(s1, s2, i + 1, j, len1, len2);
    int substitute = editDistanceRecursive(s1, s2, i + 1, j + 1, len1, len2);
    
    return 1 + min(insert, min(delete, substitute));
}

char* solution(char* word, char dictionary[][101], int dictSize) {
    int minDistance = INT_MAX;
    static char bestMatch[101];
    bestMatch[0] = '\0';
    
    int wordLen = strlen(word);
    
    for (int i = 0; i < dictSize; i++) {
        int distance = editDistanceRecursive(word, dictionary[i], 0, 0, wordLen, strlen(dictionary[i]));
        if (distance < minDistance || (distance == minDistance && strcmp(dictionary[i], bestMatch) < 0)) {
            minDistance = distance;
            strcpy(bestMatch, dictionary[i]);
        }
    }
    
    return bestMatch;
}

int main() {
    char word[101];
    fgets(word, sizeof(word), stdin);
    word[strcspn(word, "\n")] = 0;
    
    char dictLine[1001];
    fgets(dictLine, sizeof(dictLine), stdin);
    dictLine[strcspn(dictLine, "\n")] = 0;
    
    // Parse dictionary array manually
    char dictionary[20][101];
    int dictSize = 0;
    
    char* token = strtok(dictLine, "[\"],:; ");
    while (token != NULL && dictSize < 20) {
        if (strlen(token) > 0 && token[0] != '[' && token[0] != ']') {
            strcpy(dictionary[dictSize], token);
            dictSize++;
        }
        token = strtok(NULL, "[\"],:; ");
    }
    
    printf("%s\n", solution(word, dictionary, dictSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 3^max(m,k))

For each of n dictionary words, recursive edit distance takes exponential time due to overlapping subproblems

✓ Linear Growth

Space Complexity

O(max(m,k))

Recursion stack depth is at most the length of longer string

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Spell Checker - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Basic Edit Distance — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler