[Swift]LeetCode893. 特殊等价字符串组 | Groups of Special-Equivalent Strings

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

You are given an array A of strings.

Two strings S and T are special-equivalent if after any number of moves, S == T.

A move consists of choosing two indices i and j with i % 2 == j % 2, and swapping S[i] with S[j].

Now, a group of special-equivalent strings from A is a non-empty subset S of A such that any string not in S is not special-equivalent with any string in S.

Return the number of groups of special-equivalent strings from A. 

Example 1:

Input: ["a","b","c","a","c","c"]
Output: 3
Explanation: 3 groups ["a","a"], ["b"], ["c","c","c"]

Example 2:

Input: ["aa","bb","ab","ba"]
Output: 4
Explanation: 4 groups ["aa"], ["bb"], ["ab"], ["ba"]

Example 3:

Input: ["abc","acb","bac","bca","cab","cba"]
Output: 3
Explanation: 3 groups ["abc","cba"], ["acb","bca"], ["bac","cab"]

Example 4:

Input: ["abcd","cdab","adcb","cbad"]
Output: 1
Explanation: 1 group ["abcd","cdab","adcb","cbad"] 

Note:

• 1 <= A.length <= 1000
• 1 <= A[i].length <= 20
• All A[i] have the same length.
• All A[i] consist of only lowercase letters.

---

你将得到一个字符串数组 A。

如果经过任意次数的移动，S == T，那么两个字符串 S 和 T 是特殊等价的。 

一次移动包括选择两个索引 i 和 j，且 i％2 == j％2，并且交换 S[j] 和 S [i]。

现在规定，A 中的特殊等价字符串组是 A 的非空子集 S，这样不在 S 中的任何字符串与 S 中的任何字符串都不是特殊等价的。 

返回 A 中特殊等价字符串组的数量。 

示例 1：

输入：["a","b","c","a","c","c"]
输出：3
解释：3 组 ["a","a"]，["b"]，["c","c","c"]

示例 2：

输入：["aa","bb","ab","ba"]
输出：4
解释：4 组 ["aa"]，["bb"]，["ab"]，["ba"]

示例 3：

输入：["abc","acb","bac","bca","cab","cba"]
输出：3
解释：3 组 ["abc","cba"]，["acb","bca"]，["bac","cab"]

示例 4：

输入：["abcd","cdab","adcb","cbad"]
输出：1
解释：1 组 ["abcd","cdab","adcb","cbad"] 

提示：

• 1 <= A.length <= 1000
• 1 <= A[i].length <= 20
• 所有 A[i] 都具有相同的长度。
• 所有 A[i] 都只由小写字母组成。

---

40ms

class Solution {    
    func numSpecialEquivGroups(_ A: [String]) -> Int {
        var  specialEquivalentStringCountSet = Set<[Int]>()
        for str in A {
            specialEquivalentStringCountSet.insert(getStringPartion(source: str))
        }
        return  specialEquivalentStringCountSet.count
    }
    private func getStringPartion(source: String) -> [Int] {
        var result  = Array<Int>(repeating: 0, count: 52)
        var index = 0
        for char in source.utf8 {
            let tempIndex = 26 * (index % 2 == 0 ? 0 : 1) + Int(char) - 97
            result[tempIndex] = result[tempIndex] + 1
            index += 1
        }
        return result
    }
}

---

52ms

class Solution {
    func numSpecialEquivGroups(_ A: [String]) -> Int {
        var result = Set<[Character]>()
        for string in A {
            var str1: String = ""
            var str2: String = ""
            var even = true
            for c in string {
                if even {
                    str1.append(c)
                } else {
                    str2.append(c)
                }
                even = !even
            }
            result.insert(str1.sorted() + str2.sorted())
        }
        return result.count
    }
}

---

64ms

class Solution {
    func numSpecialEquivGroups(_ A: [String]) -> Int {
     var set = Set<String>()
        for word in A{
            var evenString = ""
            var oddString = ""
            for (index, char) in word.enumerated(){
                if index % 2 == 0{
                    evenString.append(char)
                }
                else{
                    oddString.append(char)
                }
            }
            set.insert(String(evenString.sorted()) + String(oddString.sorted()))
        }
        return set.count
    }
}

---

68ms

class Solution {
    func numSpecialEquivGroups(_ A: [String]) -> Int {
        var array = [String]()
        for s in A {
            let temp = Array(s)
            var preStr = [Character]()
            var sufStr = [Character]()
            for i in 0..<temp.count{
                if i%2==0 {
                    preStr.append(temp[i])
                }else {
                    sufStr.append(temp[i])
                }
            }
            preStr = preStr.sorted()
            sufStr = sufStr.sorted()
            array.append(String(preStr+sufStr))
        }
        return Set(array).count
    }
}

---

84ms

class Solution {
    func numSpecialEquivGroups(_ A: [String]) -> Int {
        var dict = [String: Int]()
        for item in A {
            let chars = Array(item)
            var odd = [Character]()
            var even = [Character]()
            for i in 0..<chars.count {
                if i % 2 == 0 {
                    even.append(chars[i])
                } else {
                    odd.append(chars[i])
                }
            } 
            odd.sort()
            even.sort()
            let current = odd.reduce("") { $0 + String($1) } + even.reduce("") { $0 + String($1) }
            dict[current] = dict[current] ?? 0
            dict[current]! += 1
        }
        return dict.count
    }
}

---

88ms

class Solution {
    func numSpecialEquivGroups(_ A: [String]) -> Int {
        return Set(A.map { tokenize($0) }).count
    }
    
    private func tokenize(_ str: String) -> Token {
        var even = [Character: Int]()
        var odd = [Character: Int]()
        
        for (i, c) in Array(str).enumerated() {
            if i % 2 == 0 {
                even[c] = (even[c] ?? 0) + 1
            } else {
                odd[c] = (odd[c] ?? 0) + 1
            }
        }
        
        return Token(even: even, odd: odd)
    }
    
    private struct Token: Hashable {
        let even: [Character: Int]
        let odd: [Character: Int]
    }
}

---

92ms

class Solution {
    func numSpecialEquivGroups(_ A: [String]) -> Int {
        var dict = [String: Int]()
        for item in A {
            let chars = Array(item)
            var count = [Int](repeating: 0, count: 52)
            for i in 0..<chars.count {
                count[Int(UnicodeScalar(String(chars[i]))!.value) - Int(UnicodeScalar("a")!.value) + 26 * (i % 2)] += 1
            } 
            
            let current = count.reduce("") { $0 + String($1) } 
            dict[current] = dict[current] ?? 0
        }
        return dict.count
    }
}

---

Runtime: 92 ms

Memory Usage: 20.2 MB

class Solution {
    func numSpecialEquivGroups(_ A: [String]) -> Int {
        var set:Set<String> = Set<String>()
        for s in A
        {
            var odd:[Int] = [Int](repeating:0,count:26)
            var even:[Int] = [Int](repeating:0,count:26)
            let arrS:[Character] = Array(s)
            for i in 0..<s.count
            {
                if i % 2 == 1
                {
                    odd[arrS[i].ascii - 97] += 1
                }
                else
                {
                    even[arrS[i].ascii - 97] += 1
                }
            }
            var oddChar:[Character] = odd.map{$0.ASCII}
            var evenChar:[Character] = even.map{$0.ASCII}
            var sig:String = String(oddChar) + String(evenChar)
            set.insert(sig)
        }
        return set.count
    }
}

//Character扩展 
extension Character  
{  
  //Character转ASCII整数值(定义小写为整数值)
   var ascii: Int {
       get {
           return Int(self.unicodeScalars.first?.value ?? 0)
       }       
    }
}

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

---

100ms

class Solution {
    func numSpecialEquivGroups(_ A: [String]) -> Int {
        let s = Set(A.map { (s: String) -> String in 
            let cs = Array(s).enumerated()
            let s1 = String(cs.filter {$0.0 % 2 == 0}.map {$0.1}.sorted())
            let s2 = String(cs.filter {$0.0 % 2 == 1}.map {$0.1}.sorted())
            return s1 + s2
        })
        return s.count
    }
}

---

132ms

class Solution {
    func numSpecialEquivGroups(_ A: [String]) -> Int {
        var c = Set<String>()
        let aVal = "a".unicodeScalars.first!.value
        for word in A {
            var d = [Int](repeating:0, count:54)
            for (index, char) in word.enumerated() {
                let i = 26 * (index%2) + Int(char.unicodeScalars.first!.value - aVal)
                d[i] = d[i] + 1
            }
            var output = String()
            for i in 0 ..< d.count {
                output.append("(d[i]) ")
            }
            c.insert(output)
        }
        return c.count
    }
}