X of a Kind in a Deck of Cards - Practice Coding Problems

X of a Kind in a Deck of Cards - Problem

Array Hash Table Math Counting Number Theory Easy

You have a deck of cards, and each card has a number written on it. Your task is to determine if you can partition all the cards into groups where:

Each group has exactly X cards (where X ≥ 2)
All cards in the same group have the same number
Every card must be placed in exactly one group

Return true if such a partition is possible, false otherwise.

Example: If you have cards [1,2,3,4,4,3,2,1], you could group them as:

Group 1: [1,1] (2 cards with value 1)
Group 2: [2,2] (2 cards with value 2)
Group 3: [3,3] (2 cards with value 3)
Group 4: [4,4] (2 cards with value 4)

Since all groups have the same size (2) and X=2 ≥ 2, this partition is valid!

Input & Output

example_1.py — Basic valid partition

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

› Output: true

💡 Note: We can partition into groups of size 2: [1,1], [2,2], [3,3], [4,4]. Each group has exactly 2 cards with the same value.

example_2.py — No valid partition

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

› Output: false

💡 Note: We have 3 ones, 3 twos, and 2 threes. No single group size X works for all: X=2 doesn't divide 3, X=3 doesn't divide 2.

example_3.py — Single card type

$ Input: [1,1,1,1,1,1]

› Output: true

💡 Note: All 6 cards have value 1. We can form 3 groups of size 2, or 2 groups of size 3, or 1 group of size 6. All are valid since X ≥ 2.

Visualization

Tap to expand

Understanding the Visualization

Count Players by Card

Count how many players have each card value - this gives us frequency constraints

Find Team Size

The team size must divide evenly into every card group - this is where GCD helps

Verify Minimum

Check if the largest valid team size is at least 2 players

Form Teams

If GCD ≥ 2, we can successfully partition all players into equal-sized teams

Key Takeaway

🎯 Key Insight: The problem reduces to finding GCD of frequencies. If GCD ≥ 2, we can partition all cards into equal-sized groups where each group contains cards of the same value.

Time & Space Complexity

Time Complexity

⏱️

O(n log(max_freq))

Single pass O(n), with GCD computation O(log(max_freq)) for each unique card

⚡ Linearithmic

Space Complexity

O(k)

Hash map to store frequency of k unique card values

✓ Linear Space

Constraints

1 ≤ deck.length ≤ 10⁴
0 ≤ deck[i] < 10⁴
Group size must be at least 2
All cards must be partitioned (no leftover cards allowed)

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 19

The optimal solution uses GCD (Greatest Common Divisor) of card frequencies. Since valid group size X must divide all frequencies, the answer is whether GCD ≥ 2. We can compute this efficiently in a single pass with early termination when GCD becomes 1.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Group Sizes)	O(n * max_freq)	O(unique_values)	Count frequencies, then try every possible group size from 2 to max frequency
One-Pass GCD (Optimal)	O(n log(max_freq))	O(k)	Count frequencies and compute running GCD simultaneously in a single pass
Two-Pass with GCD	O(n + k log(max_freq))	O(k)	Count frequencies first, then compute GCD of all frequencies to find the answer

Brute Force (Try All Group Sizes) — Algorithm Steps

Count frequency of each card value in the deck
For each possible group size X from 2 to max frequency:
Check if all frequencies are divisible by X
If any X works, return true; if none work, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count how many times each card value appears

Try Group Size 2

Check if all frequencies are divisible by 2

Try Group Size 3

Check if all frequencies are divisible by 3

Continue Testing

Keep trying until we find a valid size or exhaust all options

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MAX_VAL 10000

bool hasGroupsSizeX(int* deck, int deckSize) {
    if (deckSize < 2) return false;
    
    int freq[MAX_VAL + 1] = {0};
    for (int i = 0; i < deckSize; i++) {
        freq[deck[i]]++;
    }
    
    int frequencies[MAX_VAL];
    int freqCount = 0, maxFreq = 0;
    for (int i = 0; i <= MAX_VAL; i++) {
        if (freq[i] > 0) {
            frequencies[freqCount++] = freq[i];
            if (freq[i] > maxFreq) {
                maxFreq = freq[i];
            }
        }
    }
    
    for (int x = 2; x <= maxFreq; x++) {
        bool valid = true;
        for (int i = 0; i < freqCount; i++) {
            if (frequencies[i] % x != 0) {
                valid = false;
                break;
            }
        }
        if (valid) return true;
    }
    
    return false;
}

int main() {
    int deck[1000];
    int deckSize = 0;
    char c;
    int num = 0;
    bool inNum = false;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            inNum = true;
        } else if (inNum) {
            deck[deckSize++] = num;
            num = 0;
            inNum = false;
        }
    }
    if (inNum) deck[deckSize++] = num;
    
    printf("%s\n", hasGroupsSizeX(deck, deckSize) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * max_freq)

O(n) to count frequencies, then O(max_freq * unique_values) to test all group sizes

✓ Linear Growth

Space Complexity

O(unique_values)

Hash map to store frequency of each unique card value

⚡ Linearithmic Space

Constraints

1 ≤ deck.length ≤ 10⁴
0 ≤ deck[i] < 10⁴
Group size must be at least 2
All cards must be partitioned (no leftover cards allowed)

42.4K Views

Medium-High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Group Sizes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler