Added tasks 155-221

Author: ThanhNIT

README.md

@@ -0,0 +1,77 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Stack #Design
+// #Data_Structure_II_Day_14_Stack_Queue #Programming_Skills_II_Day_18 #Level_2_Day_16_Design
+// #Udemy_Design #Big_O_Time_O(1)_Space_O(N) #2024_09_10_Time_0_ms_(100.00%)_Space_5.9_MB_(71.62%)
+
+pub struct MinStack {
+    current_node: Option<Box<Node>>,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+struct Node {
+    min: i32,
+    data: i32,
+    next_node: Option<Box<Node>>,
+    previous_node: Option<Box<Node>>,
+}
+
+impl Node {
+    fn new(min: i32, data: i32, previous_node: Option<Box<Node>>, next_node: Option<Box<Node>>) -> Self {
+        Node {
+            min,
+            data,
+            next_node,
+            previous_node,
+        }
+    }
+}
+
+impl MinStack {
+    pub fn new() -> Self {
+        MinStack { current_node: None }
+    }
+
+    pub fn push(&mut self, val: i32) {
+        match &self.current_node {
+            None => {
+                self.current_node = Some(Box::new(Node::new(val, val, None, None)));
+            }
+            Some(current) => {
+                let min = std::cmp::min(current.min, val);
+                let previous_node = self.current_node.take();
+                self.current_node = Some(Box::new(Node::new(min, val, previous_node, None)));
+            }
+        }
+    }
+
+    pub fn pop(&mut self) {
+        if let Some(current) = self.current_node.take() {
+            self.current_node = current.previous_node;
+        }
+    }
+
+    pub fn top(&self) -> i32 {
+        if let Some(current) = &self.current_node {
+            return current.data;
+        }
+        panic!("Stack is empty!");
+    }
+
+    pub fn get_min(&self) -> i32 {
+        if let Some(current) = &self.current_node {
+            return current.min;
+        }
+        panic!("Stack is empty!");
+    }
+}
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * let obj = MinStack::new();
+ * obj.push(val);
+ * obj.pop();
+ * let ret_3: i32 = obj.top();
+ * let ret_4: i32 = obj.get_min();
+ */

src/main/rust/g0101_0200/s0155_min_stack/MinStack.rs

@@ -0,0 +1,39 @@
+155\. Min Stack
+
+Easy
+
+Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
+
+Implement the `MinStack` class:
+
+*   `MinStack()` initializes the stack object.
+*   `void push(int val)` pushes the element `val` onto the stack.
+*   `void pop()` removes the element on the top of the stack.
+*   `int top()` gets the top element of the stack.
+*   `int getMin()` retrieves the minimum element in the stack.
+
+**Example 1:**
+
+**Input**
+
+    ["MinStack","push","push","push","getMin","pop","top","getMin"]
+    [[],[-2],[0],[-3],[],[],[],[]]
+
+**Output:** [null,null,null,null,-3,null,0,-2]
+
+**Explanation:**
+
+    MinStack minStack = new MinStack();
+    minStack.push(-2);
+    minStack.push(0);
+    minStack.push(-3);
+    minStack.getMin(); // return -3
+    minStack.pop();
+    minStack.top(); // return 0
+    minStack.getMin(); // return -2 
+
+**Constraints:**
+
+*   <code>-2<sup>31</sup> <= val <= 2<sup>31</sup> - 1</code>
+*   Methods `pop`, `top` and `getMin` operations will always be called on **non-empty** stacks.
+*   At most <code>3 * 10<sup>4</sup></code> calls will be made to `push`, `pop`, `top`, and `getMin`.

src/main/rust/g0101_0200/s0155_min_stack/readme.md

@@ -0,0 +1,37 @@
+// #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Array #Hash_Table #Sorting #Counting
+// #Divide_and_Conquer #Data_Structure_II_Day_1_Array #Udemy_Famous_Algorithm
+// #Big_O_Time_O(n)_Space_O(1) #2024_09_10_Time_1_ms_(82.64%)_Space_2.5_MB_(18.91%)
+
+impl Solution {
+    pub fn majority_element(arr: Vec<i32>) -> i32 {
+        let mut count = 1;
+        let mut majority = arr[0];
+
+        // For Potential Majority Element
+        for &num in arr.iter().skip(1) {
+            if num == majority {
+                count += 1;
+            } else {
+                if count > 1 {
+                    count -= 1;
+                } else {
+                    majority = num;
+                }
+            }
+        }
+
+        // For Confirmation
+        count = 0;
+        for &num in arr.iter() {
+            if num == majority {
+                count += 1;
+            }
+        }
+
+        if count >= (arr.len() / 2) + 1 {
+            majority
+        } else {
+            -1
+        }
+    }
+}

src/main/rust/g0101_0200/s0169_majority_element/Solution.rs

@@ -0,0 +1,27 @@
+169\. Majority Element
+
+Easy
+
+Given an array `nums` of size `n`, return _the majority element_.
+
+The majority element is the element that appears more than `⌊n / 2⌋` times. You may assume that the majority element always exists in the array.
+
+**Example 1:**
+
+**Input:** nums = [3,2,3]
+
+**Output:** 3
+
+**Example 2:**
+
+**Input:** nums = [2,2,1,1,1,2,2]
+
+**Output:** 2
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>1 <= n <= 5 * 10<sup>4</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+
+**Follow-up:** Could you solve the problem in linear time and in `O(1)` space?

src/main/rust/g0101_0200/s0169_majority_element/readme.md

@@ -0,0 +1,18 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Math #Two_Pointers
+// #Algorithm_I_Day_2_Two_Pointers #Udemy_Arrays #Big_O_Time_O(n)_Space_O(1)
+// #2024_09_10_Time_3_ms_(96.69%)_Space_3.6_MB_(76.46%)
+
+impl Solution {
+    pub fn rotate(nums: &mut Vec<i32>, k: i32) {
+        let mut rotated = vec![0; nums.len()];
+        let k_fixed = k as usize % nums.len();
+
+        for (i, item) in nums.iter().enumerate() {
+            match nums.get(i+k_fixed) {
+                Some(n) => rotated[i+k_fixed] = *item,
+                None => rotated[(i+k_fixed)-nums.len()] = *item,
+            }
+        }
+        nums.copy_from_slice(&rotated)
+    }
+}

src/main/rust/g0101_0200/s0189_rotate_array/Solution.rs

@@ -0,0 +1,42 @@
+189\. Rotate Array
+
+Medium
+
+Given an array, rotate the array to the right by `k` steps, where `k` is non-negative.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4,5,6,7], k = 3
+
+**Output:** [5,6,7,1,2,3,4]
+
+**Explanation:** 
+
+rotate 1 steps to the right: [7,1,2,3,4,5,6] 
+
+rotate 2 steps to the right: [6,7,1,2,3,4,5] 
+
+rotate 3 steps to the right: [5,6,7,1,2,3,4]
+
+**Example 2:**
+
+**Input:** nums = [-1,-100,3,99], k = 2
+
+**Output:** [3,99,-1,-100]
+
+**Explanation:** 
+
+rotate 1 steps to the right: [99,-1,-100,3] 
+
+rotate 2 steps to the right: [3,99,-1,-100]
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
+*   <code>0 <= k <= 10<sup>5</sup></code>
+
+**Follow up:**
+
+*   Try to come up with as many solutions as you can. There are at least **three** different ways to solve this problem.
+*   Could you do it in-place with `O(1)` extra space?

src/main/rust/g0101_0200/s0189_rotate_array/readme.md

@@ -0,0 +1,28 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Dynamic_Programming
+// #Algorithm_I_Day_12_Dynamic_Programming #Dynamic_Programming_I_Day_3
+// #Level_2_Day_12_Dynamic_Programming #Udemy_Dynamic_Programming #Big_O_Time_O(n)_Space_O(n)
+// #2024_09_10_Time_0_ms_(100.00%)_Space_2.1_MB_(31.95%)
+
+impl Solution {
+    pub fn rob(nums: Vec<i32>) -> i32 {
+        if nums.is_empty() {
+            return 0;
+        }
+        if nums.len() == 1 {
+            return nums[0];
+        }
+        if nums.len() == 2 {
+            return std::cmp::max(nums[0], nums[1]);
+        }
+
+        let mut profit = vec![0; nums.len()];
+        profit[0] = nums[0];
+        profit[1] = std::cmp::max(nums[0], nums[1]);
+
+        for i in 2..nums.len() {
+            profit[i] = std::cmp::max(profit[i - 1], nums[i] + profit[i - 2]);
+        }
+
+        profit[nums.len() - 1]
+    }
+}

src/main/rust/g0101_0200/s0198_house_robber/Solution.rs

@@ -0,0 +1,28 @@
+198\. House Robber
+
+Medium
+
+You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security systems connected and **it will automatically contact the police if two adjacent houses were broken into on the same night**.
+
+Given an integer array `nums` representing the amount of money of each house, return _the maximum amount of money you can rob tonight **without alerting the police**_.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,1]
+
+**Output:** 4
+
+**Explanation:** Rob house 1 (money = 1) and then rob house 3 (money = 3). Total amount you can rob = 1 + 3 = 4.
+
+**Example 2:**
+
+**Input:** nums = [2,7,9,3,1]
+
+**Output:** 12
+
+**Explanation:** Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1). Total amount you can rob = 2 + 9 + 1 = 12.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `0 <= nums[i] <= 400`

src/main/rust/g0101_0200/s0198_house_robber/readme.md

@@ -0,0 +1,59 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Depth_First_Search
+// #Breadth_First_Search #Matrix #Union_Find
+// #Algorithm_II_Day_6_Breadth_First_Search_Depth_First_Search
+// #Graph_Theory_I_Day_1_Matrix_Related_Problems #Level_1_Day_9_Graph/BFS/DFS #Udemy_Graph
+// #Big_O_Time_O(M*N)_Space_O(M*N) #2024_09_10_Time_7_ms_(86.79%)_Space_9.1_MB_(42.14%)
+
+impl Solution {
+    pub fn num_islands(grid: Vec<Vec<char>>) -> i32 {
+        let mut num_of_islands: i32 = 0;
+        let mut current_index: i32 = 1;
+        let height = grid.len();
+        let width = grid[0].len();
+        let mut part_of_island = vec![0; width * height];
+        let mut pos;
+
+        for current in 0..height * width {
+            let x = current / width;
+            let y = current % width;
+
+            if grid[x][y] == '1' {
+                let left = if y > 0 {
+                    part_of_island[current - 1]
+                } else {
+                    0
+                };
+
+                let up = if x > 0 {
+                    part_of_island[current - width]
+                } else {
+                    0
+                };
+
+                if up > 1 {
+                    if left > 1 && left != up {
+                        for i in 0..width {
+                            pos = part_of_island[current - i];
+                            if pos == left {
+                                part_of_island[current - i] = up;
+                            }
+                        }
+                        num_of_islands -= 1;
+                    }
+                    part_of_island[current] = up;
+                    continue;
+                } else if left > 1 {
+                    part_of_island[current] = left;
+                    continue;
+                }
+
+                current_index += 1;
+                num_of_islands += 1;
+                part_of_island[current] = current_index;
+            }
+        }
+
+        num_of_islands
+    }
+}
+