Added tasks 155-295

Author: javadev

README.md

@@ -0,0 +1,120 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Rust/LeetCode-in-Rust?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust)
+[![](https://img.shields.io/github/forks/LeetCode-in-Rust/LeetCode-in-Rust?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust/fork)
+
+## 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`.
+
+## Solution
+
+```rust
+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/readme.md

@@ -0,0 +1,68 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Rust/LeetCode-in-Rust?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust)
+[![](https://img.shields.io/github/forks/LeetCode-in-Rust/LeetCode-in-Rust?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust/fork)
+
+## 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?
+
+## Solution
+
+```rust
+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/readme.md

@@ -0,0 +1,64 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Rust/LeetCode-in-Rust?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust)
+[![](https://img.shields.io/github/forks/LeetCode-in-Rust/LeetCode-in-Rust?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust/fork)
+
+## 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?
+
+## Solution
+
+```rust
+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/readme.md

@@ -0,0 +1,59 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Rust/LeetCode-in-Rust?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust)
+[![](https://img.shields.io/github/forks/LeetCode-in-Rust/LeetCode-in-Rust?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust/fork)
+
+## 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`
+
+## Solution
+
+```rust
+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]
+    }
+}
+```