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"
- 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: HashTable
Using 3 hashtables: original words, lower cases, lower cases with vowels replaced to “*”
Time complexity: O(|W|+|Q|)
Space complexity: O(|W|)
C++
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
class Solution { public: vector<string> spellchecker(vector<string>& wordlist, vector<string>& queries) { vector<string> ans; unordered_map<string, string> m_org; unordered_map<string, string> m_low; unordered_map<string, string> m_vow; for (const string& w : wordlist) { // Original word m_org[w] = w; // Case-insensitive string l = toLower(w); if (!m_low.count(l)) m_low[l] = w; // Vowel-insensitive string o = replaceVowels(l); if (!m_vow.count(o)) m_vow[o] = w; } for (const string& q : queries) { if (m_org.count(q)) { ans.push_back(q); continue; } string l = toLower(q); if (m_low.count(l)) { ans.push_back(m_low[l]); continue; } string o = replaceVowels(l); if (m_vow.count(o)) { ans.push_back(m_vow[o]); continue; } ans.push_back(""); } return ans; } private: string toLower(const string& s) { string l(s); std::transform(begin(s), end(s), begin(l), ::tolower); return l; } string replaceVowels(const string& s) { string o(s); for (char& c : o) if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') c = '*'; return o; } }; |
Python3
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
class Solution: def spellchecker(self, wordlist, queries): org = dict() low = dict() vow = dict() for w in wordlist: org[w] = w l = w.lower() if l not in low: low[l] = w v = re.sub(r'[aeiou]', '*', l) if v not in vow: vow[v] = w ans = [] for q in queries: if q in org: ans.append(q) continue l = q.lower() if l in low: ans.append(low[l]) continue v = re.sub(r'[aeiou]', '*', l) if v in vow: ans.append(vow[v]) continue ans.append("") return ans |