Hand of Straights - Practice Coding Problems

Hand of Straights - Problem

Card Sequence Challenge: Alice has a deck of cards with numbers written on them and wants to organize them into consecutive groups. Each group must contain exactly groupSize cards with consecutive values (like 3,4,5 or 7,8,9,10).

Given an array hand where each element represents a card value, and an integer groupSize, determine if Alice can successfully arrange all her cards into valid consecutive groups.

Example: If Alice has cards [1,2,3,6,2,3,4,7,8] and groupSize = 3, she can form groups [1,2,3], [2,3,4], and [6,7,8] - so return true.

Input & Output

example_1.py — Basic Consecutive Groups

$ Input: hand = [1,2,3,6,2,3,4,7,8], groupSize = 3

› Output: true

💡 Note: Alice can form three groups: [1,2,3], [2,3,4], and [6,7,8]. Each group has exactly 3 consecutive cards.

example_2.py — Impossible Grouping

$ Input: hand = [1,2,3,4,5], groupSize = 4

› Output: false

💡 Note: We have 5 cards but need groups of size 4. Since 5 is not divisible by 4, it's impossible to form valid groups.

example_3.py — Single Card Groups

$ Input: hand = [1,1,2,2,3,3], groupSize = 1

› Output: true

💡 Note: When groupSize is 1, each card forms its own group. Any hand can be arranged this way.

Visualization

Tap to expand

Understanding the Visualization

Count All Cards

Create a frequency map to know how many of each card value we have

Sort Card Values

Process card values in ascending order to ensure optimal grouping

Greedy Group Formation

For each card value, form as many consecutive sequences as possible

Validate Completeness

Ensure all cards are used and all groups are properly formed

Key Takeaway

🎯 Key Insight: The greedy approach of always starting with the smallest available card is optimal because it never blocks better arrangements - if a valid grouping exists, the greedy method will find it.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log n) for priority queue operations

⚡ Linearithmic

Space Complexity

O(n)

Priority queue and additional data structures to track sequences

⚡ Linearithmic Space

Constraints

1 ≤ hand.length ≤ 10⁴
0 ≤ hand[i] ≤ 10⁹
1 ≤ groupSize ≤ hand.length
All card values are non-negative integers

Asked in

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

The optimal solution uses a hash map to count card frequencies and then greedily forms consecutive groups starting from the smallest available card. This greedy approach works because if we can form a valid arrangement, we can always start sequences with the smallest unused card without missing better opportunities.

Common Approaches

Approach	Time	Space	Notes
✓ Sorted Array + Priority Queue	O(n log n)	O(n)	Use priority queue (min-heap) to always process cards in order while tracking consecutive sequences
Brute Force (Try All Combinations)	O(n!)	O(n)	Generate all possible ways to group cards and check if any valid arrangement exists
Two-Pass Hash Map + Greedy	O(n log n)	O(n)	First count all cards, then greedily form consecutive sequences starting from smallest

Sorted Array + Priority Queue — Algorithm Steps

Sort the hand array in ascending order
Use priority queue to process cards in order
For each card, try to extend existing partial sequences
If no sequence can be extended, start a new sequence
Verify all sequences are complete at the end

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Heap

Build min-heap from all cards

Pop Minimum

Always start new sequence with smallest card

Build Sequence

Find consecutive cards to complete the group

Code -

solution.c — C

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

#define MAX_VAL 10000

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

bool isNStraightHand(int* hand, int handSize, int groupSize) {
    if (handSize % groupSize != 0) return false;
    if (groupSize == 1) return true;
    
    // Sort the array
    qsort(hand, handSize, sizeof(int), compare);
    
    int count[MAX_VAL] = {0};
    int minVal = hand[0], maxVal = hand[handSize-1];
    
    for (int i = 0; i < handSize; i++) {
        count[hand[i]]++;
    }
    
    for (int card = minVal; card <= maxVal; card++) {
        while (count[card] > 0) {
            int needed = count[card];
            
            for (int i = 0; i < groupSize; i++) {
                int currentCard = card + i;
                if (currentCard > maxVal || count[currentCard] < needed) {
                    return false;
                }
                count[currentCard] -= needed;
            }
        }
    }
    
    return true;
}

int main() {
    int hand[] = {1, 2, 3, 6, 2, 3, 4, 7, 8};
    int handSize = 9;
    int groupSize = 3;
    printf("%s\n", isNStraightHand(hand, handSize, groupSize) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log n) for priority queue operations

⚡ Linearithmic

Space Complexity

O(n)

Priority queue and additional data structures to track sequences

⚡ Linearithmic Space

Constraints

1 ≤ hand.length ≤ 10⁴
0 ≤ hand[i] ≤ 10⁹
1 ≤ groupSize ≤ hand.length
All card values are non-negative integers

52.8K Views

Medium-High Frequency

~18 min Avg. Time

1.5K 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

Sorted Array + Priority Queue — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler