Solve #241

Author: aylei

src/lib.rs

@@ -203,3 +203,4 @@ mod n0232_implement_queue_using_stacks;
 mod n0233_number_of_digit_one;
 mod n0238_product_of_array_except_self;
 mod n0239_sliding_window_maximum;
+mod n0241_different_ways_to_add_parentheses;

src/n0106_construct_binary_tree_from_inorder_and_postorder_traversal.rs

@@ -2,46 +2,54 @@
  * [106] Construct Binary Tree from Inorder and Postorder Traversal
  *
  * Given inorder and postorder traversal of a tree, construct the binary tree.
- * 
+ *
  * Note:<br />
  * You may assume that duplicates do not exist in the tree.
- * 
+ *
  * For example, given
- * 
- * 
+ *
+ *
  * inorder = [9,3,15,20,7]
  * postorder = [9,15,7,20,3]
- * 
+ *
  * Return the following binary tree:
- * 
- * 
+ *
+ *
  *     3
  *    / \
  *   9  20
  *     /  \
  *    15   7
- * 
- * 
+ *
+ *
  */
 pub struct Solution {}
-use super::util::tree::{TreeNode, to_tree};
+use super::util::tree::{to_tree, TreeNode};
 
 // submission codes start here
 
-use std::rc::Rc;
 use std::cell::RefCell;
+use std::rc::Rc;
 impl Solution {
     pub fn build_tree(inorder: Vec<i32>, postorder: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
-        Solution::build_tree_helper(&postorder[..], &inorder[..], )
+        Solution::build_tree_helper(&postorder[..], &inorder[..])
     }
 
     fn build_tree_helper(postorder: &[i32], inorder: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
-        if postorder.is_empty() { return None }
-        let root_idx = inorder.iter().position(|v| v == postorder.last().unwrap()).unwrap();
-        Some(Rc::new(RefCell::new(TreeNode{
+        if postorder.is_empty() {
+            return None;
+        }
+        let root_idx = inorder
+            .iter()
+            .position(|v| v == postorder.last().unwrap())
+            .unwrap();
+        Some(Rc::new(RefCell::new(TreeNode {
             val: *postorder.last().unwrap(),
             left: Solution::build_tree_helper(&postorder[0..root_idx], &inorder[0..root_idx]),
-            right: Solution::build_tree_helper(&postorder[root_idx..postorder.len()-1], &inorder[root_idx+1..]),
+            right: Solution::build_tree_helper(
+                &postorder[root_idx..postorder.len() - 1],
+                &inorder[root_idx + 1..],
+            ),
         })))
     }
 }
@@ -54,8 +62,14 @@ mod tests {
 
     #[test]
     fn test_106() {
-        assert_eq!(Solution::build_tree(vec![9,3,15,20,7], vec![9,15,7,20,3]), tree![3,9,20,null,null,15,7]);
-        assert_eq!(Solution::build_tree(vec![3,20,7], vec![7,20,3]), tree![3,null,20,null,7]);
+        assert_eq!(
+            Solution::build_tree(vec![9, 3, 15, 20, 7], vec![9, 15, 7, 20, 3]),
+            tree![3, 9, 20, null, null, 15, 7]
+        );
+        assert_eq!(
+            Solution::build_tree(vec![3, 20, 7], vec![7, 20, 3]),
+            tree![3, null, 20, null, 7]
+        );
         assert_eq!(Solution::build_tree(vec![], vec![]), tree![]);
     }
 }

src/n0241_different_ways_to_add_parentheses.rs

@@ -0,0 +1,73 @@
+/**
+ * [241] Different Ways to Add Parentheses
+ *
+ * Given a string of numbers and operators, return all possible results from computing all the different possible ways to group numbers and operators. The valid operators are +, - and *.
+ *
+ * Example 1:
+ *
+ *
+ * Input: "2-1-1"
+ * Output: [0, 2]
+ * Explanation:
+ * ((2-1)-1) = 0
+ * (2-(1-1)) = 2
+ *
+ * Example 2:
+ *
+ *
+ * Input: "2*3-4*5"
+ * Output: [-34, -14, -10, -10, 10]
+ * Explanation:
+ * (2*(3-(4*5))) = -34
+ * ((2*3)-(4*5)) = -14
+ * ((2*(3-4))*5) = -10
+ * (2*((3-4)*5)) = -10
+ * (((2*3)-4)*5) = 10
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn diff_ways_to_compute(input: String) -> Vec<i32> {
+        Solution::helper(&input)
+    }
+
+    pub fn helper(input: &str) -> Vec<i32> {
+        if input.is_empty() { return vec![] }
+        if let Ok(digit) = input.parse::<i32>() {
+            return vec![digit]
+        }
+        let mut res: Vec<i32> = Vec::new();
+        for (i, ch) in input.chars().enumerate() {
+            if ch == '+' || ch == '-' || ch == '*' {
+                let left = Solution::helper(&input[..i]);
+                let right = Solution::helper(&input[i+1..]);
+                for &a in left.iter() {
+                    for &b in right.iter() {
+                        res.push(match ch {
+                            '+' => a + b,
+                            '-' => a - b,
+                            '*' => a * b,
+                            _ => unreachable!(),
+                        })
+                    }
+                }
+            }
+        }
+        res
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_241() {
+        assert_eq!(Solution::diff_ways_to_compute("2*3-4*5".to_owned()), vec![-34, -10, -14, -10, 10]);
+    }
+}