More solutions

leopsidom · leopsidom · commit 9b3cdbf34815 · 2020-01-22T22:00:38.000-08:00
diff --git a/264.ugly-number-ii.rs b/264.ugly-number-ii.rs
@@ -7,8 +7,26 @@
 // @lc code=start
 impl Solution {
     pub fn nth_ugly_number(n: i32) -> i32 {
-        
+        if n <= 0 { return -1; }
+        let mut ugly_numbers = vec![1; n as usize];
+        let mut i2 = 0;
+        let mut i3 = 0;
+        let mut i5 = 0;
+
+        for i in 1..n as usize {
+            ugly_numbers[i] = *[
+                ugly_numbers[i2] * 2,
+                ugly_numbers[i3] * 3,
+                ugly_numbers[i5] * 5
+                ].iter().min().unwrap();
+            
+            if ugly_numbers[i] == ugly_numbers[i2] * 2 { i2 += 1; }
+            if ugly_numbers[i] == ugly_numbers[i3] * 3 { i3 += 1; }
+            if ugly_numbers[i] == ugly_numbers[i5] * 5 { i5 += 1; }
+        }
+
+        ugly_numbers[n as usize - 1]
     }
 }
 // @lc code=end
-
+
diff --git a/279.perfect-squares.rs b/279.perfect-squares.rs
@@ -0,0 +1,14 @@
+/*
+ * @lc app=leetcode id=279 lang=rust
+ *
+ * [279] Perfect Squares
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn num_squares(n: i32) -> i32 {
+        
+    }
+}
+// @lc code=end
+
diff --git a/599.minimum-index-sum-of-two-lists.rs b/599.minimum-index-sum-of-two-lists.rs
@@ -0,0 +1,35 @@
+/*
+ * @lc app=leetcode id=599 lang=rust
+ *
+ * [599] Minimum Index Sum of Two Lists
+ */
+
+// @lc code=start
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn find_restaurant(list1: Vec<String>, list2: Vec<String>) -> Vec<String> {
+        let mut str_2_idx = HashMap::new();
+
+        for (i, s) in list1.into_iter().enumerate() {
+            if !str_2_idx.contains_key(&s) {
+                str_2_idx.insert(s, i);
+            }
+        }
+
+        let mut ans = HashMap::new();
+
+        for (i, s) in list2.into_iter().enumerate() {
+            match str_2_idx.get(&s) {
+                Some(j) => {
+                    ans.entry(i + *j).or_insert(vec![]).push(s);
+                },
+                None => ()
+            }
+        }
+
+        ans.get(ans.keys().min().unwrap()).unwrap().to_vec()
+    }
+}
+// @lc code=end
+
diff --git a/606.construct-string-from-binary-tree.rs b/606.construct-string-from-binary-tree.rs
@@ -0,0 +1,58 @@
+/*
+ * @lc app=leetcode id=606 lang=rust
+ *
+ * [606] Construct String from Binary Tree
+ */
+
+// @lc code=start
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+// 
+// impl TreeNode {
+//   #[inline]
+//   pub fn new(val: i32) -> Self {
+//     TreeNode {
+//       val,
+//       left: None,
+//       right: None
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn tree2str(t: Option<Rc<RefCell<TreeNode>>>) -> String {
+        match t {
+            None => "".to_owned(),
+            Some(rc_node) => {
+                let tree_node = rc_node.borrow();
+                let left = Self::tree2str(tree_node.left.clone());
+                let right = Self::tree2str(tree_node.right.clone());
+
+                let mut ans = String::new();
+                ans.push_str(&tree_node.val.to_string());
+
+                if left != "" || right != "" {
+                    ans.push('(');
+                    ans.push_str(&left);
+                    ans.push(')');
+                }
+
+                if right != "" {
+                    ans.push('(');
+                    ans.push_str(&right);
+                    ans.push(')');
+                }
+
+                ans
+            }
+        }
+    }
+}
+// @lc code=end
+
diff --git a/617.merge-two-binary-trees.rs b/617.merge-two-binary-trees.rs
@@ -0,0 +1,48 @@
+/*
+ * @lc app=leetcode id=617 lang=rust
+ *
+ * [617] Merge Two Binary Trees
+ */
+
+// @lc code=start
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+// 
+// impl TreeNode {
+//   #[inline]
+//   pub fn new(val: i32) -> Self {
+//     TreeNode {
+//       val,
+//       left: None,
+//       right: None
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn merge_trees(t1: Option<Rc<RefCell<TreeNode>>>, t2: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
+        match (t1, t2) {
+            (Some(rn1), Some(rn2)) => {
+                let tn1 = rn1.borrow();
+                let tn2 = rn2.borrow();
+
+                let mut tn = TreeNode::new(tn1.val + tn2.val);
+                tn.left = Self::merge_trees(tn1.left.clone(), tn2.left.clone());
+                tn.right = Self::merge_trees(tn1.right.clone(), tn2.right.clone());
+
+                Some(Rc::new(RefCell::new(tn)))
+            },
+            (Some(rn1), None) => Some(rn1.clone()),
+            (None, Some(rn2)) => Some(rn2.clone()),
+            (None, None) => None,
+        }
+    }
+}
+// @lc code=end
+
