Vowel Spellchecker

Vowel Spellchecker - Problem

Given a wordlist, we want to implement a spellchecker that converts a query word into a correct word.

For a given query word, the spell checker handles two categories of spelling mistakes:

Capitalization: If the query matches a word in the wordlist (case-insensitive), then the query word is returned with the same case as the case in the wordlist.

Example: wordlist = ["yellow"], query = "YellOw" → correct = "yellow"

Vowel Errors: If after replacing the vowels ('a', 'e', 'i', 'o', 'u') of the query word with any vowel individually, it matches a word in the wordlist (case-insensitive), then the query word is returned with the same case as the match in the wordlist.

Example: wordlist = ["YellOw"], query = "yollow" → correct = "YellOw"

The spell checker operates under the following precedence rules:

1. When the query exactly matches a word in the wordlist (case-sensitive), return the same word back.

2. When the query matches a word up to capitalization, return the first such match in the wordlist.

3. When the query matches a word up to vowel errors, return the first such match in the wordlist.

4. If the query has no matches in the wordlist, return the empty string.

Given some queries, return a list of words answer, where answer[i] is the correct word for query = queries[i].

Input & Output

Example 1 — Mixed Cases and Vowel Errors

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

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

💡 Note: "kite": exact match. "Kite": case match with "KiTe" (first). "KiTe": exact match. "Hare": exact match. "HARE": case match with "hare". "Hear": no vowel match. "hear": no match. "keti": vowel match with "KiTe".

Example 2 — Priority Testing

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

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

💡 Note: All queries have exact matches in the wordlist, so they return themselves unchanged.

Example 3 — No Matches

$ Input: wordlist = ["hello"], queries = ["hi", "world", "test"]

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

💡 Note: None of the queries match "hello" exactly, by case, or by vowel pattern, so all return empty strings.

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

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 A Apple 8

The key insight is to preprocess the wordlist into hash maps for each match type (exact, case-insensitive, vowel pattern) to enable O(1) lookups. Best approach uses hash map optimization with Time: O(m×k + n×k), Space: O(m×k).

Common Approaches

✓ Brute Force

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

For every query, iterate through the entire wordlist multiple times: first for exact matches, then for case-insensitive matches, then for vowel pattern matches. This approach doesn't preprocess the wordlist.

Hash Map Optimization

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

First pass builds three hash maps: exact matches, case-insensitive patterns, and vowel patterns. Second pass queries these maps for each input query in priority order.

Brute Force — Algorithm Steps

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

Visualization

Tap to expand

Step-by-Step Walkthrough

Exact Match

Check if query exactly matches any word

Case Match

Check if query matches ignoring case

Vowel Match

Check if vowel patterns match

Code -

solution.c — C

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

void normalizeVowels(const char* word, char* result) {
    int i = 0;
    while (word[i] != '\0') {
        char c = tolower(word[i]);
        if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
            result[i] = '*';
        } else {
            result[i] = c;
        }
        i++;
    }
    result[i] = '\0';
}

int containsWord(char** wordlist, int wordlistSize, const char* query) {
    for (int i = 0; i < wordlistSize; i++) {
        if (strcmp(wordlist[i], query) == 0) {
            return 1;
        }
    }
    return 0;
}

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

char** solution(char** wordlist, int wordlistSize, char** queries, int queriesSize, int* returnSize) {
    char** result = (char**)malloc(queriesSize * sizeof(char*));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        char* query = queries[i];
        
        // Priority 1: Exact match
        if (containsWord(wordlist, wordlistSize, query)) {
            result[i] = strdup(query);
            continue;
        }
        
        // Priority 2: Case-insensitive match
        int found = 0;
        for (int j = 0; j < wordlistSize; j++) {
            if (strcasecmp_custom(wordlist[j], query) == 0) {
                result[i] = strdup(wordlist[j]);
                found = 1;
                break;
            }
        }
        
        if (found) {
            continue;
        }
        
        // Priority 3: Vowel error match
        char queryPattern[1000];
        normalizeVowels(query, queryPattern);
        found = 0;
        for (int j = 0; j < wordlistSize; j++) {
            char wordPattern[1000];
            normalizeVowels(wordlist[j], wordPattern);
            if (strcmp(wordPattern, queryPattern) == 0) {
                result[i] = strdup(wordlist[j]);
                found = 1;
                break;
            }
        }
        
        if (!found) {
            result[i] = strdup("");
        }
    }
    
    return result;
}

void parseJsonStringArray(const char* json, char*** array, int* size) {
    *size = 0;
    *array = NULL;
    
    const char* p = json;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    char temp[10000];
    int tempLen = 0;
    int inString = 0;
    
    while (*p && *p != ']') {
        if (*p == '"') {
            if (!inString) {
                inString = 1;
                tempLen = 0;
            } else {
                temp[tempLen] = '\0';
                *array = (char**)realloc(*array, (*size + 1) * sizeof(char*));
                (*array)[*size] = strdup(temp);
                (*size)++;
                inString = 0;
            }
        } else if (inString) {
            temp[tempLen++] = *p;
        }
        p++;
    }
}

void printJsonStringArray(char** array, int size) {
    printf("[");
    for (int i = 0; i < size; i++) {
        printf("\"%s\"", array[i]);
        if (i < size - 1) printf(",");
    }
    printf("]\n");
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    char** wordlist;
    char** queries;
    int wordlistSize, queriesSize;
    
    parseJsonStringArray(line1, &wordlist, &wordlistSize);
    parseJsonStringArray(line2, &queries, &queriesSize);
    
    int returnSize;
    char** result = solution(wordlist, wordlistSize, queries, queriesSize, &returnSize);
    
    printJsonStringArray(result, returnSize);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × k)

For each query (n), we scan wordlist (m) and compare strings of length k

✓ Linear Growth

Space Complexity

O(1)

Only using variables for iteration, no extra data structures

✓ Linear Space

31.3K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler