## Title: card grouping

Given a deck of cards, an integer is written on each card.

At this point, you need to select a number x, so that we can divide the whole deck into one or more groups according to the following rules:

Each group has X cards.

All cards in the group have the same integer written on them.

Returns “true” only if your optional x > = 2.

Example 1:

Input: [1,2,3,4,4,3,2,1]

Output: true

Explanation: the feasible groups are [1,1], [2,2], [3,3], [4,4]

Example 2:

Input: [1,1,1,2,2,2,3,3]

Output: false

Explanation: there are no groups that meet the requirements.

Example 3:

Input: [1]

Output: false

Explanation: there are no groups that meet the requirements.

Example 4:

Input: [1,1]

Output: true

Explanation: the feasible grouping is [1,1]

Example 5:

Input: [1,1,2,2,2]

Output: true

Explanation: the feasible groups are [1,1], [2,2], [2,2]

Tips:

1 <= deck.length <= 10000

0 <= deck[i]

Thinking:

First of all, according to the conditions of the topic, we are required to divide the cards into one or more groups, and each group of cards is the same.

We can think of, if each group has only one card, then no matter how many cards there are, there are qualified points.

If each group has two cards, then the total number of each kind of same card must be a multiple of 2, in order to meet the conditions of the division.

If there are three cards in each group, then the total number of the same card in each group must be a multiple of 3 in order to meet the conditions.

By analogy, the number x we are looking for is:

Let y be a set

- The total number of all the same cards is a multiple of the elements in Y, that is, they can divide the elements in Y exactly
- X is the largest possible number of Y elements

Obviously, the Y set is the common divisor of all the same number of cards, and X is their greatest common divisor.

Code (c) above:

```
//Finding the greatest common divisor int GCD (int x, int y){
int tmp;
while( y != 0 ) {
tmp = x;
x = y;
y = tmp%y;
}
return x;
}
bool hasGroupsSizeX(int* deck, int deckSize){
int count[10005] = {0};
int x = -1;
for( int i = 0; i < deckSize; i++ ) {
count[deck[i]]++;
}
for( int i = 0; i < 10005; i++ ) {
if( count[i] > 0 ) {
if( x == -1 ) ans = count[i];
else x = gcd( ans, count[i] );
}
}
if( x >= 2 ) return true;
return false;
}
```

2020-03-27-19:03:11