Added tasks 300-1143

Author: javadev

README.md

@@ -0,0 +1,78 @@
+[![](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)
+
+## 300\. Longest Increasing Subsequence
+
+Medium
+
+Given an integer array `nums`, return the length of the longest strictly increasing subsequence.
+
+A **subsequence** is a sequence that can be derived from an array by deleting some or no elements without changing the order of the remaining elements. For example, `[3,6,2,7]` is a subsequence of the array `[0,3,1,6,2,2,7]`.
+
+**Example 1:**
+
+**Input:** nums = [10,9,2,5,3,7,101,18]
+
+**Output:** 4
+
+**Explanation:** The longest increasing subsequence is [2,3,7,101], therefore the length is 4.
+
+**Example 2:**
+
+**Input:** nums = [0,1,0,3,2,3]
+
+**Output:** 4
+
+**Example 3:**
+
+**Input:** nums = [7,7,7,7,7,7,7]
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= nums.length <= 2500`
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+
+**Follow up:** Can you come up with an algorithm that runs in `O(n log(n))` time complexity?
+
+## Solution
+
+```rust
+impl Solution {
+    pub fn length_of_lis(nums: Vec<i32>) -> i32 {
+        if nums.is_empty() {
+            return 0;
+        }
+
+        let mut dp = vec![i32::MAX; nums.len() + 1];
+        let (mut left, mut right) = (1, 1);
+
+        for &curr in nums.iter() {
+            let (mut start, mut end) = (left, right);
+
+            // Binary search to find the position to update
+            while start + 1 < end {
+                let mid = start + (end - start) / 2;
+                if dp[mid as usize] > curr {
+                    end = mid;
+                } else {
+                    start = mid;
+                }
+            }
+
+            // Update the dp array
+            if dp[start as usize] > curr {
+                dp[start as usize] = curr;
+            } else if curr > dp[start as usize] && curr < dp[end as usize] {
+                dp[end as usize] = curr;
+            } else if curr > dp[end as usize] {
+                dp[end as usize + 1] = curr;
+                right += 1;
+            }
+        }
+
+        right
+    }
+}
+```

src/main/rust/g0201_0300/s0300_longest_increasing_subsequence/readme.md

@@ -0,0 +1,69 @@
+[![](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)
+
+## 322\. Coin Change
+
+Medium
+
+You are given an integer array `coins` representing coins of different denominations and an integer `amount` representing a total amount of money.
+
+Return _the fewest number of coins that you need to make up that amount_. If that amount of money cannot be made up by any combination of the coins, return `-1`.
+
+You may assume that you have an infinite number of each kind of coin.
+
+**Example 1:**
+
+**Input:** coins = [1,2,5], amount = 11
+
+**Output:** 3
+
+**Explanation:** 11 = 5 + 5 + 1
+
+**Example 2:**
+
+**Input:** coins = [2], amount = 3
+
+**Output:** -1
+
+**Example 3:**
+
+**Input:** coins = [1], amount = 0
+
+**Output:** 0
+
+**Constraints:**
+
+*   `1 <= coins.length <= 12`
+*   <code>1 <= coins[i] <= 2<sup>31</sup> - 1</code>
+*   <code>0 <= amount <= 10<sup>4</sup></code>
+
+## Solution
+
+```rust
+impl Solution {
+    pub fn coin_change(coins: Vec<i32>, amount: i32) -> i32 {
+        let mut dp = vec![0; (amount + 1) as usize];
+        dp[0] = 1;  // Base case: one way to make 0 amount (using no coins)
+
+        for &coin in &coins {
+            for i in coin..=amount {
+                let prev = dp[(i - coin) as usize];
+                if prev > 0 {
+                    if dp[i as usize] == 0 {
+                        dp[i as usize] = prev + 1;
+                    } else {
+                        dp[i as usize] = dp[i as usize].min(prev + 1);
+                    }
+                }
+            }
+        }
+        
+        // If the dp[amount] is still 0, it means no solution was found
+        if dp[amount as usize] == 0 {
+            -1
+        } else {
+            dp[amount as usize] - 1
+        }
+    }
+}
+```

src/main/rust/g0301_0400/s0322_coin_change/readme.md

@@ -0,0 +1,70 @@
+[![](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)
+
+## 338\. Counting Bits
+
+Easy
+
+Given an integer `n`, return _an array_ `ans` _of length_ `n + 1` _such that for each_ `i` (`0 <= i <= n`)_,_ `ans[i]` _is the **number of**_ `1`_**'s** in the binary representation of_ `i`.
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** [0,1,1]
+
+**Explanation:**
+
+    0 --> 0
+    1 --> 1
+    2 --> 10 
+
+**Example 2:**
+
+**Input:** n = 5
+
+**Output:** [0,1,1,2,1,2]
+
+**Explanation:**
+
+    0 --> 0
+    1 --> 1
+    2 --> 10
+    3 --> 11
+    4 --> 100
+    5 --> 101 
+
+**Constraints:**
+
+*   <code>0 <= n <= 10<sup>5</sup></code>
+
+**Follow up:**
+
+*   It is very easy to come up with a solution with a runtime of `O(n log n)`. Can you do it in linear time `O(n)` and possibly in a single pass?
+*   Can you do it without using any built-in function (i.e., like `__builtin_popcount` in C++)?
+
+## Solution
+
+```rust
+impl Solution {
+    pub fn count_bits(num: i32) -> Vec<i32> {
+        let mut result = vec![0; (num + 1) as usize];
+        let mut border_pos = 1;
+        let mut incr_pos = 1;
+        
+        for i in 1..=num {
+            // When we reach a power of 2, reset border_pos and incr_pos
+            if incr_pos == border_pos {
+                result[i as usize] = 1;
+                incr_pos = 1;
+                border_pos = i;
+            } else {
+                result[i as usize] = 1 + result[incr_pos as usize];
+                incr_pos += 1;
+            }
+        }
+        
+        result
+    }
+}
+```

src/main/rust/g0301_0400/s0338_counting_bits/readme.md

@@ -0,0 +1,66 @@
+[![](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)
+
+## 347\. Top K Frequent Elements
+
+Medium
+
+Given an integer array `nums` and an integer `k`, return _the_ `k` _most frequent elements_. You may return the answer in **any order**.
+
+**Example 1:**
+
+**Input:** nums = [1,1,1,2,2,3], k = 2
+
+**Output:** [1,2]
+
+**Example 2:**
+
+**Input:** nums = [1], k = 1
+
+**Output:** [1]
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+*   `k` is in the range `[1, the number of unique elements in the array]`.
+*   It is **guaranteed** that the answer is **unique**.
+
+**Follow up:** Your algorithm's time complexity must be better than `O(n log n)`, where n is the array's size.
+
+## Solution
+
+```rust
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn top_k_frequent(nums: Vec<i32>, k: i32) -> Vec<i32> {
+        nums.iter().fold(HashMap::new(), |mut map, n| {
+            let mut counter = map.entry(n).or_insert(0);
+            *counter += 1;
+            map
+        })
+        .drain()
+        .fold(vec![(0, 0); k as usize], |mut top_k, (&num, count)| {
+            if count > top_k[0].1 {
+                top_k[0] = (num, count);
+
+                let mut next_index = 1;
+                while next_index < k as usize {
+                    if count > top_k[next_index].1 {
+                        let temp = top_k[next_index];
+                        top_k[next_index] = (num, count);
+                        top_k[next_index - 1] = temp;
+                    }
+                    next_index += 1;
+                }
+            }
+
+            top_k
+        })
+        .into_iter()
+        .map(|(num, count)| num)
+        .collect()
+    }
+}
+```

src/main/rust/g0301_0400/s0347_top_k_frequent_elements/readme.md

@@ -0,0 +1,72 @@
+[![](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)
+
+## 394\. Decode String
+
+Medium
+
+Given an encoded string, return its decoded string.
+
+The encoding rule is: `k[encoded_string]`, where the `encoded_string` inside the square brackets is being repeated exactly `k` times. Note that `k` is guaranteed to be a positive integer.
+
+You may assume that the input string is always valid; there are no extra white spaces, square brackets are well-formed, etc. Furthermore, you may assume that the original data does not contain any digits and that digits are only for those repeat numbers, `k`. For example, there will not be input like `3a` or `2[4]`.
+
+The test cases are generated so that the length of the output will never exceed <code>10<sup>5</sup></code>.
+
+**Example 1:**
+
+**Input:** s = "3[a]2[bc]"
+
+**Output:** "aaabcbc"
+
+**Example 2:**
+
+**Input:** s = "3[a2[c]]"
+
+**Output:** "accaccacc"
+
+**Example 3:**
+
+**Input:** s = "2[abc]3[cd]ef"
+
+**Output:** "abcabccdcdcdef"
+
+**Constraints:**
+
+*   `1 <= s.length <= 30`
+*   `s` consists of lowercase English letters, digits, and square brackets `'[]'`.
+*   `s` is guaranteed to be **a valid** input.
+*   All the integers in `s` are in the range `[1, 300]`.
+
+## Solution
+
+```rust
+impl Solution {
+    pub fn decode_string(s: String) -> String {
+        s
+        .chars()
+        .fold((String::new(), String::new(), Vec::new()), |(mut next_string, mut next_integer, mut stack): (String, String, Vec<(usize, String)>), c| {
+            match c {
+                '0'..='9' => {
+                    next_integer.push(c);
+                    (next_string, next_integer, stack)
+                },
+                '[' => {
+                    stack.push((next_integer.parse::<usize>().unwrap(), next_string));
+                    next_integer.clear();
+                    (String::new(), next_integer, stack)
+                },
+                ']' => {
+                    let (last_integer, left_string) = stack.pop().unwrap();
+                    let next_string = left_string + &next_string.repeat(last_integer);
+                    (next_string, next_integer, stack)
+                },
+                c => {
+                    next_string.push(c);
+                    (next_string, next_integer, stack)
+                }
+            }
+        }).0
+    }
+}
+```