Vowel Spellchecker - Practice Coding Problems

Vowel Spellchecker - Problem

🔍 Build a Smart Spell Checker

Imagine building an auto-correct feature for a text editor! Given a dictionary of correctly spelled words (wordlist), you need to implement a spell checker that fixes common typing mistakes in query words.

Your spell checker should handle two types of errors with specific precedence rules:

📝 Capitalization Errors: If a query word matches a dictionary word ignoring case, return the original dictionary word with its proper capitalization.
Example: Dictionary has "yellow", query is "YellOw" → return "yellow"

🔤 Vowel Errors: If replacing any vowels (a,e,i,o,u) in the query makes it match a dictionary word (case-insensitive), return that dictionary word.
Example: Dictionary has "YellOw", query is "yollow" → return "YellOw"

⚖️ Precedence Rules:
1. Exact match (case-sensitive) - highest priority
2. Case-insensitive match - return first match in wordlist
3. Vowel error match - return first match in wordlist
4. No match - return empty string

Given multiple queries, return the corrected word for each query following these rules.

Input & Output

example_1.py — Basic Spell Checking

$ Input: wordlist = ["KiTe", "kite", "hare", "Hare"] queries = ["kite", "Kite", "KiTe", "Hare", "HARE", "Hear", "hear", "keti", "keet", "keto"]

› Output: ["kite", "KiTe", "KiTe", "Hare", "hare", "", "", "KiTe", "", "KiTe"]

💡 Note: - "kite" exact match → "kite" - "Kite" case-insensitive match with "kite" (first occurrence) → "KiTe" - "KiTe" exact match → "KiTe" - "Hare" exact match → "Hare" - "HARE" case-insensitive match with "hare" (first occurrence) → "hare" - "Hear" and "hear" no matches → "" - "keti" vowel pattern matches "KiTe" (k*t*) → "KiTe" - "keet" no match → "" - "keto" vowel pattern matches "KiTe" (k*t*) → "KiTe"

example_2.py — Precedence Rules

$ Input: wordlist = ["yellow", "Yellow"] queries = ["yellow", "Yellow", "YELLOW", "yollow"]

› Output: ["yellow", "Yellow", "yellow", "yellow"]

💡 Note: - "yellow" exact match (highest priority) → "yellow" - "Yellow" exact match → "Yellow" - "YELLOW" case-insensitive match with "yellow" (first in wordlist) → "yellow" - "yollow" vowel pattern match with "yellow" (y*ll*w) → "yellow"

example_3.py — Edge Cases

$ Input: wordlist = ["ae", "aa"] queries = ["aei", "aea", "xyz"]

› Output: ["", "ae", ""]

💡 Note: - "aei" has pattern "***" which doesn't match "ae" (*) or "aa" (**) → "" - "aea" has pattern "***" which doesn't match existing patterns → "" - "xyz" no matches in any category → ""

Visualization

Tap to expand

Understanding the Visualization

Exact Match Check

First, check if the query exactly matches any word in our dictionary

Case-Insensitive Check

If no exact match, ignore capitalization and find the first matching word

Vowel Pattern Check

If still no match, replace vowels with wildcards and find pattern matches

No Match Found

If all checks fail, return empty string indicating no correction available

Key Takeaway

🎯 Key Insight: Build specialized hash maps for each matching type, then check them in precedence order for O(1) query processing!

Time & Space Complexity

Time Complexity

⏱️

O(m × n × k)

m queries × n words × k average word length for string comparisons

✓ Linear Growth

Space Complexity

O(1)

Only using variables for iteration, no extra data structures

✓ Linear Space

Constraints

1 ≤ wordlist.length, queries.length ≤ 5000
1 ≤ wordlist[i].length, queries[i].length ≤ 7
wordlist[i] and queries[i] consist only of English letters
All words are case-sensitive for exact matching

Asked in

G Google 42 ⊞ Microsoft 28 a Amazon 31 f Facebook 19

The optimal approach uses hash table preprocessing to build three lookup structures: exact match set, case-insensitive map, and vowel pattern map. For each query, we check these maps in precedence order achieving O(1) lookup time per query after O(n×k) preprocessing.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Word)	O(m × n × k)	O(1)	For each query, check against every dictionary word using all matching rules
Hash Table Preprocessing	O(n×k + m×k)	O(n×k)	Build hash maps for each match type, then lookup queries efficiently

Brute Force (Check Every Word) — Algorithm Steps

For each query, first scan entire wordlist for exact matches
If no exact match, scan wordlist again for case-insensitive matches
If no case match, scan wordlist again checking vowel-pattern matches
Return first match found or empty string if no matches

Visualization

Tap to expand

Step-by-Step Walkthrough

Exact Match Check

First pass: check query against each word for exact case-sensitive match

Case-Insensitive Check

Second pass: convert both query and each word to lowercase and compare

Vowel Pattern Check

Third pass: replace vowels with wildcards and compare patterns

Code -

solution.c — C

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

char* vowelPattern(const char* word) {
    int len = strlen(word);
    char* pattern = malloc(len + 1);
    
    for (int i = 0; i < len; i++) {
        char c = tolower(word[i]);
        if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
            pattern[i] = '*';
        } else {
            pattern[i] = c;
        }
    }
    pattern[len] = '\0';
    return pattern;
}

int strcasecmp_custom(const char* s1, const char* s2) {
    while (*s1 && *s2) {
        if (tolower(*s1) != tolower(*s2)) {
            return tolower(*s1) - tolower(*s2);
        }
        s1++; s2++;
    }
    return tolower(*s1) - tolower(*s2);
}

char* solveQuery(char** wordlist, int wordlistSize, const char* query) {
    // Priority 1: Exact match
    for (int i = 0; i < wordlistSize; i++) {
        if (strcmp(wordlist[i], query) == 0) {
            return wordlist[i];
        }
    }
    
    // Priority 2: Case-insensitive match
    for (int i = 0; i < wordlistSize; i++) {
        if (strcasecmp_custom(wordlist[i], query) == 0) {
            return wordlist[i];
        }
    }
    
    // Priority 3: Vowel error match
    char* queryPattern = vowelPattern(query);
    for (int i = 0; i < wordlistSize; i++) {
        char* wordPattern = vowelPattern(wordlist[i]);
        if (strcmp(wordPattern, queryPattern) == 0) {
            free(wordPattern);
            free(queryPattern);
            return wordlist[i];
        }
        free(wordPattern);
    }
    free(queryPattern);
    
    // Priority 4: No match - return empty string
    return "";
}

char** spellchecker(char** wordlist, int wordlistSize, char** queries, int queriesSize, int* returnSize) {
    *returnSize = queriesSize;
    char** result = malloc(queriesSize * sizeof(char*));
    
    for (int i = 0; i < queriesSize; i++) {
        char* answer = solveQuery(wordlist, wordlistSize, queries[i]);
        result[i] = malloc(strlen(answer) + 1);
        strcpy(result[i], answer);
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n × k)

m queries × n words × k average word length for string comparisons

✓ Linear Growth

Space Complexity

O(1)

Only using variables for iteration, no extra data structures

✓ Linear Space

Constraints

1 ≤ wordlist.length, queries.length ≤ 5000
1 ≤ wordlist[i].length, queries[i].length ≤ 7
wordlist[i] and queries[i] consist only of English letters
All words are case-sensitive for exact matching

18.4K Views

Medium Frequency

~18 min Avg. Time

892 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check Every Word) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler