[Swift]LeetCode1002. 查找常用字符 | Find Common Characters

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

Given an array A of strings made only from lowercase letters, return a list of all characters that show up in all strings within the list (including duplicates).  For example, if a character occurs 3 times in all strings but not 4 times, you need to include that character three times in the final answer.

You may return the answer in any order. 

Example 1:

Input: ["bella","label","roller"]
Output: ["e","l","l"]

Example 2:

Input: ["cool","lock","cook"]
Output: ["c","o"] 

Note:

1. 1 <= A.length <= 100
2. 1 <= A[i].length <= 100
3. A[i][j] is a lowercase letter

---

给定仅有小写字母组成的字符串数组 A，返回列表中的每个字符串中都显示的全部字符（包括重复字符）组成的列表。例如，如果一个字符在每个字符串中出现 3 次，但不是 4 次，则需要在最终答案中包含该字符 3 次。

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

示例 1：

输入：["bella","label","roller"]
输出：["e","l","l"]

示例 2：

输入：["cool","lock","cook"]
输出：["c","o"] 

提示：

1. 1 <= A.length <= 100
2. 1 <= A[i].length <= 100
3. A[i][j] 是小写字母

---

52ms

class Solution {
    func commonChars(_ A: [String]) -> [String] {
        if A.count < 1 {
        return []
    }
    
    var commonCount: [Int] = Array.init(repeating: 0, count: 26)
    var ans:[String] = []
    for string in A {
        var thisFrequency:[Int] = Array.init(repeating: 0, count: 26)
        var leftIndex  = string.startIndex
        
        while leftIndex < string.endIndex {
            let leftChar  = string[leftIndex]
            if let value = leftChar.unicodeScalars.first?.value {
                let index = Int(value - 97)
                thisFrequency[index] += 1
            }
            // move towards middle
            leftIndex  = string.index(after: leftIndex)
        }
        if string == A.first {
            for index in 0...25 {
                commonCount[index] = thisFrequency[index]
            }
        } else {
            for index in 0...25 {
                commonCount[index] = min(commonCount[index], thisFrequency[index])
            }
        }
    }
    
    for index in 0...25 {
        while commonCount[index] > 0 {
            let value = index + 97
            if let scalar = UnicodeScalar(value) {
                let character = Character(scalar)
                ans.append("(character)")
            }
            commonCount[index] -= 1
        }
    }
    
    return ans
    }
}

---

68ms

class Solution {
    func commonChars(_ words: [String]) -> [String] {
        var prevDict = [String:Int]()
        var currDict = [String:Int]()

        // Get the first word, otherwise return
        guard let firstWord = words.first else {
            return []
        }

        // Add chars of first word to result
        for char in firstWord {
            let char = String(char)
            if let prevFreq = prevDict[char] {
                prevDict[char] = prevFreq + 1
            }
            else {
                prevDict[char] = 1
            }
        }

        for word in words[1...] {
            for char in word {
                //char is in previous dictionary
                //Add to current
                let char = String(char)
                if let prevFreq = prevDict[char] {
                    if let currentFreq = currDict[char] {
                        currDict[char] = currentFreq < prevFreq ? currentFreq + 1 : prevFreq
                    }
                    else {
                        currDict[char] = 1
                    }
                }
            }

            //Setup for next iteration
            prevDict = currDict
            currDict.removeAll()
        }

        var result = [String]()
        for (char, freq) in prevDict {
            for _ in 0..<freq {
                result.append(char)
            }
        }

        return result
    }
}

---

72ms

class Solution {
    func commonChars(_ A: [String]) -> [String] {
        var repeatCount: [Int] = Array.init(repeating: 0, count: 26)
        var outPutString = [String]()
        let aChar: String = "a"
        
        var count: Int = 0
        for eachString in A {
            var onceCount: [Int] = Array.init(repeating: 0, count: 26)
            for char in eachString {
                let acharNUm: Int = aChar.transInToAcsIIInt()
                let charNUm: Int = String(char).transInToAcsIIInt()
                let counter: Int = charNUm - acharNUm
                if count == 0 {
                    repeatCount[counter] += 1
                } else {
                    onceCount[counter] += 1
                }
            }
            for index in 0..<26 {
                if count != 0 {
                    repeatCount[index] = min(repeatCount[index], onceCount[index])
                }
            }
            count += 1
        }
        
        count = 0
        for eachNum in repeatCount {
            for _ in 0..<eachNum {
                outPutString.append(String(Character(UnicodeScalar(aChar.transInToAcsIIInt() + count)!)))
            }
            count += 1
        }
        
        return outPutString;
    }
}



extension String {
    func transInToAcsIIInt() -> Int {
        var acharNUm: Int = 0
        for num in self.unicodeScalars {
            acharNUm = Int(num.value)
        }
        
        return acharNUm
    }
}

---

76ms

class Solution {
    func commonChars(_ A: [String]) -> [String] {
        let ref = A[0]
        var refDict = [Character: Int]()
        for char in ref {
            refDict[char, default: 0] += 1
        }
        
        for i in 1..<A.count {
            let str = A[i]
            var dict = [Character: Int]()
            for char in str {
                dict[char, default: 0] += 1
            }

            for char in refDict.keys {
                if let count = dict[char] {
                    refDict[char] = min(refDict[char]!, count)
                } else {
                    refDict[char] = nil
                }
            }
        }
        
        var result = [String]()
        for (char, count) in refDict {
            for _ in 0..<count {
                result.append(String(char))
            }
        }
        return result
    }
}

---

80ms

class Solution {
    func commonChars(_ A: [String]) -> [String] {
            func f(A: [[Character]], result: [String]) -> [String] {
                if (A.count == 0) { return result }
                var newA = A
                var currentWord = newA.removeFirst().map{ String($0) }
                var i1 = 0
                var res = [String]()
                while i1 < result.count {
                    let f_char = result[i1]
                    if let founded_char_index = currentWord.firstIndex(of: f_char) {
                        res.append(String(f_char))
                        currentWord.remove(at: founded_char_index)
                    }
                    i1 += 1
                }
                return f(A: newA, result: res)
            }    
            var strings = A.map{Array(String($0))}
            let result = strings.removeFirst().map{ String($0) }
            return f(A: strings, result: result)
    }
}

---

Runtime: 88 ms

Memory Usage: 19.7 MB

class Solution {
    func commonChars(_ A: [String]) -> [String] {
        var n:Int = A.count
        var h:[[Int]] = [[Int]](repeating:[Int](repeating:0,count:26),count:n)
        for i in 0..<n
        {
            for j in 0..<A[i].count
            {
                h[i][A[i][j].ascii - 97] += 1
            }
        }
        var ans:[String] = [String]()
        for j in 0..<26
        {
            var num:Int = 10000
            for i in 0..<n
            {
                num = min(h[i][j], num)
            }
            var cs:String = String((j + 97).ASCII)
            for i in 0..<num
            {
                ans.append(cs)
            }
        }
        return ans        
    }
}

//String扩展
extension String {        
    //subscript函数可以检索数组中的值
    //直接按照索引方式截取指定索引的字符
    subscript (_ i: Int) -> Character {
        //读取字符
        get {return self[index(startIndex, offsetBy: i)]}
    }
}

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

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

---

92ms

class Solution {
    func commonChars(_ A: [String]) -> [String] {
        var results = [String]()
        guard A.count > 0 else { return results }
        var masterMap = [String : Int]()
        for char in A[0] {
            let s = String(char)
            guard masterMap[s] != nil else {
                masterMap[s] = 1
                continue
            }
            masterMap[s]! += 1
        }
        for i in 1..<A.count {
            guard masterMap.count > 0 else { return results }
            var tempMap = [String : Int]()
            for char in A[i] {
                let s = String(char)
                guard tempMap[s] != nil else {
                    tempMap[s] = 1
                    continue
                }
                tempMap[s]! += 1
            }
            for key in masterMap.keys {
                guard let temp = tempMap[key], let master = masterMap[key] else {
                    masterMap.removeValue(forKey: key)
                    continue
                }
                masterMap[key] = min(master, temp)
            }
        }
        for (key, value) in masterMap {
            for _ in 0..<value {
                results.append(key)
            }
        }
        return results
    }
}

---

100ms

struct CharCounter
{    
    var countOf: [ Character : Int ]    
    init()
    {
        self.countOf = [ : ]
    }
    
    mutating func insert( _ char: Character )
    {
        if let count: Int = countOf[ char ]
        {
            countOf[ char ] = ( count + 1 )
        }
        else
        {
            countOf[ char ] = 1
        }
    }
    
    func countOf( _ char: Character ) -> Int
    {
        if let count: Int = countOf[ char ]
        {
            return count
        }
        else
        {
            return 0
        }        
    }    
}

class Solution 
{    
    func commonChars( _ strings: [ String ] ) -> [ String ] 
    {        
        var charSets: [ CharCounter ] = [ CharCounter ].init(
            repeating: CharCounter(), 
            count: strings.count
        )        
        var index: Int = 0        
        while index < strings.count
        {            
            let string = strings[ index ]
            
            for char in string
            {
                charSets[ index ].insert( char )
            }            
            index += 1            
        }        
        var result: [ String ] = []
        
        for char in charSets[ 0 ].countOf.keys
        {
            
            var minCount: Int = charSets[ 0 ].countOf( char ) 
            
            var index: Int = 1
            while index < charSets.count
            {                
                minCount = min( minCount, charSets[ index ].countOf( char ) )                
                index += 1                
            }
            
            if minCount > 0
            {
                for _ in ( 1 ... minCount )
                {
                    result.append( String( char ) )
                }
            }            
        }        
        return result        
    }    
}