[Swift]LeetCode451. 根据字符出现频率排序 | Sort Characters By Frequency

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

Given a string, sort it in decreasing order based on the frequency of characters.

Example 1:

Input:
"tree"

Output:
"eert"

Explanation:
'e' appears twice while 'r' and 't' both appear once.
So 'e' must appear before both 'r' and 't'. Therefore "eetr" is also a valid answer. 

Example 2:

Input:
"cccaaa"

Output:
"cccaaa"

Explanation:
Both 'c' and 'a' appear three times, so "aaaccc" is also a valid answer.
Note that "cacaca" is incorrect, as the same characters must be together. 

Example 3:

Input:
"Aabb"

Output:
"bbAa"

Explanation:
"bbaA" is also a valid answer, but "Aabb" is incorrect.
Note that 'A' and 'a' are treated as two different characters.

---

给定一个字符串，请将字符串里的字符按照出现的频率降序排列。

示例 1:

输入:
"tree"

输出:
"eert"

解释:
'e'出现两次，'r'和't'都只出现一次。
因此'e'必须出现在'r'和't'之前。此外，"eetr"也是一个有效的答案。

示例 2:

输入:
"cccaaa"

输出:
"cccaaa"

解释:
'c'和'a'都出现三次。此外，"aaaccc"也是有效的答案。
注意"cacaca"是不正确的，因为相同的字母必须放在一起。

示例 3:

输入:
"Aabb"

输出:
"bbAa"

解释:
此外，"bbaA"也是一个有效的答案，但"Aabb"是不正确的。
注意'A'和'a'被认为是两种不同的字符。

---

160ms

class Solution {
    func frequencySort(_ s: String) -> String {
        let a = Array(s)
        var dicts = [Character: Int]()
        
        for e in a {
            if let count = dicts[e] {
                dicts[e] = count + 1
            } else {
                dicts[e] = 1
            }
        }
        
        let sortedDicts = dicts.sorted { $0.1 > $1.1 }
        var res = ""
        for d in sortedDicts {
            res += String(repeating: d.key, count: d.value)
        }
        return res
    }
}

---

164ms

class Solution {
    func frequencySort(_ s: String) -> String {
            var dict = [Character: Int]()
    for i in s {
        dict[i] = (dict[i] ?? 0 ) + 1
    }

    let keys = dict.keys.sorted(by: { dict[$0]! >= dict[$1]! } )
    var s = ""
    for key in keys {
        for _ in 0..<dict[key]! {
            s.append(key)
        }
    }
    return s
    }
}

---

184ms

class Solution {
    func frequencySort(_ s: String) -> String {
        var map: [Character: Int] = [:]
        s.forEach { (char) in
            if let count = map[char] {
                map[char] = count + 1
            } else {
                map[char] = 1
            }
        }

        return map.lazy.sorted(by: { $0.value > $1.value }).reduce("", { $0 + String(Array(repeating: $1.key, count: $1.value)) })
    }
}

---

204ms

class Solution {
    func frequencySort(_ s: String) -> String {
        let array = Array(s.characters)
        var map : [Character : Int] = [:]
        
        for i in 0..<array.count {
            var n = map[array[i]]
            n = (n ?? 0) + 1
            map[array[i]] = n
        }        

        var counts = Array(map.values)
        counts.sort()
        var ret : [Character] = []        
        for i in 0..<counts.count {
            var c : Character = " "
            let count = counts[counts.count - 1 - i]
            let keys = Array(map.keys)
            for key in keys {
                let co = map[key]
                if co == count {
                    c = key
                    break
                }
            }
            map.removeValue(forKey: c)
            for j in 0..<count {
                ret.append(c)        
            }
        }
        
        return String(ret)
    }
}

---

228ms

class Solution {
    func frequencySort(_ s: String) -> String {
        var dictionary : [Character:Int] = [:]
        var answerArray : [Character] = []
        for i in s{
            if dictionary.keys.contains(i){
                dictionary[i] = dictionary[i]! + 1
            } else {
                dictionary[i] = 1
            }
        }
        
        let sortedKeys = dictionary.sorted{ $0.value > $1.value }
        
        for i in sortedKeys{
            let (key, value) = i
            for _ in 0..<value{
                answerArray.append(key)
            }
        }
        
        return String(answerArray)
    }
}

---

260ms

class Solution {
    func frequencySort(_ s: String) -> String {
        var m = [Character:Int]()
        for c in s {
            if let count = m[c] {
                m[c] = count + 1
            } else {
                m[c] = 1
            }
        }
        
        let arr = m.sorted { (arg0, arg1) -> Bool in
            let a0: (Character, Int) = arg1
            let a1: (Character, Int) = arg0
            return a0.1 < a1.1
        }
        
        var carr = [Character]()
        for tuple in arr {
            for _ in 0 ..< tuple.value {
                carr.append(tuple.key)
            }
        }
        
        return String(carr)
    }
}

---

268ms

class Solution {
    func frequencySort(_ s: String) -> String {
        if s.count == 0 {
            return s
        }
        let chars = s.cString(using: .utf8)!
    
        var dict = Dictionary<CChar,Int>.init()
    
        for c in chars {
            if c == 0{
                continue
            }
            dict[c] = (dict[c] ?? 0) + 1
        }
        var result = dict.sorted { (d1,d2) -> Bool in
            d1.value > d2.value
        }
        var newStr = [CChar].init()
    
        for (c,index) in result {
            for i in 0 ..< index {
                newStr.append(c)
            }
        }
        newStr.append(0)

        return String.init(utf8String: newStr) ?? ""
    }
}

---

348ms

class Solution {
    func frequencySort(_ s: String) -> String {
        var dict: [Character: Int] = [:]
        
        for char in s {
            dict[char] = (dict[char] ?? 0) + 1
        }
        
        let keys = dict.sorted { $0.value > $1.value}.map { $0.key }
        
        var res = ""
        
        for char in keys {
            while dict[char] != 0 {
                res += String(char)
                dict[char]! -= 1
            }
        }
        
        return res
    }
}

---

3388ms

class Solution {
    var m:[Character:Int] = [Character:Int]()
    func frequencySort(_ s: String) -> String {      
        var arr:[Character] = [Character]()
        for char in s.characters
        {
            if m[char] == nil
            {
                m[char] = 1
            }
            else
            {
                m[char]! += 1
            }            
            arr.append(char)
        }
        arr.sort(by: sortArray)
        return String(arr)
    }
    
    func sortArray(_ a:Character,_ b:Character) -> Bool 
    {
        return m[a]! > m[b]! || (m[a]! == m[b]! && a < b)
    }
}