# 846. Hand of Straights

Alice has a `hand` of cards, given as an array of integers.

Now she wants to rearrange the cards into groups so that each group is size `W`, and consists of `W` consecutive cards.

Return `true` if and only if she can.

**Example 1:**

```
Input: hand = [1,2,3,6,2,3,4,7,8], W = 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], W = 4
Output: false
Explanation: Alice's hand can't be rearranged into groups of 4.
```

**Note:**

1. `1 <= hand.length <= 10000`
2. `0 <= hand[i] <= 10^9`
3. `1 <= W <= hand.length`

```cpp
// Greedy
bool isNStraightHand(vector<int>& hand, int W) { // time: O(nlogn); space: O(n)
    if (hand.size() % W) return false;
    sort(hand.begin(), hand.end());
    unordered_map<int, int> cnt;
    for (const int& num : hand) ++cnt[num];
    for (const int& num : hand) {
        if (!cnt[num]) continue;
        bool success = false;
        for (int i = 0; i < W; ++i) {
            if (!cnt[num + i]--) break;
            if (i == W - 1) success = true;
        }
        if (!success) return false;
    }
    return true;
}
```

```cpp
bool isNStraightHand(vector<int>& hand, int W) { // time: O(nlogn); space: O(n)
    if (hand.size() % W) return false;
    map<int, int> cnt;
    for (const int& num : hand) ++cnt[num];
    for (auto& e : cnt) {
        if (!e.second) continue;
        for (int i = W - 1; i >= 0; --i) {
            if (cnt[e.first + i] < e.second) return false;
            cnt[e.first + i] -= e.second;
        }
    }
    return true;
}
```