Add more solutions

martwz · martwz · commit 1d3cc9acf8c4 · 2021-10-03T07:02:37.000-07:00
diff --git a/README.md b/README.md
@@ -6,7 +6,7 @@
 
 LeetCode is a website that has programming-related questions that are designed to be solved in a limited amount of time. This repository is a collection of some of my solutions written in [Rust](https://www.rust-lang.org/).
 
-## Solutions
+## Solutions (49) 
 | No. | Title | Solution | Problem | Difficulty |
 |:---:|:------|:--------:|:-------:|:----------:|
 | 1 | Two Sum | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/two_sum.rs) | [Leetcode](https://leetcode.com/problems/two-sum/) | Easy |
@@ -50,7 +50,11 @@ LeetCode is a website that has programming-related questions that are designed t
 | 1293 | Shortest Path in a Grid with Obstacles Elimination | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/shortest_path.rs) | [Leetcode](https://leetcode.com/problems/shortest-path-in-a-grid-with-obstacles-elimination/) | Hard |
 | 1328 | Break a Palindrome | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/challenge/break_palindrome.rs) | [Leetcode](https://leetcode.com/problems/break-a-palindrome/) | Medium |
 | 1457 | Pseudo-Palindromic Paths in a Binary Tree | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/pseudo_palindromic_paths.rs) | [Leetcode](https://leetcode.com/problems/pseudo-palindromic-paths-in-a-binary-tree/) | Easy |
+| 1801 | Number of Orders in the Backlog | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/get_number_of_backlog_orders.rs) | [Leetcode](https://leetcode.com/problems/number-of-orders-in-the-backlog/) | Medium |
+| 1962 | Remove Stones to Minimize the Total | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/problem/min_stone_sum.rs) | [Leetcode](https://leetcode.com/problems/remove-stones-to-minimize-the-total/) | Medium |
 | 2022 | Convert 1D Array Into 2D Array | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/contest/biweekly_62.rs) | [Leetcode](https://leetcode.com/problems/convert-1d-array-into-2d-array/) | Easy |
 | 2023 | Number of Pairs of Strings With Concatenation Equal to Target | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/contest/biweekly_62.rs) | [Leetcode](https://leetcode.com/problems/number-of-pairs-of-strings-with-concatenation-equal-to-target/) | Medium |
 | 2024 | Maximize the Confusion of an Exam | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/contest/biweekly_62.rs) | [Leetcode](https://leetcode.com/problems/maximize-the-confusion-of-an-exam/) | Medium |
-| 2025 | Maximum Number of Ways to Partition an Array | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/contest/biweekly_62.rs) | [Leetcode](https://leetcode.com/problems/maximum-number-of-ways-to-partition-an-array/) | Hard |
+| 2025 | Maximum Number of Ways to Partition an Array | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/contest/biweekly_62.rs) | [Leetcode](https://leetcode.com/problems/maximum-number-of-ways-to-partition-an-array/) | Hard |
+| 2027 | Minimum Moves to Convert String | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/contest/weekly_261.rs) | [Leetcode](https://leetcode.com/problems/minimum-moves-to-convert-string/) | Easy |
+| 2028 | Find Missing Observations | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/./src/leetcode/contest/weekly_261.rs) | [Leetcode](https://leetcode.com/problems/find-missing-observations/) | Medium |
diff --git a/src/leetcode/contest/weekly_261.rs b/src/leetcode/contest/weekly_261.rs
@@ -1 +1,138 @@
+use std::collections::HashMap;
 
+// 2027. Minimum Moves to Convert String, Easy
+// https://leetcode.com/problems/minimum-moves-to-convert-string/
+impl Solution1 {
+    pub fn minimum_moves(s: String) -> i32 {
+        let mut arr: Vec<i32> = vec![];
+
+        for ch in s.chars() {
+            if ch == 'X' {
+                arr.push(1);
+            } else {
+                arr.push(0);
+            }
+        }
+
+        let mut moves = 0;
+        let n = arr.len();
+        let [mut l, mut r] = [0, 0];
+        while r < n {
+            if r - l < 2 {
+                r += 1;
+            } else {
+                if arr[l] == 1 {
+                    arr[l] = 0;
+                    arr[l + 1] = 0;
+                    arr[l + 2] = 0;
+                    moves += 1;
+                } else {
+                    l += 1;
+                }
+            }
+
+            if r == n && (arr[r - 1] == 1 || arr[r - 2] == 1 || arr[r - 3] == 1) {
+                moves += 1;
+            }
+        }
+
+        moves
+    }
+}
+
+// 2028. Find Missing Observations, Medium
+// https://leetcode.com/problems/find-missing-observations/
+impl Solution2 {
+    pub fn missing_rolls(rolls: Vec<i32>, mean: i32, n: i32) -> Vec<i32> {
+        if rolls.len() == 0 || n == 0 {
+            return vec![];
+        }
+
+        let m = rolls.len() as i32;
+
+        let have_sum = rolls.iter().sum::<i32>();
+        let mut missing_sum = (mean * (n + m)) - have_sum;
+
+        let avg_missing = missing_sum / n;
+        let mut action = true;
+        if avg_missing > 0 && avg_missing <= 6 {
+            let mut missing_rolls = vec![avg_missing; n as usize];
+            missing_sum -= avg_missing * n;
+            'outer: while missing_sum > 0 {
+                for i in 0..n {
+                    if missing_sum <= 0 || !action {
+                        if !action {
+                            return vec![];
+                        }
+                        break 'outer;
+                    }
+                    if missing_rolls[i as usize] < 6 {
+                        let add = i32::min(6 - missing_rolls[i as usize], missing_sum);
+                        missing_rolls[i as usize] += add;
+                        missing_sum -= add;
+                        action = true;
+                    } else {
+                        action = false;
+                    }
+                }
+            }
+
+            return missing_rolls;
+        } else {
+            return vec![];
+        }
+    }
+}
+
+struct Solution1 {}
+struct Solution2 {}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{vec_string, vec_vec_i32};
+
+    #[test]
+    fn test_minimum_moves() {
+        assert_eq!(Solution1::minimum_moves("XXX".to_string()), 1);
+    }
+
+    #[test]
+    fn test_minimum_moves2() {
+        assert_eq!(Solution1::minimum_moves("XXOX".to_string()), 2);
+    }
+
+    #[test]
+    fn test_minimum_moves3() {
+        assert_eq!(Solution1::minimum_moves("OOOO".to_string()), 0);
+    }
+
+    #[test]
+    fn test_missing_rolls() {
+        assert_eq!(Solution2::missing_rolls(vec![3, 2, 4, 3], 4, 2), vec![6, 6]);
+    }
+
+    #[test]
+    fn test_missing_rolls2() {
+        assert_eq!(Solution2::missing_rolls(vec![1, 5, 6], 3, 4), vec![3, 2, 2, 2]);
+    }
+
+    #[test]
+    fn test_missing_rolls3() {
+        assert_eq!(Solution2::missing_rolls(vec![1, 2, 3, 4], 6, 4), vec![]);
+    }
+
+    #[test]
+    fn test_missing_rolls4() {
+        assert_eq!(Solution2::missing_rolls(vec![1], 3, 1), vec![5]);
+    }
+
+    #[test]
+    fn test_missing_rolls5() {
+        assert_eq!(Solution2::missing_rolls(vec![3, 5, 4], 5, 3), vec![6, 6, 6]);
+    }
+
+    #[test]
+    fn test_missing_rolls6() {
+        assert_eq!(Solution2::missing_rolls(vec![3, 5, 3], 5, 3), vec![]);
+    }
+}
diff --git a/src/leetcode/problem/get_number_of_backlog_orders.rs b/src/leetcode/problem/get_number_of_backlog_orders.rs
@@ -0,0 +1,142 @@
+use std::collections::BinaryHeap;
+
+// 1801. Number of Orders in the Backlog, Medium
+// https://leetcode.com/problems/number-of-orders-in-the-backlog/
+impl Solution {
+    pub fn get_number_of_backlog_orders(orders: Vec<Vec<i32>>) -> i32 {
+        #[derive(Eq, Debug, Clone)]
+        struct Order {
+            price: i32,
+            amount: i32,
+            order_type: i32,
+        }
+
+        impl Order {
+            fn new(mut price: i32, amount: i32, order_type: i32) -> Self {
+                if order_type == 1 {
+                    price *= -1;
+                }
+
+                Self { price, amount, order_type }
+            }
+        }
+
+        impl Ord for Order {
+            fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+                self.price.cmp(&other.price)
+            }
+        }
+
+        impl PartialOrd for Order {
+            fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+                Some(self.cmp(other))
+            }
+        }
+
+        impl PartialEq for Order {
+            fn eq(&self, other: &Self) -> bool {
+                self.price == other.price
+            }
+        }
+
+        let base: i32 = 10;
+        let modulo: f64 = (base.pow(9) + 7) as f64;
+
+        let mut buy_backlog: BinaryHeap<Order> = BinaryHeap::new();
+        let mut sell_backlog: BinaryHeap<Order> = BinaryHeap::new();
+
+        for order in orders.iter() {
+            let mut o = Order::new(order[0], order[1], order[2]);
+
+            while o.amount > 0 {
+                if o.order_type == 0 {
+                    if !sell_backlog.is_empty() && sell_backlog.peek().unwrap().price * -1 <= o.price {
+                        let mut sell_order = sell_backlog.pop().unwrap();
+                        let amount = i32::min(sell_order.amount, o.amount);
+                        o.amount -= amount;
+                        sell_order.amount -= amount;
+
+                        if sell_order.amount > 0 {
+                            sell_backlog.push(sell_order);
+                        }
+                    } else {
+                        buy_backlog.push(o.clone());
+                        break;
+                    }
+                } else {
+                    if !buy_backlog.is_empty() && buy_backlog.peek().unwrap().price >= o.price * -1 {
+                        let mut buy_order = buy_backlog.pop().unwrap();
+                        let amount = i32::min(buy_order.amount, o.amount);
+                        o.amount -= amount;
+                        buy_order.amount -= amount;
+
+                        if buy_order.amount > 0 {
+                            buy_backlog.push(buy_order);
+                        }
+                    } else {
+                        sell_backlog.push(o.clone());
+                        break;
+                    }
+                }
+            }
+        }
+
+        ((buy_backlog.iter().map(|order| order.amount as f64).sum::<f64>() + sell_backlog.iter().map(|order| order.amount as f64).sum::<f64>()) % modulo) as i32
+    }
+}
+
+struct Solution {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::vec_vec_i32;
+
+    #[test]
+    fn test_get_number_of_backlog_orders() {
+        assert_eq!(Solution::get_number_of_backlog_orders(vec_vec_i32![[10, 5, 0], [15, 2, 1], [25, 1, 1], [30, 4, 0]]), 6);
+    }
+
+    #[test]
+    fn test_get_number_of_backlog_orders2() {
+        assert_eq!(
+            Solution::get_number_of_backlog_orders(vec_vec_i32![[7, 1000000000, 1], [15, 3, 0], [5, 999999995, 0], [5, 1, 1]]),
+            999999984
+        );
+    }
+
+    #[test]
+    fn test_get_number_of_backlog_orders3() {
+        assert_eq!(Solution::get_number_of_backlog_orders(vec_vec_i32![[19, 28, 0], [9, 4, 1], [25, 15, 1]]), 39);
+    }
+
+    #[test]
+    fn test_get_number_of_backlog_orders4() {
+        assert_eq!(
+            Solution::get_number_of_backlog_orders(vec_vec_i32![
+                [944925198, 885003661, 0],
+                [852263791, 981056352, 0],
+                [16300530, 415829909, 0],
+                [940927944, 713835606, 0],
+                [606389372, 407474168, 1],
+                [139563740, 85382287, 1],
+                [700244880, 901922025, 1],
+                [972900669, 15506445, 0],
+                [576578542, 65339074, 0],
+                [45972021, 293765308, 0],
+                [464403992, 97750995, 0],
+                [29659852, 536508041, 0],
+                [799523481, 299864737, 0],
+                [711908211, 480514887, 1],
+                [354125407, 677598767, 1],
+                [279004011, 688916331, 0],
+                [263524013, 64622178, 0],
+                [375395974, 460070320, 0],
+                [971786816, 379275200, 1],
+                [577774472, 214070125, 1],
+                [987757349, 711231195, 0]
+            ]),
+            83062672
+        );
+    }
+}
diff --git a/src/leetcode/problem/min_stone_sum.rs b/src/leetcode/problem/min_stone_sum.rs
@@ -0,0 +1,35 @@
+use std::collections::BinaryHeap;
+
+// 1962. Remove Stones to Minimize the Total, Medium
+// https://leetcode.com/problems/remove-stones-to-minimize-the-total/
+impl Solution {
+    pub fn min_stone_sum(piles: Vec<i32>, k: i32) -> i32 {
+        let mut heap = BinaryHeap::from(piles);
+
+        for _ in 0..k {
+            let mut t = heap.pop().unwrap_or(0);
+            t -= f32::floor(t as f32 / 2.0) as i32;
+            heap.push(t);
+        }
+
+        heap.iter().sum()
+    }
+}
+
+struct Solution {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::vec_vec_i32;
+
+    #[test]
+    fn test_min_stone_sum() {
+        assert_eq!(Solution::min_stone_sum(vec![5, 4, 9], 2), 12);
+    }
+
+    #[test]
+    fn test_min_stone_sum2() {
+        assert_eq!(Solution::min_stone_sum(vec![4, 3, 6, 7], 3), 12);
+    }
+}
diff --git a/src/leetcode/problem/mod.rs b/src/leetcode/problem/mod.rs
@@ -2,12 +2,14 @@ mod add_operators;
 mod erase_overlap_intervals;
 mod find_min_arrow_shots;
 mod find_poisoned_duration;
+mod get_number_of_backlog_orders;
 mod is_anagram;
 mod is_good_array;
 mod largest_divisible_subset;
 mod max_uncrossed_lines;
 mod min_distance;
 mod min_eating_speed;
+mod min_stone_sum;
 mod num_subarray_product_less_than_k;
 mod pseudo_palindromic_paths;
 mod two_sum;
diff --git a/src/main.rs b/src/main.rs
@@ -53,6 +53,11 @@ fn gen_table() -> Result<()> {
     }
 
     entries.sort();
+    println!("## Solutions ({}) ", entries.len());
+    println!(
+        r#"| No. | Title | Solution | Problem | Difficulty |
+    |:---:|:------|:--------:|:-------:|:----------:|"#
+    );
     for entry in entries {
         println!(
             "| {} | {} | [Rust](https://github.com/martinxxd/leetcode-rust/tree/master/{}) | [Leetcode]({}) | {} |",
