[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 <= deck.length <= 10000
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 <= deck.length <= 10000
0 <= deck[i] < 10000

40ms

 1 class Solution {
 2     func hasGroupsSizeX(_ deck: [Int]) -> Bool {
 3         guard deck.count > 1 else {
 4             return false
 5         } 
 6         var d = [Int: Int]()
 7         for k in deck {
 8             d[k, default: 0] += 1
 9         }
10         let dks = Array(d.values).filter {$0 >= 2}
11         guard dks.count == d.values.count else {
12             return false
13         }
14         let m = dks.min() ?? 2
15         for i in 2 ... m  {
16             var t = true
17             for k in dks {
18                 if k % i != 0 {
19                     t = false
20                     break
21                 }    
22             }
23             if t {
24                 return true
25             }
26         }
27         return false
28     }
29 }

44ms

 1 class Solution {
 2     func hasGroupsSizeX(_ deck: [Int]) -> Bool {
 3         var count = [Int: Int]()
 4         
 5         for d in deck {
 6             if let v = count[d] {
 7                 count[d] = v + 1
 8             } else {
 9                 count[d] = 1
10             }
11         }
12         
13         var smallest = Int.max
14         
15         for (_, v) in count {
16             if v < smallest {
17                 smallest = v
18             }
19         }
20         
21         if 2 > smallest {
22             return false
23         }
24         
25         for i in 2...smallest {
26             var flag = true
27             for (_, v) in count {
28                 if v % i != 0 {
29                     flag = false
30                     break
31                 }
32             }
33             if flag {
34                 return true
35             }
36         }
37         
38         return false
39     }
40 }

48ms

 1 class Solution {
 2     func hasGroupsSizeX(_ deck: [Int]) -> Bool {
 3         var cache: [Int: Int] = [:]
 4         for card in deck {
 5             var count = 0;
 6             if let card_count = cache[card] {
 7                 count = card_count;
 8             }
 9             cache[card] = count + 1;
10         }
11         var cgcd = 0
12         for card in cache {
13             cgcd = gcd(cgcd > 0 ? cgcd : card.value, card.value);
14         }
15         return cgcd > 1
16     }
17     
18     func gcd(_ a: Int, _ b: Int) -> Int {
19         if a == 0 || b == 0 {
20             return 0
21         }
22         if a == b {
23             return a
24         }
25         if a > b {
26             return gcd(a-b, b)
27         }
28         return gcd(a, b-a);
29     }
30 }

56ms

 1 class Solution {
 2     func hasGroupsSizeX(_ deck: [Int]) -> Bool {
 3         guard deck.count > 1 else {return false}
 4         let counts = deck.reduce(into: [:]) { counts, card in counts[card, default: 0] += 1 }
 5         let values = counts.values.sorted(by: {$0 < $1})
 6         for i in 1..<values.count {
 7         let gcd = calculateGCD(values.first!, values[i])
 8             if gcd == 1 && values.last! > 1 {
 9                 return false
10             }
11         }
12         return true
13     }
14     
15     func calculateGCD(_ a: Int, _ b:Int) -> Int {
16         let r = a > b ? a % b : b % a
17         if r != 0 {
18             return calculateGCD(b, (a > b ? a % b : b % a))
19         } else {
20             return a > b ? b : a
21         }
22     }
23 }

76ms

 1 class Solution {
 2         func hasGroupsSizeX(_ deck: [Int]) -> Bool {
 3             if deck.count == 0 {
 4                 return false
 5             }
 6             var countMap = [Int: Int]()
 7             for num in deck {
 8                 if let count = countMap[num] {
 9                     countMap[num] = count + 1
10                     continue
11                 }
12                 countMap[num] = 1
13             }
14             var min = Int.max
15             for (_, count) in countMap {
16                 if count < min {
17                     min = count
18                 }
19             }
20             if min < 2 {
21                 return false
22             }
23             for (_, count) in countMap {
24                 let remainder = count % min
25                 if remainder == 0 {
26                     continue
27                 }
28                 min = findFactor(max: count, min: min)
29                 if min == 1 {
30                     return false
31                 }
32             }
33             return true
34         }
35         func findFactor(max: Int, min: Int) -> Int {
36             let remainder = max % min
37             if remainder == 0 {
38                 return min
39             }
40             return findFactor(max: min, min: remainder)
41         }
42     }

80ms

 1 class Solution {
 2     func hasGroupsSizeX(_ deck: [Int]) -> Bool {
 3         if deck.count <= 1 { return false }
 4         
 5         var dict = [Int:Int]()
 6         for i in deck {
 7             if let count = dict[i] {
 8                 dict[i] = count+1
 9             } else {
10                 dict[i] = 1
11             }
12         }
13         var counts = Array(dict.values).sorted()
14         
15         if counts.count == 1 { return true }
16         
17         print(counts)
18         
19         for x in 2...counts.max()! {
20             var xIsS = true
21             for val in counts {
22                 if val % x != 0 {
23                     xIsS = false
24                 }
25             }
26             if xIsS { return true }
27         }
28         
29         return false
30     }
31 }

84ms

 1 class Solution {
 2     func hasGroupsSizeX(_ deck: [Int]) -> Bool {
 3         if deck.isEmpty {
 4             return false
 5         }
 6         let counter = deck.reduce(into: [:]) { counts, elem in counts[elem, default: 0] += 1 }
 7         let values = counter.values
 8 
 9         let maxCount = values.max()!
10 
11         if values.min()! < 2 {
12             return false
13         }
14 
15         for div in 2...maxCount {
16             if (values.reduce(true) { $0 && ($1 % div == 0) }) {
17                 return true
18             }
19         }
20 
21         return false
22     }
23 }

156ms

 1 class Solution {
 2     func hasGroupsSizeX(_ deck: [Int]) -> Bool {
 3         var map = [Int: Int]()
 4         if deck.isEmpty || deck.count == 1 {
 5             return false
 6         }
 7         for i in 0..<deck.count {
 8             if let val = map[deck[i]] {
 9                 map[deck[i]] = val + 1
10             } else {
11                 map[deck[i]] = 1
12             }
13         }
14         let set = Array(map.values)
15         var result = set[0]
16         for i in 1..<set.count {
17             result = getHCF(result, set[i])
18         }
19         
20         return result > 1
21     }
22     
23     func getHCF(_ a: Int, _ b: Int) -> Int {
24         if a == 0 {
25             return b
26         }
27         if b == 0 {
28             return a
29         }
30         if a == b {
31             return a
32         }
33         if a <= b {
34             return getHCF(a, b % a)
35         } else {
36             return getHCF(a % b, b)
37         }
38         return 1
39     }
40 }

164ms

 1 class Solution {
 2     func hasGroupsSizeX(_ deck: [Int]) -> Bool {
 3         func gcd(a: Int, b: Int) -> Int {
 4             return (b > 0 ? gcd(a: b, b: a % b) : a)
 5         }
 6         
 7         //
 8         guard deck.count >= 2 else { return false }
 9         
10         var dict: [Int: Int] = [:]
11         
12         for num in deck {
13             dict[num] = (dict[num] ?? 0) + 1
14         }
15         
16         let counts = dict.keys.compactMap { dict[$0] }
17         
18         var res = 0
19         for count in counts {
20             res = gcd(a: count, b: res)
21         }
22         
23         return res > 1
24     }
25 }

172ms

 1 class Solution {
 2   func gcd(_ a: Int, _ b: Int) -> Int {
 3     let r = a % b
 4     if r != 0 {
 5       return gcd(b, r)
 6     } else {
 7       return b
 8     }
 9   }
10   
11   func hasGroupsSizeX(_ deck: [Int]) -> Bool {
12     var cnt: [Int:Int] = [:]
13     deck.forEach {cnt[$0] = cnt[$0, default:0] + 1}
14     
15     let X = cnt.values.reduce(cnt.first!.value, gcd)
16     return X >= 2
17   }
18 }

180ms

 1 class Solution {
 2     func hasGroupsSizeX(_ deck: [Int]) -> Bool {
 3         var nums:[Int:Int] = [:]
 4         for c in deck {
 5             if nums[c] == nil {
 6                 nums[c] = 1
 7             } else {
 8                 nums[c]! += 1
 9             }
10         }
11         
12         
13         var arr = nums.map { (a) -> Int in
14             return a.value
15         }
16         
17         if arr.count == 1 && arr[0] == 1 {
18             return false
19         }
20         
21         print(arr)
22   
23         var hcf:Int = arr.removeFirst()
24         
25         func gcd(a:Int, b:Int) -> Int {
26             if a == b {
27                 return a
28             } else {
29                 if a > b {
30                     return gcd(a:a-b,b:b)
31                 } else {
32                     return gcd(a:a,b:b-a)
33                 }
34             }
35         }
36         
37         while !arr.isEmpty {
38             hcf = gcd(a:hcf, b:arr.removeFirst())
39             if hcf == 1 {
40                 return false
41             }
42         }
43         return true
44         
45     }
46 }

276ms

 1 class Solution {
 2     func hasGroupsSizeX(_ deck: [Int]) -> Bool {
 3         var f:[Int] = [Int](repeating: 0,count: 10001)
 4         for d in deck
 5         {
 6             f[d] += 1
 7         }
 8         var g:Int = 0
 9         for v in f
10         {
11             g = gcd(g,v)
12         }
13         return g != 1
14     }
15     func gcd(_ a:Int,_ b:Int) -> Int
16     {
17         var a = a
18         var b = b
19         while(b > 0)
20         {
21             var c:Int = a
22             a = b
23             b = c % b
24         }
25         return a
26     }
27 }

相关阅读:
Python List comprehension列表推导式
 Git
Python 默认参数关键词参数位置参数
 Blog List
【论文笔记】DeepOrigin: End-to-End Deep Learning for Detection of New Malware Families
【论文笔记】Malware Detection with Deep Neural Network Using Process Behavior
Scala入门【1】
RocketMQ与Kafka对比（18项差异）
Kafka简介
 Spark存储管理（读书笔记）
原文地址：https://www.cnblogs.com/strengthen/p/9856704.html