Hand of Straights

Hand of Straights - Problem

Alice has some number of cards and she wants to rearrange the cards into groups so that each group is of size groupSize, and consists of groupSize consecutive cards.

Given an integer array hand where hand[i] is the value written on the i-th card and an integer groupSize, return true if she can rearrange the cards, or false otherwise.

Note: Each card can only be used once, and all cards must be used to form complete groups.

Input & Output

Example 1 — Basic Valid Case

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

› Output: true

💡 Note: We can form two groups: [1,2,3] and [2,3,6]. Both groups have 3 consecutive cards.

Example 2 — Invalid Case

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

› Output: false

💡 Note: We have 5 cards but need groups of 4. Since 5 is not divisible by 4, we cannot form complete groups.

Example 3 — Gap in Sequence

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

› Output: true

💡 Note: We can form two groups: [1,2,3] and [5,6,7]. Both groups have 3 consecutive cards.

Constraints

1 ≤ hand.length ≤ 10⁴
0 ≤ hand[i] ≤ 10⁹
1 ≤ groupSize ≤ hand.length

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is to use frequency counting with greedy group formation. Always start forming groups from the smallest available card value to ensure optimal usage. Best approach uses TreeMap for O(n log n) time complexity with O(n) space.

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(n!) Space: O(n)

Try every possible way to partition the cards into groups of the required size. For each partition, verify that every group contains consecutive numbers. This requires exponential time as we explore all possible combinations.

Frequency Count with Greedy Formation

⏱️ Time: O(n log n) Space: O(n)

Use a frequency map to count each card value, then sort the unique values. For each value, try to form groups starting from that value by taking consecutive cards. This greedy approach ensures we use cards optimally.

Optimized Greedy with Priority Queue

⏱️ Time: O(n log n) Space: O(n)

Combine frequency counting with a sorted map (TreeMap) to process cards in ascending order automatically. This eliminates the need for separate sorting and provides the most efficient solution for forming consecutive groups.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible ways to partition cards into groups
For each partition, check if groups have consecutive numbers
Return true if any valid partition exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Partitions

Create all possible ways to group cards

Check Consecutiveness

Verify each group has consecutive numbers

Return Result

True if any valid partition found

Code -

solution.c — C

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

char* ones[] = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine",
               "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", 
               "Seventeen", "Eighteen", "Nineteen"};

char* tens[] = {"", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"};

void convertHundreds(int n, char* result) {
    char temp[100] = "";
    
    if (n >= 100) {
        strcat(temp, ones[n / 100]);
        strcat(temp, " Hundred");
        n %= 100;
        if (n > 0) {
            strcat(temp, " ");
        }
    }
    
    if (n >= 20) {
        strcat(temp, tens[n / 10]);
        if (n % 10 > 0) {
            strcat(temp, " ");
            strcat(temp, ones[n % 10]);
        }
    } else if (n > 0) {
        strcat(temp, ones[n]);
    }
    
    strcpy(result, temp);
}

char* solution(int num) {
    static char result[1000];
    result[0] = '\0';
    
    if (num == 0) {
        strcpy(result, "Zero");
        return result;
    }
    
    if (num < 1000) {
        convertHundreds(num, result);
    } else if (num < 1000000) {
        int thousands = num / 1000;
        int remainder = num % 1000;
        char temp[100];
        convertHundreds(thousands, temp);
        strcat(result, temp);
        strcat(result, " Thousand");
        if (remainder > 0) {
            convertHundreds(remainder, temp);
            strcat(result, " ");
            strcat(result, temp);
        }
    } else if (num < 1000000000) {
        int millions = num / 1000000;
        int remainder = num % 1000000;
        char temp[100];
        convertHundreds(millions, temp);
        strcat(result, temp);
        strcat(result, " Million");
        if (remainder >= 1000) {
            int thousands = remainder / 1000;
            convertHundreds(thousands, temp);
            strcat(result, " ");
            strcat(result, temp);
            strcat(result, " Thousand");
            remainder %= 1000;
        }
        if (remainder > 0) {
            convertHundreds(remainder, temp);
            strcat(result, " ");
            strcat(result, temp);
        }
    } else {
        int billions = num / 1000000000;
        int remainder = num % 1000000000;
        char temp[100];
        convertHundreds(billions, temp);
        strcat(result, temp);
        strcat(result, " Billion");
        if (remainder >= 1000000) {
            int millions = remainder / 1000000;
            convertHundreds(millions, temp);
            strcat(result, " ");
            strcat(result, temp);
            strcat(result, " Million");
            remainder %= 1000000;
        }
        if (remainder >= 1000) {
            int thousands = remainder / 1000;
            convertHundreds(thousands, temp);
            strcat(result, " ");
            strcat(result, temp);
            strcat(result, " Thousand");
            remainder %= 1000;
        }
        if (remainder > 0) {
            convertHundreds(remainder, temp);
            strcat(result, " ");
            strcat(result, temp);
        }
    }
    
    return result;
}

int main() {
    int num;
    scanf("%d", &num);
    printf("%s\n", solution(num));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

Generating all partitions requires factorial time complexity

⚡ Linearithmic

Space Complexity

O(n)

Recursion stack and temporary storage for partitions

⚡ Linearithmic Space

89.0K Views

Medium Frequency

~15 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler