Search

Vowel Spellchecker

Updated: Mar 24, 2021

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"

  • Example: wordlist = ["Yellow"], query = "yellow": correct = "Yellow"

  • 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"

  • Example: wordlist = ["YellOw"], query = "yeellow": correct = "" (no match)

  • Example: wordlist = ["YellOw"], query = "yllw": correct = "" (no match)


In addition, the spell checker operates under the following precedence rules:

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

  • When the query matches a word up to capitlization, you should return the first such match in the wordlist.

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

  • If the query has no matches in the wordlist, you should return the empty string.

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


Example 1:

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:

  • 1 <= wordlist.length <= 5000

  • 1 <= queries.length <= 5000

  • 1 <= wordlist[i].length <= 7

  • 1 <= queries[i].length <= 7

  • All strings in wordlist and queries consist only of english letters.

Solution:


class Solution {
    Set<String> Original;
        Map<String,String> caseSensitive;
        Map<String,String> vowels;
    public String[] spellchecker(String[] wordlist, String[] queries) {
        Original = new HashSet();
        caseSensitive = new HashMap<>();
        vowels = new HashMap<>();
        String[] result = new String[queries.length];
        
        for(String word:wordlist)
        {
            Original.add(word);
            
            String wordlow = word.toLowerCase();
            caseSensitive.putIfAbsent(wordlow,word);
            
            String wordwithVowel = wordlow.replaceAll("[aeiou]","*");
            vowels.putIfAbsent(wordwithVowel,word);
            
        }
        int t=0;
        for(String query:queries)
        {
            result[t++]=helper(query);
        }
        return result;
    }
    
    public String helper(String query)
    {
        if(Original.contains(query))
            return query;
        
        String lowword = query.toLowerCase();
        if(caseSensitive.containsKey(lowword))
            return caseSensitive.get(lowword);
        
        String wordvowel = lowword.replaceAll("[aeiou]","*");
        if(vowels.containsKey(wordvowel))
            return vowels.get(wordvowel);
        
        return "";
    }
    
}



9 views0 comments

Recent Posts

See All

A string s is called good if there are no two different characters in s that have the same frequency. Given a string s, return the minimum number of characters you need to delete to make s good. The f

The numeric value of a lowercase character is defined as its position (1-indexed) in the alphabet, so the numeric value of a is 1, the numeric value of b is 2, the numeric value of c is 3, and so on.