Reset

Author: mapx

src/n1071_binary_prefix_divisible_by_5.rs

@@ -0,0 +1,102 @@
+/**
+ * [1071] Binary Prefix Divisible By 5
+ *
+ * Given an array A of 0s and 1s, consider N_i: the i-th subarray from A[0] to A[i] interpreted as a binary number (from most-significant-bit to least-significant-bit.)
+ *
+ * Return a list of booleans answer, where answer[i] is true if and only if N_i is divisible by 5.
+ *
+ * Example 1:
+ *
+ *
+ * Input: <span id="example-input-1-1">[0,1,1]</span>
+ * Output: <span id="example-output-1">[true,false,false]</span>
+ * Explanation:
+ * The input numbers in binary are 0, 01, 011; which are 0, 1, and 3 in base-10.  Only the first number is divisible by 5, so answer[0] is true.
+ *
+ *
+ * Example 2:
+ *
+ *
+ * Input: <span id="example-input-2-1">[1,1,1]</span>
+ * Output: <span id="example-output-2">[false,false,false]</span>
+ *
+ *
+ * Example 3:
+ *
+ *
+ * Input: <span id="example-input-3-1">[0,1,1,1,1,1]</span>
+ * Output: <span id="example-output-3">[true,false,false,false,true,false]</span>
+ *
+ *
+ * Example 4:
+ *
+ *
+ * Input: <span id="example-input-4-1">[1,1,1,0,1]</span>
+ * Output: <span id="example-output-4">[false,false,false,false,false]</span>
+ *
+ *
+ *  
+ *
+ * Note:
+ *
+ * <ol>
+ * 	1 <= A.length <= 30000
+ * 	A[i] is 0 or 1
+ * </ol>
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn prefixes_div_by5(a: Vec<i32>) -> Vec<bool> {
+        let mut ret = vec![];
+        let mut n = 0;
+        for i in a {
+            let remain = (n * 2 + i) % 5;
+            ret.push(remain == 0);
+            n = remain;
+        }
+        return ret;
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1071() {
+        assert_eq!(
+            Solution::prefixes_div_by5(vec![0, 1, 1]),
+            vec![true, false, false]
+        );
+        assert_eq!(
+            Solution::prefixes_div_by5(vec![1, 1, 1]),
+            vec![false, false, false]
+        );
+        assert_eq!(
+            Solution::prefixes_div_by5(vec![0, 1, 1, 1, 1, 1]),
+            vec![true, false, false, false, true, false]
+        );
+        assert_eq!(
+            Solution::prefixes_div_by5(vec![1, 1, 1, 0, 1]),
+            vec![false, false, false, false, false]
+        );
+        assert_eq!(
+            Solution::prefixes_div_by5(vec![
+                1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0,
+                0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1
+            ]),
+            vec![
+                false, false, false, false, false, false, false, false, false, false, false, false,
+                false, false, false, false, false, false, false, false, false, false, false, false,
+                false, false, false, false, false, false, false, true, false, false, true, true,
+                true, true, false
+            ]
+        );
+    }
+}

src/n1127_last_stone_weight.rs

@@ -0,0 +1,75 @@
+/**
+ * [1127] Last Stone Weight
+ *
+ * We have a collection of rocks, each rock has a positive integer weight.
+ *
+ * Each turn, we choose the two heaviest rocks and smash them together.  Suppose the stones have weights x and y with x <= y.  The result of this smash is:
+ *
+ *
+ * 	If x == y, both stones are totally destroyed;
+ * 	If x != y, the stone of weight x is totally destroyed, and the stone of weight y has new weight y-x.
+ *
+ *
+ * At the end, there is at most 1 stone left.  Return the weight of this stone (or 0 if there are no stones left.)
+ *
+ *  
+ *
+ * Example 1:
+ *
+ *
+ * Input: [2,7,4,1,8,1]
+ * Output: 1
+ * Explanation:
+ * We combine 7 and 8 to get 1 so the array converts to [2,4,1,1,1] then,
+ * we combine 2 and 4 to get 2 so the array converts to [2,1,1,1] then,
+ * we combine 2 and 1 to get 1 so the array converts to [1,1,1] then,
+ * we combine 1 and 1 to get 0 so the array converts to [1] then that's the value of last stone.
+ *
+ *  
+ *
+ * Note:
+ *
+ * <ol>
+ * 	1 <= stones.length <= 30
+ * 	1 <= stones[i] <= 1000
+ * </ol>
+ */
+pub struct Solution {}
+use std::collections::BinaryHeap;
+
+// submission codes start here
+
+impl Solution {
+    pub fn last_stone_weight(stones: Vec<i32>) -> i32 {
+        let mut heap = BinaryHeap::new();
+        heap.extend(stones);
+        loop {
+            if let Some(rock1) = heap.pop() {
+                if let Some(rock2) = heap.pop() {
+                    if rock1 > rock2 {
+                        heap.push(rock1 - rock2);
+                    }
+                } else {
+                    return rock1;
+                }
+            } else {
+                return 0;
+            }
+        }
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1127() {
+        assert_eq!(Solution::last_stone_weight(vec![2, 7, 4, 1, 8, 1]), 1);
+        assert_eq!(Solution::last_stone_weight(vec![2]), 2);
+        assert_eq!(Solution::last_stone_weight(vec![2, 2]), 0);
+        assert_eq!(Solution::last_stone_weight(vec![1, 2, 2]), 1);
+    }
+}