[Swift]LeetCode809. 情感丰富的文字 | Expressive Words

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Sometimes people repeat letters to represent extra feeling, such as "hello" -> "heeellooo", "hi" -> "hiiii".  Here, we have groups, of adjacent letters that are all the same character, and adjacent characters to the group are different.  A group is extended if that group is length 3 or more, so "e" and "o" would be extended in the first example, and "i" would be extended in the second example.  As another example, the groups of "abbcccaaaa" would be "a", "bb", "ccc", and "aaaa"; and "ccc" and "aaaa" are the extended groups of that string.

For some given string S, a query word is stretchy if it can be made to be equal to S by extending some groups.  Formally, we are allowed to repeatedly choose a group (as defined above) of characters c, and add some number of the same character c to it so that the length of the group is 3 or more.  Note that we cannot extend a group of size one like "h" to a group of size two like "hh" - all extensions must leave the group extended - ie., at least 3 characters long.

Given a list of query words, return the number of words that are stretchy. 

Example:
Input: 
S = "heeellooo"
words = ["hello", "hi", "helo"]
Output: 1
Explanation: 
We can extend "e" and "o" in the word "hello" to get "heeellooo".
We can't extend "helo" to get "heeellooo" because the group "ll" is not extended.

Notes:

• 0 <= len(S) <= 100.
• 0 <= len(words) <= 100.
• 0 <= len(words[i]) <= 100.
• S and all words in words consist only of lowercase letters

---

有时候人们会用额外的字母来表示额外的情感，比如 "hello" -> "heeellooo", "hi" -> "hiii"。我们将连续的相同的字母分组，并且相邻组的字母都不相同。我们将一个拥有三个或以上字母的组定义为扩张状态（extended），如第一个例子中的 "e" 和" o" 以及第二个例子中的 "i"。 此外，"abbcccaaaa" 将有分组 "a" , "bb" , "ccc" , "dddd"；其中 "ccc" 和 "aaaa" 处于扩张状态。

对于一个给定的字符串 S ，如果另一个单词能够通过将一些字母组扩张从而使其和 S 相同，我们将这个单词定义为可扩张的（stretchy）。我们允许选择一个字母组（如包含字母 c ），然后往其中添加相同的字母 c 使其长度达到 3 或以上。注意，我们不能将一个只包含一个字母的字母组，如 "h"，扩张到一个包含两个字母的组，如 "hh"；所有的扩张必须使该字母组变成扩张状态（至少包含三个字母）。

输入一组单词，输出其中可扩张的单词数量。

示例：
输入： 
S = "heeellooo"
words = ["hello", "hi", "helo"]
输出：1
解释：
我们能通过扩张"hello"的"e"和"o"来得到"heeellooo"。
我们不能通过扩张"helo"来得到"heeellooo"因为"ll"不处于扩张状态。

说明：

• 0 <= len(S) <= 100。
• 0 <= len(words) <= 100。
• 0 <= len(words[i]) <= 100。
• S 和所有在 words 中的单词都只由小写字母组成。

---

Runtime: 20 ms

Memory Usage: 19.6 MB

class Solution {
    func expressiveWords(_ S: String, _ words: [String]) -> Int {
        let lenS = S.count
        if lenS == 0 { // S 不能为空
            return 0
        }
        var n = words.count, res = 0, arrS = Array(S)
        for i in 0..<n {
            let lenW = words[i].count
            // words[i] 不能为空或者长度不小于S
            if lenW == 0  || lenW >= lenS {
                return 0
            }
            var j = 0, k = 0, streched = false, arrW = Array(words[i])
            while j < lenS && k < lenW {
                var startS = j
                var startW = k
                if arrS[j] == arrW[k] {
                    while j < lenS - 1 && arrS[j] == arrS[j+1] {
                        j += 1
                    }
                    while k < lenW - 1 && arrW[k] == arrW[k+1] {
                        k += 1
                    }
                    // 如果S分组后的字符串是由某个字符重复2次及以上组成，则认为是可扩展
                    if j - startS >= 2 {
                        streched = true
                    }
                    //如果不可扩展，对应位置的字符串必须相同
                    else if j - startS != k - startW {
                        streched = false
                        break
                    }
                }
                else {
                    streched = false
                    break
                }
                j += 1
                k += 1
            }
            if streched {
                res += 1
            }            
        }
        return res
    }
}

---

28ms

class Solution {
    func expressiveWords(_ S: String, _ words: [String]) -> Int {
        var sRLE = getRLE(Array(S))
        var result = 0
        for word in words {
            let wRLE = getRLE(Array(word))
            guard sRLE.count == wRLE.count else {
                continue
            }
            var index = 0
            while index < sRLE.count {
                guard sRLE[index].0 == wRLE[index].0 else {
                    break
                }
                if !((sRLE[index].1 >= 3 && sRLE[index].1 >= wRLE[index].1) || sRLE[index].1 == wRLE[index].1) {
                    break
                }
                index += 1
            }
            if index == sRLE.count {
                result += 1
            }
        }
        return result
    }
    
    private func getRLE(_ chars: [Character]) -> [(Character, Int)] {
        var start = 0
        var pointer = 0
        var result = [(Character, Int)]()
        while pointer < chars.count {
            while pointer < chars.count && chars[pointer] == chars[start] {
                pointer += 1
            }
            result.append((chars[start], pointer - start))
            start = pointer
        }
        return result
    }
}

---

40ms

class Solution {
    func expressiveWords(_ S: String, _ words: [String]) -> Int {        
        func compress(_ s: String) -> [(Character, Int)] {
            return s.reduce(into: [(Character, Int)]()) {
                if let (char, count) = $0.last, char == $1 {
                    $0[$0.count-1] = (char, count+1)
                } else {
                    $0.append(($1, 1))
                }
            }
        }
        
        func isExpressive(_ s: [(Character, Int)], _ t: [(Character, Int)]) -> Bool {
            guard s.count == t.count else { return false }
            for i in s.indices {
                if s[i] == t[i] { continue }
                if s[i].0 != t[i].0 || s[i].1 == 2 || s[i].1 < t[i].1 { return false }
            }
            return true
        }
        
        let set = Set(words)
        let sCompressed = compress(S)
        return words.filter{ isExpressive(sCompressed, compress($0)) }.count
    }    
}

---

Runtime: 44 ms

Memory Usage: 19.9 MB

class Solution {
    func expressiveWords(_ S: String, _ words: [String]) -> Int {
        var arrS:[Character] = Array(S)        
        var res:Int = 0
        var m:Int = S.count
        var n:Int = words.count
        for word in words
        {
            var arrWord = Array(word)
            var i:Int = 0
            var j:Int = 0
            while(i < m)
            {
                if j < word.count && arrS[i] == arrWord[j]
                {
                    j += 1
                }
                else if i > 0 && arrS[i] == arrS[i - 1] && i + 1 < m && arrS[i] == arrS[i + 1]
                {
                    i += 1
                }
                else if !(i > 1 && arrS[i] == arrS[i - 1] && arrS[i] == arrS[i - 2])
                {
                    break
                }
                i += 1
            }
            if i == m && j == word.count
            {
                res += 1
            }
        }
        return res
    }
}