Add problem 846: Hand of Straights

Author: EFanZh

src/lib.rs

@@ -691,6 +691,7 @@ pub mod problem_0838_push_dominoes;
 pub mod problem_0841_keys_and_rooms;
 pub mod problem_0844_backspace_string_compare;
 pub mod problem_0845_longest_mountain_in_array;
+pub mod problem_0846_hand_of_straights;
 pub mod problem_0867_transpose_matrix;
 pub mod problem_1143_longest_common_subsequence;
 pub mod problem_1192_critical_connections_in_a_network;

src/problem_0846_hand_of_straights/iterative.rs

@@ -0,0 +1,64 @@
+pub struct Solution;
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn is_n_straight_hand(hand: Vec<i32>, group_size: i32) -> bool {
+        let group_size = group_size as usize;
+
+        if hand.len() % group_size == 0 {
+            let mut cards = HashMap::new();
+
+            for card in hand {
+                cards.entry(card).and_modify(|count| *count += 1).or_insert(1);
+            }
+
+            let mut cards = cards.into_iter().collect::<Vec<_>>();
+
+            cards.sort_unstable_by_key(|&(card, _)| card);
+
+            if let Some(max_i) = cards.len().checked_sub(group_size) {
+                for i in 0..=max_i {
+                    let (&mut (first_card, first_count), rest) = cards[i..i + group_size].split_first_mut().unwrap();
+
+                    if first_count != 0 {
+                        let mut prev_card = first_card;
+
+                        for (card, count) in rest {
+                            if *card == prev_card + 1 && *count >= first_count {
+                                *count -= first_count;
+                                prev_card = *card;
+                            } else {
+                                return false;
+                            }
+                        }
+                    }
+                }
+
+                return cards[cards.len() - group_size + 1..]
+                    .iter()
+                    .all(|&(_, count)| count == 0);
+            }
+        }
+
+        false
+    }
+}
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl super::Solution for Solution {
+    fn is_n_straight_hand(hand: Vec<i32>, group_size: i32) -> bool {
+        Self::is_n_straight_hand(hand, group_size)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_solution() {
+        super::super::tests::run::<super::Solution>();
+    }
+}

src/problem_0846_hand_of_straights/iterative_2.rs

@@ -0,0 +1,74 @@
+pub struct Solution;
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+use std::collections::hash_map::DefaultHasher;
+use std::collections::HashMap;
+use std::hash::BuildHasherDefault;
+
+// <https://leetcode.com/problems/hand-of-straights/discuss/137794/Python-true-O(N)-solution>.
+
+impl Solution {
+    pub fn is_n_straight_hand(hand: Vec<i32>, group_size: i32) -> bool {
+        if hand.len() % group_size as usize == 0 {
+            let mut cards = HashMap::with_hasher(BuildHasherDefault::<DefaultHasher>::default());
+
+            for card in hand {
+                cards.entry(card).and_modify(|count| *count += 1).or_insert(1);
+            }
+
+            let mut straights = HashMap::new();
+            let mut opened = 0;
+
+            while let Some(&card) = cards.keys().next() {
+                let mut card = card;
+
+                while cards.contains_key(&(card - 1)) {
+                    card -= 1;
+                }
+
+                while let Some(count) = cards.remove(&card) {
+                    if count < opened {
+                        return false;
+                    }
+
+                    let new_open = count - opened;
+
+                    if new_open != 0 {
+                        straights.insert(card, new_open);
+                    }
+
+                    opened = straights
+                        .remove(&(card - group_size + 1))
+                        .map_or(count, |closed| count - closed);
+
+                    card += 1;
+                }
+
+                if opened != 0 {
+                    return false;
+                }
+            }
+
+            true
+        } else {
+            false
+        }
+    }
+}
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl super::Solution for Solution {
+    fn is_n_straight_hand(hand: Vec<i32>, group_size: i32) -> bool {
+        Self::is_n_straight_hand(hand, group_size)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_solution() {
+        super::super::tests::run::<super::Solution>();
+    }
+}

src/problem_0846_hand_of_straights/mod.rs

@@ -0,0 +1,35 @@
+pub mod iterative;
+pub mod iterative_2;
+
+pub trait Solution {
+    fn is_n_straight_hand(hand: Vec<i32>, group_size: i32) -> bool;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    pub fn run<S: Solution>() {
+        let test_cases = [
+            ((&[1, 2, 3, 6, 2, 3, 4, 7, 8] as &[_], 3), true),
+            ((&[1, 2, 3, 4, 5], 4), false),
+            ((&[0, 0], 2), false),
+            (
+                (
+                    &[
+                        9, 13, 15, 23, 22, 25, 4, 4, 29, 15, 8, 23, 12, 19, 24, 17, 18, 11, 22, 24, 17, 17, 10, 23, 21,
+                        18, 14, 18, 7, 6, 3, 6, 19, 11, 16, 11, 12, 13, 8, 26, 17, 20, 13, 19, 22, 21, 27, 9, 20, 15,
+                        20, 27, 8, 13, 25, 23, 22, 15, 9, 14, 20, 10, 6, 5, 14, 12, 7, 16, 21, 18, 21, 24, 23, 10, 21,
+                        16, 18, 16, 18, 5, 20, 19, 20, 10, 14, 26, 2, 9, 19, 12, 28, 17, 5, 7, 25, 22, 16, 17, 21, 11,
+                    ],
+                    10,
+                ),
+                false,
+            ),
+        ];
+
+        for ((hand, group_size), expected) in test_cases {
+            assert_eq!(S::is_n_straight_hand(hand.to_vec(), group_size), expected);
+        }
+    }
+}