Intuition

The smallest remaining card must start a group. Greedily forming groups from the smallest value forces the choice, so a frequency map processed in sorted order settles it.

Approach

If the count of cards is not divisible by k, return false.
Count each value; process values in ascending order.
For each value with remaining count c, consume c copies of the next k consecutive values; if any is short, return false.

Complexity

Time — O(n log n): sorting the distinct values.
Space — O(n): the count map.

Common Pitfalls

Start each group at the smallest available card; picking arbitrary starts fails.

Full Solution — all languages

class Solution:
    def isNStraightHand(self, hand, k):
        if len(hand)%k: return False
        from collections import Counter
        count=Counter(hand)
        for v in sorted(count):
            c=count[v]
            if c>0:
                for i in range(v,v+k):
                    if count[i]<c: return False
                    count[i]-=c
        return True

import java.util.*;

class Solution {
    public boolean isNStraightHand(int[] hand, int k) {
        if(hand.length%k!=0)return false; TreeMap<Integer,Integer> cnt=new TreeMap<>(); for(int x:hand)cnt.merge(x,1,Integer::sum); for(int v:new ArrayList<>(cnt.keySet())){int c=cnt.getOrDefault(v,0); if(c>0){for(int i=v;i<v+k;i++){if(cnt.getOrDefault(i,0)<c)return false; cnt.put(i,cnt.get(i)-c);}}} return true;
    }
}

#include <bits/stdc++.h>
using namespace std;

class Solution {
public:
    bool isNStraightHand(vector<int>& hand, int k) {
        if(hand.size()%k)return false; map<int,int> cnt; for(int x:hand)cnt[x]++; for(auto& kv:cnt){int v=kv.first,c=cnt[v]; if(c>0){for(int i=v;i<v+k;i++){if(cnt[i]<c)return false; cnt[i]-=c;}}} return true;
    }
};

/**
 * @param {number[]} hand
 * @param {number} k
 * @return {boolean}
 */
var isNStraightHand = function(hand, k) {
    if(hand.length%k)return false; const cnt={}; hand.forEach(x=>cnt[x]=(cnt[x]||0)+1); const keys=Object.keys(cnt).map(Number).sort((a,b)=>a-b); for(const v of keys){const c=cnt[v]; if(c>0){for(let i=v;i<v+k;i++){if((cnt[i]||0)<c)return false; cnt[i]-=c;}}} return true;
};

Hand of Straights

Example 1

Example 2

Constraints