12/7/2020

Author: safrannn

README.md

@@ -24,13 +24,14 @@ leetcode practise solution in rust
 |46|[Permutations](src/_0046_permutations.rs)|
 |49|[Group Anagrams](src/_0049_group_anagrams.rs)|
 |53|[Maximum Subarray](src/_0053_maximum_subarray.rs)|
+|54|[Spiral Matrix](src/_0054_spiral_matrix.rs)|
 |56|[Merge Intervals](src/_0056_merge_intervals.rs)|
 |66|[Plus One](src/_0066_plus_one.rs)|
 |67|[Add Binary](src/_0067_add_binary.rs)|
 |70|[Climbing Stairs](src/_0070_climbing_stairs.rs)|
 |74|[Search a 2D Matrix](src/_0074_search_a_2d_matrix.rs)|
 |78|[Subsets](src/_0078_subsets.rs)|
-|79|[Word Search](src/_0079_word_search)|
+|79|[Word Search](src/_0079_word_search.rs)|
 |83|[Remove Duplicates from Sorted List](src/_0083_remove_duplicates_from_sorted_list.rs)|
 |88|[Merge Sorted Array](src/_0088_merge_sorted_array.rs)|
 |91|[Decode Ways](src/_0091_decode_ways.rs)|
@@ -43,6 +44,7 @@ leetcode practise solution in rust
 |125|[Valid Palindrome](src/_0125_valid_palindrome.rs)|
 |127|[Word Ladder](src/_0127_word_ladder.rs)|
 |136|[Single Number](src/_0136_single_number.rs)|
+|151|[Reverse Words in a String](src/_0151_reverse_words_in_a_string.rs)|
 |155|[Min Stack](src/_0155_min_stack.rs)|
 |167|[Two Sum II - Input array is sorted](src/_0167_two_sum_ii.rs)|
 |169|[Majority Element](src/_0169_majority_element.rs)|

src/_0054_spiral_matrix.rs

@@ -0,0 +1,52 @@
+struct Solution;
+
+impl Solution {
+    pub fn spiral_order(matrix: Vec<Vec<i32>>) -> Vec<i32> {
+        let direction: Vec<(i32, i32)> = vec![(0, 1), (1, 0), (0, -1), (-1, 0)];
+        let mut result = vec![];
+
+        let mut cur_pos = (0, 0);
+        let mut margin: (i32, i32, i32, i32) =
+            (0, matrix.len() as i32 - 1, 0, matrix[0].len() as i32 - 1); // up, bottom, left, right
+        let mut cur_dir: usize = 0;
+        let mut visited = 0;
+
+        while visited < matrix[0].len() * matrix.len() {
+            result.push(matrix[cur_pos.0][cur_pos.1]);
+            visited += 1;
+
+            let next_pos: (i32, i32) = (
+                cur_pos.0 as i32 + direction[cur_dir].0,
+                cur_pos.1 as i32 + direction[cur_dir].1,
+            );
+            if (next_pos.0 < margin.0 || next_pos.0 > margin.1)
+                || (next_pos.1 < margin.2 || next_pos.1 > margin.3)
+            {
+                cur_dir = if cur_dir == 3 { 0 } else { cur_dir + 1 };
+                match cur_dir {
+                    0 => margin.2 += 1,
+                    1 => margin.0 += 1,
+                    2 => margin.3 -= 1,
+                    3 => margin.1 -= 1,
+                    _ => {}
+                }
+            }
+            cur_pos = (
+                (cur_pos.0 as i32 + direction[cur_dir].0) as usize,
+                (cur_pos.1 as i32 + direction[cur_dir].1) as usize,
+            );
+        }
+
+        result
+    }
+}
+
+#[test]
+fn test() {
+    let matrix: Vec<Vec<i32>> = vec_vec_i32![[1, 2, 3], [4, 5, 6], [7, 8, 9]];
+    let res = vec![1, 2, 3, 6, 9, 8, 7, 4, 5];
+    assert_eq!(Solution::spiral_order(matrix), res);
+    let matrix: Vec<Vec<i32>> = vec_vec_i32![[3], [2]];
+    let res = vec![3, 2];
+    assert_eq!(Solution::spiral_order(matrix), res);
+}

src/_0112_path_sum.rs

@@ -0,0 +1,45 @@
+use crate::util::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+struct Solution;
+impl Solution {
+    pub fn has_path_sum(root: Option<Rc<RefCell<TreeNode>>>, sum: i32) -> bool {
+        if root.is_some() {
+            Self::dfs(&root, sum)
+        } else {
+            false
+        }
+    }
+
+    fn dfs(root: &Option<Rc<RefCell<TreeNode>>>, sum: i32) -> bool {
+        if let Some(root) = root {
+            let root = root.borrow();
+            match (&root.left, &root.right) {
+                (None, None) => sum == root.val,
+                (left, right) => {
+                    if (left.is_some() && Self::dfs(left, sum - root.val))
+                        || (right.is_some() && Self::dfs(right, sum - root.val))
+                    {
+                        return true;
+                    } else {
+                        return false;
+                    }
+                }
+            }
+        } else {
+            sum == 0
+        }
+    }
+}
+
+#[test]
+fn test() {
+    let root = tree!(
+        5,
+        tree!(4, tree!(11, tree!(7), tree!(2)), None),
+        tree!(8, tree!(13), tree!(4, None, tree!(1)))
+    );
+    assert_eq!(Solution::has_path_sum(root, 22), true);
+    assert_eq!(Solution::has_path_sum(tree!(1, tree!(2), None), 1), false);
+}

src/_0151_reverse_words_in_a_string.rs

@@ -0,0 +1,34 @@
+struct Solution;
+impl Solution {
+    pub fn reverse_words(s: String) -> String {
+        s.trim();
+        let mut words: Vec<&str> = s.split_whitespace().collect();
+        words.reverse();
+        let result = words.join(" ");
+        result
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::reverse_words("the sky is blue".to_string()),
+        "blue is sky the".to_string()
+    );
+    assert_eq!(
+        Solution::reverse_words("  hello world  ".to_string()),
+        "world hello".to_string()
+    );
+    assert_eq!(
+        Solution::reverse_words("a good   example".to_string()),
+        "example good a".to_string()
+    );
+    assert_eq!(
+        Solution::reverse_words("  Bob    Loves  Alice   ".to_string()),
+        "Alice Loves Bob".to_string()
+    );
+    assert_eq!(
+        Solution::reverse_words("Alice does not even like bob".to_string()),
+        "bob like even not does Alice".to_string()
+    );
+}

src/_1679_max_number_of_k-sum_pairs.rs renamed to src/_1679_max_number_of_ksum_pairs.rs

@@ -22,6 +22,6 @@ impl Solution {
 
 #[test]
 fn test() {
-    assert_eq!(Solution::max_operations(vec![1, 2, 3, 4], 2), 5);
+    assert_eq!(Solution::max_operations(vec![1, 2, 3, 4], 5), 2);
     assert_eq!(Solution::max_operations(vec![3, 1, 3, 4, 3], 6), 1);
 }

src/_1680_concatenation_of_consecutive_binary_numbers.rs

@@ -1,29 +1,29 @@
-struct Solution;
+// struct Solution;
 
-impl Solution {
-    pub fn concatenated_binary(n: i32) -> i32 {
-        let mut result: usize = 0;
-        for i in 1..=n as usize {
-            result <<= Self::binary_digits(i);
-            result += i;
-            result %= 1_000_000_007;
-        }
-        result as i32
-    }
+// impl Solution {
+//     pub fn concatenated_binary(n: i32) -> i32 {
+//         let mut result: usize = 0;
+//         for i in 1..=n as usize {
+//             result <<= Self::binary_digits(i);
+//             result += i;
+//             result %= 1_000_000_007;
+//         }
+//         result as i32
+//     }
 
-    fn binary_digits(mut decimal: usize) -> usize {
-        let mut bits = 0;
-        while decimal > 0 {
-            bits += 1;
-            decimal >> 1;
-        }
-        bits
-    }
-}
+//     fn binary_digits(mut decimal: usize) -> usize {
+//         let mut bits = 0;
+//         while decimal > 0 {
+//             bits += 1;
+//             decimal >> 1;
+//         }
+//         bits
+//     }
+// }
 
-#[test]
-fn test() {
-    assert_eq!(Solution::concatenated_binary(1), 1);
-    assert_eq!(Solution::concatenated_binary(3), 3);
-    assert_eq!(Solution::concatenated_binary(12), 505379714);
-}
+// #[test]
+// fn test() {
+//     assert_eq!(Solution::concatenated_binary(1), 1);
+//     assert_eq!(Solution::concatenated_binary(3), 3);
+//     assert_eq!(Solution::concatenated_binary(12), 505379714);
+// }

src/lib.rs

@@ -48,6 +48,8 @@ mod _0049_group_anagrams;
 //
 mod _0053_maximum_subarray;
 //
+mod _0054_spiral_matrix;
+//
 mod _0056_merge_intervals;
 //
 mod _0066_plus_one;
@@ -76,6 +78,8 @@ mod _0104_maximum_depth_of_binary_tree;
 //
 mod _0110_balanced_binary_tree;
 //
+mod _0112_path_sum;
+//
 mod _0121_best_time_to_buy_and_sell_stock;
 //
 mod _0122_best_time_to_buy_and_sell_stock_ii;
@@ -86,6 +90,8 @@ mod _0127_word_ladder;
 //
 mod _0136_single_number;
 //
+mod _0151_reverse_words_in_a_string;
+//
 mod _0155_min_stack;
 //
 mod _0167_two_sum_ii;
@@ -312,7 +318,6 @@ mod _1608_special_array_with_x_elements_greater_than_or_equal_x;
 //
 mod _1609_even_odd_tree;
 //
-mod test;
-
+mod _1679_max_number_of_ksum_pairs;
 //
-mod temp1;
+mod _1680_concatenation_of_consecutive_binary_numbers;