Hand of straights

/*
 * 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/
 */

use std::collections::BTreeMap;
impl Solution {
  pub fn is_n_straight_hand(hand: Vec<i32>, group_size: i32) -> bool {
    if hand.len() % group_size as usize != 0 { return false; }
    let mut counts: BTreeMap<i32, i32> = BTreeMap::new();
    for h in hand { *counts.entry(h).or_insert(0) += 1; }
    while let Some((&start, _)) = counts.iter().next() {
      let cnt = *counts.get(&start).unwrap();
      for i in 0..group_size {
        let v = start + i;
        let c = *counts.get(&v).unwrap_or(&0);
        if c < cnt { return false; }
        if c == cnt { counts.remove(&v); }
        else { counts.insert(v, c - cnt); }
      }
    }
    true
  }
}