[Swift]LeetCode890. 查找和替换模式 | Find and Replace Pattern

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10605199.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

You have a list of words and a pattern, and you want to know which words in words matches the pattern.

A word matches the pattern if there exists a permutation of letters p so that after replacing every letter x in the pattern with p(x), we get the desired word.

(Recall that a permutation of letters is a bijection from letters to letters: every letter maps to another letter, and no two letters map to the same letter.)

Return a list of the words in words that match the given pattern. 

You may return the answer in any order.

Example 1:

Input: words = ["abc","deq","mee","aqq","dkd","ccc"], pattern = "abb"
Output: ["mee","aqq"]
Explanation: "mee" matches the pattern because there is a permutation {a -> m, b -> e, ...}. 
"ccc" does not match the pattern because {a -> c, b -> c, ...} is not a permutation,
since a and b map to the same letter.

Note:

• 1 <= words.length <= 50
• 1 <= pattern.length = words[i].length <= 20

---

你有一个单词列表 words 和一个模式  pattern，你想知道 words 中的哪些单词与模式匹配。

如果存在字母的排列 p ，使得将模式中的每个字母 x 替换为 p(x) 之后，我们就得到了所需的单词，那么单词与模式是匹配的。

（回想一下，字母的排列是从字母到字母的双射：每个字母映射到另一个字母，没有两个字母映射到同一个字母。）

返回 words 中与给定模式匹配的单词列表。

你可以按任何顺序返回答案。

示例：

输入：words = ["abc","deq","mee","aqq","dkd","ccc"], pattern = "abb"
输出：["mee","aqq"]
解释：
"mee" 与模式匹配，因为存在排列 {a -> m, b -> e, ...}。
"ccc" 与模式不匹配，因为 {a -> c, b -> c, ...} 不是排列。
因为 a 和 b 映射到同一个字母。

提示：

• 1 <= words.length <= 50
• 1 <= pattern.length = words[i].length <= 20

---

16ms

class Solution {
    func findAndReplacePattern(_ words: [String], _ pattern: String) -> [String] {
        var output = [String]()
        for word in words {
            if checkPattern(word,pattern) {
                output.append(word)
            }
        }
        return output
    }   
    func checkPattern(_ word: String, _ pattern: String) -> Bool {
        if word.count != pattern.count {
            return false
        }
        var myDict : Dictionary<Character,Character> = Dictionary.init()
        var secondDict : Dictionary<Character,Character> = Dictionary.init()
        var wordArray = Array(word)
        let patternArray = Array(pattern)
        for i in 0..<word.count {
            if myDict[wordArray[i]] == nil {
                if secondDict[patternArray[i]] != nil {
                    continue
                }
                myDict[wordArray[i]] = patternArray[i]
                secondDict[patternArray[i]] = wordArray[i]                
                wordArray[i] = patternArray[i]               
            } else {
                wordArray[i] = myDict[wordArray[i]]!
            }
        }
        if wordArray != patternArray {
            return false
        }
        return true
    }
}

---

16ms

class Solution {
    func rootArray(of string:String) -> [Int] {
        var rootDic : [UInt32:Int] = [:]
        var rootArray : [Int] = []
        
        var idx : Int = 0
        for p in string.unicodeScalars {
            if let pRoot = rootDic[p.value] {
                rootArray.append(pRoot)
            }else{
                rootArray.append(idx)
                rootDic[p.value] = idx
            }
            idx += 1
        }
        return rootArray
    }
    
    func findAndReplacePattern(_ words: [String], _ pattern: String) -> [String] {
        let patternRootArray = rootArray(of: pattern)

        var result : [String] = []
        for word in words {
            if rootArray(of: word) == patternRootArray {
                result.append(word)
            }
        }
        
        return result
    }
}

---

20ms

class Solution {
    func findAndReplacePattern(_ words: [String], _ pattern: String) -> [String] {
        return words.filter({ word($0, matches: pattern)})
    }
    
    func word(_ word: String, matches pattern: String) -> Bool {
        if word.count != pattern.count {
            return false
        }

        var letterMapping = [Character: Character]()
        var wordIndex = word.startIndex
        var patternIndex = pattern.startIndex
        
        while wordIndex != word.endIndex && patternIndex != pattern.endIndex {
            let currentChar = word[wordIndex]
            let patternChar = pattern[patternIndex]
            
            if !letterMapping.keys.contains(currentChar) {
                if letterMapping.values.contains(patternChar) {
                    return false
                }
                
                letterMapping[currentChar] = patternChar
            } else if letterMapping[currentChar] != patternChar {
                return false
            }
            
            wordIndex = word.index(after: wordIndex)
            patternIndex = pattern.index(after: patternIndex)
        }
        
        return true
    }
}

---

Runtime: 24 ms

Memory Usage: 19.7 MB

class Solution {
    func findAndReplacePattern(_ words: [String], _ pattern: String) -> [String] {
        var res:[String] = [String]()
        for w in words
        {
            if F(w) == F(pattern)
            {
                res.append(w)
            }
        }
        return res
    }

    func F(_ w:String) -> String
    {
        var arrW:[Character] = Array(w)
        var m:[Character:Int] = [Character:Int]()
        for c in w
        {
            if m[c] == nil
            {
                m[c] = m.count
            }
        }
        for i in 0..<w.count
        {
            arrW[i] = (97 + m[arrW[i],default:0]).ASCII
        }
        return String(arrW)
    }
}

//Int扩展
extension Int
{
    //Int转Character,ASCII值(定义大写为字符值)
    var ASCII:Character 
    {
        get {return Character(UnicodeScalar(self)!)}
    }
}