X of a Kind in a Deck of Cards LT914

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)

 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) {
         if(deck.length < 2) {
             return false;
         }
 
         Map<Integer, Integer> intCnt = new HashMap<>();
         for(int num: deck) {
             intCnt.put(num, intCnt.getOrDefault(num, 0) + 1);
         }
 
         int preVal = -1;
         for(int val: intCnt.values()) {
             if(val == 1) {
                 return false;
             }
             if(preVal == -1) {
                 preVal = val;
             }
             else {
                 preVal = gcd(preVal, val);
                 if(preVal == 1) {
                     return false;
                 }
             }
         }
 
         return preVal >= 2;
     }
 }

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

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;
    }
}