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

Idea 1. count the occurences of each number in the deck and check if the greatest common divisor of all counts pair > 1

Time complexity: O(Nlog^2N), where N is the number of cards. gcd operation is O(log^2C) if there are C cards for number i. need to read further about it.

Space complexity: O(N)

 1 class Solution {
 2     int gcd(int a, int b) {
 3         while(b != 0) {
 4             int temp = b;
 5             b = a%b;
 6             a = temp;
 7         }
 8         return a;
 9     }
10     public boolean hasGroupsSizeX(int[] deck) {
11         if(deck.length < 2) {
12             return false;
13         }
14         
15         Map<Integer, Integer> intCnt = new HashMap<>();
16         for(int num: deck) {
17             intCnt.put(num, intCnt.getOrDefault(num, 0) + 1);
18         }
19         
20         
21         int preVal = -1;
22         for(int val: intCnt.values()) {
23             if(val == 1) {
24                 return false;
25             }
26             if(preVal == -1) {
27                 preVal = val;
28             }
29             else {
30                 preVal = gcd(preVal, val);
31                 if(preVal == 1) {
32                     return false;
33                 }   
34             }
35         }
36         
37         return preVal >= 2;
38     }
39 }

网上看到的超级简洁，自己的差好远，还有很长的路啊

class Solution {
    int gcd(int a, int b) {
        while(b != 0) {
            int temp = b;
            b = a%b;
            a = temp;
        }
        return a;
    }
    public boolean hasGroupsSizeX(int[] deck) {
        Map<Integer, Integer> intCnt = new HashMap<>();
        for(int num: deck) {
            intCnt.put(num, intCnt.getOrDefault(num, 0) + 1);
        }
        
        
        int res = 0;
        for(int val: intCnt.values()) {
            res = gcd(val, res);  
        }
        
        return res >= 2;
    }
}