[Swift]LeetCode914.一副牌中的X | X of a Kind in a Deck of Cards

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

In a deck of cards, each card has an integer written on it.

Return true if and only if you can choose X >= 2 such that it is possible to split the entire deck into 1 or more groups of cards, where:

• Each group has exactly X cards.
• All the cards in each group have the same integer.

Example 1:

Input: [1,2,3,4,4,3,2,1]
Output: true
Explanation: Possible partition [1,1],[2,2],[3,3],[4,4]

Example 2:

Input: [1,1,1,2,2,2,3,3]
Output: false
Explanation: No possible partition.

Example 3:

Input: [1]
Output: false
Explanation: No possible partition.

Example 4:

Input: [1,1]
Output: true
Explanation: Possible partition [1,1]

Example 5:

Input: [1,1,2,2,2,2]
Output: true
Explanation: Possible partition [1,1],[2,2],[2,2]

Note:

1. 1 <= deck.length <= 10000
2. 0 <= deck[i] < 10000

---

在一副牌中，每张牌都写有一个整数。

返回true当且仅当你可以选择  X >= 2，使得它可以将整副牌分成1个或多个组的卡，其中：

• 每组都有X卡片。
• 每组中的所有卡都具有相同的整数。

例1：

输入：[1,2,3,4,4,3,2,1] 
输出：true
 说明：可能的分区[1,1]，[2,2]，[3,3]，[4,4]

例2：

输入：[1,1,1,2,2,2,3,3] 
输出：false
 说明：没有可能的分区。

例3：

输入：[1] 
输出：false
 说明：没有可能的分区。

例4：

输入：[1,1] 
输出：true
 说明：可能的分区[1,1]

例5：

输入：[1,1,2,2,2,2] 
输出：true
 说明：可能的分区[1,1]，[2,2]，[2,2]

注意：

1. 1 <= deck.length <= 10000
2. 0 <= deck[i] < 10000

---

40ms

class Solution {
    func hasGroupsSizeX(_ deck: [Int]) -> Bool {
        guard deck.count > 1 else {
            return false
        } 
        var d = [Int: Int]()
        for k in deck {
            d[k, default: 0] += 1
        }
        let dks = Array(d.values).filter {$0 >= 2}
        guard dks.count == d.values.count else {
            return false
        }
        let m = dks.min() ?? 2
        for i in 2 ... m  {
            var t = true
            for k in dks {
                if k % i != 0 {
                    t = false
                    break
                }    
            }
            if t {
                return true
            }
        }
        return false
    }
}

---

44ms

class Solution {
    func hasGroupsSizeX(_ deck: [Int]) -> Bool {
        var count = [Int: Int]()
        
        for d in deck {
            if let v = count[d] {
                count[d] = v + 1
            } else {
                count[d] = 1
            }
        }
        
        var smallest = Int.max
        
        for (_, v) in count {
            if v < smallest {
                smallest = v
            }
        }
        
        if 2 > smallest {
            return false
        }
        
        for i in 2...smallest {
            var flag = true
            for (_, v) in count {
                if v % i != 0 {
                    flag = false
                    break
                }
            }
            if flag {
                return true
            }
        }
        
        return false
    }
}

---

48ms

class Solution {
    func hasGroupsSizeX(_ deck: [Int]) -> Bool {
        var cache: [Int: Int] = [:]
        for card in deck {
            var count = 0;
            if let card_count = cache[card] {
                count = card_count;
            }
            cache[card] = count + 1;
        }
        var cgcd = 0
        for card in cache {
            cgcd = gcd(cgcd > 0 ? cgcd : card.value, card.value);
        }
        return cgcd > 1
    }
    
    func gcd(_ a: Int, _ b: Int) -> Int {
        if a == 0 || b == 0 {
            return 0
        }
        if a == b {
            return a
        }
        if a > b {
            return gcd(a-b, b)
        }
        return gcd(a, b-a);
    }
}

---

56ms

class Solution {
    func hasGroupsSizeX(_ deck: [Int]) -> Bool {
        guard deck.count > 1 else {return false}
        let counts = deck.reduce(into: [:]) { counts, card in counts[card, default: 0] += 1 }
        let values = counts.values.sorted(by: {$0 < $1})
        for i in 1..<values.count {
        let gcd = calculateGCD(values.first!, values[i])
            if gcd == 1 && values.last! > 1 {
                return false
            }
        }
        return true
    }
    
    func calculateGCD(_ a: Int, _ b:Int) -> Int {
        let r = a > b ? a % b : b % a
        if r != 0 {
            return calculateGCD(b, (a > b ? a % b : b % a))
        } else {
            return a > b ? b : a
        }
    }
}

---

76ms

class Solution {
        func hasGroupsSizeX(_ deck: [Int]) -> Bool {
            if deck.count == 0 {
                return false
            }
            var countMap = [Int: Int]()
            for num in deck {
                if let count = countMap[num] {
                    countMap[num] = count + 1
                    continue
                }
                countMap[num] = 1
            }
            var min = Int.max
            for (_, count) in countMap {
                if count < min {
                    min = count
                }
            }
            if min < 2 {
                return false
            }
            for (_, count) in countMap {
                let remainder = count % min
                if remainder == 0 {
                    continue
                }
                min = findFactor(max: count, min: min)
                if min == 1 {
                    return false
                }
            }
            return true
        }
        func findFactor(max: Int, min: Int) -> Int {
            let remainder = max % min
            if remainder == 0 {
                return min
            }
            return findFactor(max: min, min: remainder)
        }
    }

---

80ms

class Solution {
    func hasGroupsSizeX(_ deck: [Int]) -> Bool {
        if deck.count <= 1 { return false }
        
        var dict = [Int:Int]()
        for i in deck {
            if let count = dict[i] {
                dict[i] = count+1
            } else {
                dict[i] = 1
            }
        }
        var counts = Array(dict.values).sorted()
        
        if counts.count == 1 { return true }
        
        print(counts)
        
        for x in 2...counts.max()! {
            var xIsS = true
            for val in counts {
                if val % x != 0 {
                    xIsS = false
                }
            }
            if xIsS { return true }
        }
        
        return false
    }
}

---

84ms

class Solution {
    func hasGroupsSizeX(_ deck: [Int]) -> Bool {
        if deck.isEmpty {
            return false
        }
        let counter = deck.reduce(into: [:]) { counts, elem in counts[elem, default: 0] += 1 }
        let values = counter.values

        let maxCount = values.max()!

        if values.min()! < 2 {
            return false
        }

        for div in 2...maxCount {
            if (values.reduce(true) { $0 && ($1 % div == 0) }) {
                return true
            }
        }

        return false
    }
}

---

156ms

class Solution {
    func hasGroupsSizeX(_ deck: [Int]) -> Bool {
        var map = [Int: Int]()
        if deck.isEmpty || deck.count == 1 {
            return false
        }
        for i in 0..<deck.count {
            if let val = map[deck[i]] {
                map[deck[i]] = val + 1
            } else {
                map[deck[i]] = 1
            }
        }
        let set = Array(map.values)
        var result = set[0]
        for i in 1..<set.count {
            result = getHCF(result, set[i])
        }
        
        return result > 1
    }
    
    func getHCF(_ a: Int, _ b: Int) -> Int {
        if a == 0 {
            return b
        }
        if b == 0 {
            return a
        }
        if a == b {
            return a
        }
        if a <= b {
            return getHCF(a, b % a)
        } else {
            return getHCF(a % b, b)
        }
        return 1
    }
}

---

164ms

class Solution {
    func hasGroupsSizeX(_ deck: [Int]) -> Bool {
        func gcd(a: Int, b: Int) -> Int {
            return (b > 0 ? gcd(a: b, b: a % b) : a)
        }
        
        //
        guard deck.count >= 2 else { return false }
        
        var dict: [Int: Int] = [:]
        
        for num in deck {
            dict[num] = (dict[num] ?? 0) + 1
        }
        
        let counts = dict.keys.compactMap { dict[$0] }
        
        var res = 0
        for count in counts {
            res = gcd(a: count, b: res)
        }
        
        return res > 1
    }
}

---

172ms

class Solution {
  func gcd(_ a: Int, _ b: Int) -> Int {
    let r = a % b
    if r != 0 {
      return gcd(b, r)
    } else {
      return b
    }
  }
  
  func hasGroupsSizeX(_ deck: [Int]) -> Bool {
    var cnt: [Int:Int] = [:]
    deck.forEach {cnt[$0] = cnt[$0, default:0] + 1}
    
    let X = cnt.values.reduce(cnt.first!.value, gcd)
    return X >= 2
  }
}

---

180ms

class Solution {
    func hasGroupsSizeX(_ deck: [Int]) -> Bool {
        var nums:[Int:Int] = [:]
        for c in deck {
            if nums[c] == nil {
                nums[c] = 1
            } else {
                nums[c]! += 1
            }
        }
        
        
        var arr = nums.map { (a) -> Int in
            return a.value
        }
        
        if arr.count == 1 && arr[0] == 1 {
            return false
        }
        
        print(arr)
  
        var hcf:Int = arr.removeFirst()
        
        func gcd(a:Int, b:Int) -> Int {
            if a == b {
                return a
            } else {
                if a > b {
                    return gcd(a:a-b,b:b)
                } else {
                    return gcd(a:a,b:b-a)
                }
            }
        }
        
        while !arr.isEmpty {
            hcf = gcd(a:hcf, b:arr.removeFirst())
            if hcf == 1 {
                return false
            }
        }
        return true
        
    }
}

---

276ms

class Solution {
    func hasGroupsSizeX(_ deck: [Int]) -> Bool {
        var f:[Int] = [Int](repeating: 0,count: 10001)
        for d in deck
        {
            f[d] += 1
        }
        var g:Int = 0
        for v in f
        {
            g = gcd(g,v)
        }
        return g != 1
    }
    func gcd(_ a:Int,_ b:Int) -> Int
    {
        var a = a
        var b = b
        while(b > 0)
        {
            var c:Int = a
            a = b
            b = c % b
        }
        return a
    }
}