Add more solutions

Author: martwz

README.md

@@ -0,0 +1,23 @@
+use std::collections::HashMap;
+
+// 387. First Unique Character in a String, Easy
+// https://leetcode.com/problems/first-unique-character-in-a-string/
+impl Solution {
+    pub fn first_uniq_char(s: String) -> i32 {
+        let mut map = HashMap::<char, i32>::new();
+
+        for char in s.chars() {
+            map.entry(char).and_modify(|f| *f += 1).or_insert(1);
+        }
+
+        for (i, char) in s.chars().enumerate() {
+            if *map.get(&char).unwrap() == 1 {
+                return i as i32;
+            }
+        }
+
+        -1
+    }
+}
+
+struct Solution {}

src/leetcode/interview/amazon/first_uniq_char.rs

@@ -0,0 +1,16 @@
+// 33. Search in Rotated Sorted Array, Medium
+// https://leetcode.com/problems/search-in-rotated-sorted-array/
+impl Solution {
+    pub fn search(nums: Vec<i32>, target: i32) -> i32 {
+        let mut nums = nums.iter().enumerate().map(|(i, n)| (*n, i)).collect::<Vec<(i32, usize)>>();
+        nums.sort_unstable();
+
+        let i = nums.binary_search_by(|p| p.0.cmp(&target));
+        match i {
+            Ok(i) => return nums[i].1 as i32,
+            Err(_) => return -1,
+        }
+    }
+}
+
+struct Solution {}

src/leetcode/interview/amazon/search.rs

@@ -0,0 +1,43 @@
+// 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::cell::RefCell;
+use std::rc::Rc;
+
+// 1315. Sum of Nodes with Even-Valued Grandparent, Medium
+// https://leetcode.com/problems/sum-of-nodes-with-even-valued-grandparent/
+impl Solution {
+    pub fn sum_even_grandparent(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+        fn bfs(node: Option<Rc<RefCell<TreeNode>>>, parent_val: i32, grand_parent_val: i32, ans: &mut i32) {
+            if node.is_some() {
+                let node = node.as_ref().unwrap().borrow();
+
+                if grand_parent_val != -1 && grand_parent_val % 2 == 0 {
+                    *ans += node.val;
+                }
+
+                bfs(node.left.clone(), node.val, parent_val, ans);
+                bfs(node.left.clone(), node.val, parent_val, ans);
+            }
+        }
+
+        let mut ans = 0;
+
+        bfs(root, -1, -1, &mut ans);
+        ans
+    }
+}
+
+struct Solution {}

src/leetcode/interview/amazon/sum_even_grandparent.rs

@@ -0,0 +1,45 @@
+// 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::cell::RefCell;
+use std::rc::Rc;
+
+// 543. Diameter of Binary Tree, Easy
+// https://leetcode.com/problems/diameter-of-binary-tree/
+impl Solution {
+    pub fn diameter_of_binary_tree(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+        fn bfs(node: Option<Rc<RefCell<TreeNode>>>, max_path_length: &mut i32) -> i32 {
+            if node.is_none() {
+                return 0;
+            }
+            let node = node.as_ref().unwrap().borrow();
+
+            let path_left = bfs(node.left.clone(), max_path_length);
+            let path_right = bfs(node.right.clone(), max_path_length);
+
+            let path_length = 1 + path_left + path_right;
+            *max_path_length = i32::max(*max_path_length, path_length);
+
+            return 1 + i32::max(path_left, path_right);
+        }
+
+        let mut max_path_length = 0;
+        bfs(root, &mut max_path_length);
+
+        max_path_length - 1
+    }
+}
+
+struct Solution {}

src/leetcode/problem/diameter_of_binary_tree.rs

@@ -0,0 +1,26 @@
+// 34. Find First and Last Position of Element in Sorted Array, Medium
+// https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/
+impl Solution {
+    pub fn search_range(nums: Vec<i32>, target: i32) -> Vec<i32> {
+        let mut ans = vec![];
+
+        match nums.binary_search(&target) {
+            Ok(pos) => {
+                let mut i = pos;
+                let mut j = pos;
+                while i > 0 && nums[i] == target {
+                    i -= 1;
+                }
+                while j < nums.len() - 1 && nums[i] == target {
+                    j += 1;
+                }
+                ans.append(&mut vec![i as i32 + 1, j as i32 - 1]);
+            }
+            Err(_) => ans.append(&mut vec![-1, -1]),
+        }
+
+        ans
+    }
+}
+
+struct Solution {}

src/leetcode/problem/find-first-and-last-position-of-element-in-sorted-array.rs

@@ -0,0 +1,38 @@
+use std::collections::HashMap;
+
+// 1481. Least Number of Unique Integers after K Removals, Medium
+// https://leetcode.com/problems/least-number-of-unique-integers-after-k-removals/
+impl Solution {
+    pub fn find_least_num_of_unique_ints(arr: Vec<i32>, k: i32) -> i32 {
+        let mut dict = HashMap::<i32, i32>::new();
+
+        for num in arr.iter() {
+            dict.entry(*num).and_modify(|n| *n += 1).or_insert(1);
+        }
+
+        let mut list = dict.keys().map(|k| (*k, dict[k])).collect::<Vec<(i32, i32)>>();
+        list.sort_unstable_by(|a, b| a.1.cmp(&b.1));
+
+        let mut k = k;
+        let mut i = 0;
+        let mut num_uniques = list.len();
+
+        while k > 0 {
+            let can_rm = i32::min(k, list[i].1);
+
+            if list[i].1 - can_rm == 0 {
+                num_uniques -= 1;
+                i += 1;
+                k -= can_rm;
+            } else {
+                k -= can_rm;
+            }
+        }
+
+        // let list =
+
+        num_uniques as i32
+    }
+}
+
+struct Solution {}

src/leetcode/problem/find_least_num_of_unique_ints.rs

@@ -0,0 +1,20 @@
+use std::cmp::Ordering;
+
+// 973. K Closest Points to Origin, Medium
+// https://leetcode.com/problems/k-closest-points-to-origin/
+impl Solution {
+    pub fn k_closest(points: Vec<Vec<i32>>, k: i32) -> Vec<Vec<i32>> {
+        let mut enhanced_points = points
+            .iter()
+            .map(|n| {
+                let dist = f64::sqrt(f64::powi(n[0] as f64, 2) + f64::powi(n[1] as f64, 2));
+                (n[0], n[1], dist)
+            })
+            .collect::<Vec<(i32, i32, f64)>>();
+        enhanced_points.sort_unstable_by(|a, b| a.2.partial_cmp(&b.2).unwrap_or(Ordering::Equal));
+
+        enhanced_points.iter().take(k as usize).map(|n| vec![n.0, n.1]).collect()
+    }
+}
+
+struct Solution {}

src/leetcode/problem/k_closest.rs

@@ -0,0 +1,42 @@
+// 56. Merge Intervals, Medium
+// https://leetcode.com/problems/merge-intervals/
+impl Solution {
+    pub fn merge(intervals: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
+        let mut intervals = intervals;
+        intervals.sort_unstable_by(|a, b| a[0].cmp(&b[0]));
+        let mut ans: Vec<Vec<i32>> = vec![];
+
+        for interval in intervals.iter_mut() {
+            if ans.len() == 0 {
+                ans.push(interval.clone());
+            } else {
+                if interval[0] >= ans.last().unwrap()[0] && interval[1] <= ans.last().unwrap()[1] {
+                    continue;
+                } else if interval[0] <= ans.last().unwrap()[1] {
+                    ans.last_mut().unwrap()[1] = interval[1];
+                } else {
+                    ans.push(interval.clone());
+                }
+            }
+        }
+
+        ans
+    }
+}
+
+struct Solution {}
+
+mod tests {
+    use super::*;
+    use crate::{vec_string, vec_vec_i32};
+
+    #[test]
+    fn test_merge() {
+        assert_eq!(Solution::merge(vec_vec_i32![[1, 3], [2, 6], [8, 10], [15, 18]]), vec_vec_i32![[1, 6], [8, 10], [15, 18]]);
+    }
+
+    #[test]
+    fn test_merge2() {
+        assert_eq!(Solution::merge(vec_vec_i32![[1, 4], [4, 5]]), vec_vec_i32![[1, 5]]);
+    }
+}

src/leetcode/problem/merge.rs

@@ -0,0 +1,40 @@
+// 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::cell::RefCell;
+use std::rc::Rc;
+
+// 337. House Robber III, Medium
+// https://leetcode.com/problems/house-robber-iii/
+impl Solution {
+    pub fn rob(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+        fn bfs(node: Option<Rc<RefCell<TreeNode>>>) -> (i32, i32) {
+            if node.is_some() {
+                let node = node.as_ref().unwrap().borrow();
+
+                let l = bfs(node.left.clone());
+                let r = bfs(node.left.clone());
+
+                (node.val + l.1 + r.1, i32::max(l.0, l.1) + i32::max(r.0, r.1))
+            } else {
+                (0, 0)
+            }
+        }
+
+        i32::max(bfs(root.clone()).0, bfs(root.clone()).1)
+    }
+}
+
+struct Solution {}

src/leetcode/problem/rob.rs

@@ -0,0 +1,24 @@
+// 901. Online Stock Span, Medium
+// https://leetcode.com/problems/online-stock-span/
+impl StockSpanner {
+    fn new() -> Self {
+        StockSpanner { prices: vec![] }
+    }
+
+    fn next(&mut self, price: i32) -> i32 {
+        self.prices.push(price);
+
+        let mut i = 0;
+        for d in (0..self.prices.len()).rev() {
+            if self.prices[d] <= price {
+                i += 1;
+            }
+        }
+
+        i
+    }
+}
+
+struct StockSpanner {
+    prices: Vec<i32>,
+}

src/leetcode/problem/stock_span.rs

@@ -0,0 +1,44 @@
+use std::collections::VecDeque;
+
+// 42. Trapping Rain Water, Hard
+// https://leetcode.com/problems/trapping-rain-water/
+impl Solution {
+    pub fn trap(height: Vec<i32>) -> i32 {
+        let mut ans = 0;
+        let mut q = VecDeque::<usize>::new();
+        
+        for (i, h) in height.iter().enumerate() {
+            while q.len() > 0 && height[*q.back().unwrap()] < *h {
+                let top = q.pop_back().unwrap();
+                if q.len() == 0 {
+                    break;
+                }
+
+                let dist = i - q.back().unwrap() - 1;
+                let bounded_height = i32::min(*h, height[*q.back().unwrap()]) - height[top];
+                ans += dist as i32 * bounded_height;
+            }
+
+            q.push_back(i);
+        }
+
+        ans
+    }
+}
+
+struct Solution {}
+
+mod tests {
+    use super::*;
+    use crate::{vec_string, vec_vec_i32};
+
+    #[test]
+    fn test_trap() {
+        assert_eq!(Solution::trap(vec![0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1]), 6);
+    }
+
+    #[test]
+    fn test_trap2() {
+        assert_eq!(Solution::trap(vec![4, 2, 0, 3, 2, 5]), 9);
+    }
+}