LeetCode 846: Hand of Straights

Problem Description

LeetCode Problem 846

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 ith card and an integer groupSize, return true if she can rearrange the cards, or false otherwise.

Example 1:

Input: hand = [1,2,3,6,2,3,4,7,8], groupSize = 3
Output: true
Explanation: Alice’s hand can be rearranged as [1,2,3],[2,3,4],[6,7,8]

Example 2:

Input: hand = [1,2,3,4,5], groupSize = 4
Output: false
Explanation: Alice’s hand can not be rearranged into groups of 4.

Constraints:

• 1 <= hand.length <= 104
• 0 <= hand[i] <= 109
• 1 <= groupSize <= hand.length

Note: This question is the same as 1296: https://leetcode.com/problems/divide-array-in-sets-of-k-consecutive-numbers/

Difficulty: Medium

Tags: array, hash table, greedy, sorting

Rating: 92.76%

Solution

Here’s my Python solution to this problem:

#Problem 846: Hand of Straights

class Solution:
    def isNStraightHand(self, hand: List[int], groupSize: int) -> bool:
        if len(hand) % groupSize != 0: return False

        counts = Counter(hand)
        sorted_counts = sorted(counts.keys())

        # Treating each card as potential start of group
        for c in sorted_counts:
            if counts[c] == 0:
                continue
            
            freq = counts[c]
            for num in range(c, c + groupSize):
                if counts[num] < freq:
                    return False
                counts[num] -= freq
            
        return True

Complexity Analysis

The solution has the following complexity characteristics:

• Time Complexity: $O(n²)$
• Space Complexity: $O(1)$

Note: This is an automated analysis and may not capture all edge cases or specific algorithmic optimizations.