first few solutions

Author: leopsidom

1.two-sum.rs

@@ -0,0 +1,28 @@
+/*
+ * @lc app=leetcode id=1 lang=rust
+ *
+ * [1] Two Sum
+ */
+
+// @lc code=start
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
+        let size = nums.len();
+        let mut indices = HashMap::new();
+
+        for i in 0..size {
+            let val = nums.get(i).unwrap();
+            if (indices.contains_key(&(target - val))) {
+                let j = indices.get(&(target - val)).unwrap();
+                return vec![*j as i32, i as i32];
+            }
+            indices.insert(val, i);
+        }
+
+        return vec![0, 0];
+    }
+}
+// @lc code=end
+

100.same-tree.rs

@@ -0,0 +1,34 @@
+/*
+ * @lc app=leetcode id=100 lang=rust
+ *
+ * [100] Same 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 is_same_tree(p: Option<Rc<RefCell<TreeNode>>>, q: Option<Rc<RefCell<TreeNode>>>) -> bool {
+        
+    }
+}
+// @lc code=end
+

109.convert-sorted-list-to-binary-search-tree.rs

@@ -0,0 +1,50 @@
+/*
+ * @lc app=leetcode id=109 lang=rust
+ *
+ * [109] Convert Sorted List to Binary Search Tree
+ */
+
+// @lc code=start
+// Definition for singly-linked list.
+// #[derive(PartialEq, Eq, Clone, Debug)]
+// pub struct ListNode {
+//   pub val: i32,
+//   pub next: Option<Box<ListNode>>
+// }
+// 
+// impl ListNode {
+//   #[inline]
+//   fn new(val: i32) -> Self {
+//     ListNode {
+//       next: None,
+//       val
+//     }
+//   }
+// }
+// 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 sorted_list_to_bst(head: Option<Box<ListNode>>) -> Option<Rc<RefCell<TreeNode>>> {
+        
+    }
+}
+// @lc code=end
+

11.container-with-most-water.rs

@@ -0,0 +1,35 @@
+/*
+ * @lc app=leetcode id=11 lang=rust
+ *
+ * [11] Container With Most Water
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn max_area(height: Vec<i32>) -> i32 {
+        let mut left = 0;
+        let mut right = height.len() - 1;
+        let mut ans = 0;
+
+        while left < right {
+            if height[left] < height[right] {
+                let area = (right - left) as i32 * height[left];
+                if (ans < area) {
+                    ans = area;
+                }
+                left += 1;
+            }
+            else {
+                let area = (right - left) as i32 * height[right];
+                if (ans < area) {
+                    ans = area;
+                }
+                right -= 1;
+            }
+        }
+
+        ans
+    }
+}
+// @lc code=end
+

136.single-number.rs

@@ -0,0 +1,20 @@
+/*
+ * @lc app=leetcode id=136 lang=rust
+ *
+ * [136] Single Number
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn single_number(nums: Vec<i32>) -> i32 {
+        let mut ans = 0;
+
+        for num in nums {
+            ans ^= num;
+        }
+
+        ans
+    }
+}
+// @lc code=end
+

141.linked-list-cycle.rs

@@ -0,0 +1,89 @@
+/*
+ * @lc app=leetcode id=143 lang=rust
+ *
+ * [143] Reorder List
+ */
+
+// @lc code=start
+// Definition for singly-linked list.
+// #[derive(PartialEq, Eq, Clone, Debug)]
+// pub struct ListNode {
+//   pub val: i32,
+//   pub next: Option<Box<ListNode>>
+// }
+// 
+// impl ListNode {
+//   #[inline]
+//   fn new(val: i32) -> Self {
+//     ListNode {
+//       next: None,
+//       val
+//     }
+//   }
+// }
+use std::mem;
+
+impl Solution {
+    pub fn reorder_list(mut head: &mut Option<Box<ListNode>>) {
+        
+        let mut href = head.as_ref();
+        let mut N = 0;
+
+        while let Some(node) = href.take() {
+            href = node.next.as_ref();
+            N += 1;
+        }
+
+        let mut hmut = head.as_mut();
+        let mut cnt = 1;
+
+        while cnt < (N + 1) / 2 {
+            if let Some(node) = hmut.take() {
+                hmut = node.next.as_mut();
+                cnt += 1;
+            } else {
+                break;
+            }
+        }
+
+        match hmut.take() {
+            None => (),
+            Some(node) => {
+                let tail = Self::reverse(node.next.take());
+                if let Some(node) = head {
+                    node.next = Self::merge_two_lists(tail, node.next.take());
+                }
+            }
+        }
+
+    }
+
+    pub fn merge_two_lists(mut l1: Option<Box<ListNode>>, mut l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        
+        match (l1.as_mut(), l2.as_mut()) {
+            (None, None) => None,
+            (Some(node1), None) => l1,
+            (None, Some(node2)) => l2,
+            (Some(node1), Some(node2)) => {
+                node1.next = Self::merge_two_lists(l2, node1.next.take());
+                l1
+            }
+        }
+    }
+
+    pub fn reverse(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+
+        let mut prev = None;
+        let mut curr = head;
+
+        while let Some(mut curr_inner) = curr.take() {
+            curr = curr_inner.next.take();
+            curr_inner.next = prev.take();
+            prev = Some(curr_inner);
+        }
+
+        prev
+    }
+}
+// @lc code=end
+

143.reorder-list.rs

@@ -0,0 +1,55 @@
+/*
+ * @lc app=leetcode id=15 lang=rust
+ *
+ * [15] 3Sum
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn three_sum(mut nums: Vec<i32>) -> Vec<Vec<i32>> {
+        nums.sort();
+
+        let n = nums.len();
+        let mut ans: Vec<Vec<i32>> = vec![];
+        if (n < 3) {
+            return ans;
+        }
+
+        let mut i = 0;
+        let mut j = 1;
+        let mut k = n-1;
+
+        while i <= n - 2 {
+            j = i + 1;
+            k = n - 1;
+
+            while j < k {
+                if nums[i] + nums[j] + nums[k] < 0 {
+                    j += 1;
+                } else if nums[i] + nums[j] + nums[k] > 0 {
+                    k -= 1;
+                } else {
+                    ans.push(vec![nums[i], nums[j], nums[k]]);
+                    while j < k && nums[j] == nums[j+1] {
+                        j += 1;
+                    }
+                    j += 1;
+                    while j < k && nums[k-1] == nums[k] {
+                        k -= 1;
+                    }
+                    k -= 1;
+                }
+
+            }
+
+            while i <= n - 2 && nums[i] == nums[i+1] {
+                i += 1;
+            }
+            i += 1;
+        }
+
+        ans
+    }
+}
+// @lc code=end
+

15.3-sum.rs

@@ -0,0 +1,52 @@
+/*
+ * @lc app=leetcode id=16 lang=rust
+ *
+ * [16] 3Sum Closest
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn three_sum_closest(mut nums: Vec<i32>, target: i32) -> i32 {
+        let N = nums.len();
+
+        nums.sort();
+
+        let mut ans = 0;
+        for i in 0..3 {
+            ans += nums[i];
+        }
+        
+        let mut i = 0;
+        let mut j = 1;
+        let mut k = N - 1;
+
+        while i < N - 2 {
+            j = i + 1;
+            k = N - 1;
+
+            while j < k {
+                let sum = nums[i] + nums[j] + nums[k];
+                if ((sum - target).abs() < (ans - target).abs()) {
+                    ans = sum;
+                }
+                if (sum < target) {
+                    j += 1;
+                } else if (sum > target) {
+                    k -= 1;
+                } else {
+                    return sum;
+                }
+            }
+
+            while i < N - 2 && nums[i] == nums[i+1] {
+                i += 1;
+            }
+
+            i += 1;
+        }
+
+        ans
+    }
+}
+// @lc code=end
+