feat: minimum_window_substring

src/solutions/array/mod.rs

@@ -5,3 +5,4 @@ mod plus_one;
 mod remove_duplicate_from_sorted_array;
 mod remove_element;
 mod trapping_train_water;
+mod sort_colors;

src/solutions/array/sort_colors.rs

@@ -0,0 +1,54 @@
+struct Solution;
+
+impl Solution {
+    pub fn sort_colors(nums: &mut Vec<i32>) {
+        let l = nums.len();
+        if l == 0 { return; }
+        let mut start = 0;
+        let mut end = l - 1;
+        let mut i = 0;
+        while i <= end {
+            if nums[i] < 1 {
+                nums[start] = 0;
+                start += 1;
+                i += 1;
+            } else if nums[i] > 1 {
+                nums[i] = nums[end];
+                nums[end] = 2;
+                if end == 0 { return; }
+                end -= 1;
+
+            } else {
+                i += 1;
+            }
+        }
+        for j in start..=end {
+            nums[j] = 1;
+        }
+
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[test]
+    fn test_sort_colors1() {
+        let mut nums = vec![2,0,2,1,1,0];
+        Solution::sort_colors(&mut nums);
+
+        assert_eq!(nums, vec![0,0,1,1,2,2]);
+
+    }
+
+    #[test]
+    fn test_sort_colors2() {
+        let mut nums = vec![0,0];
+        Solution::sort_colors(&mut nums);
+
+        assert_eq!(nums, vec![0,0]);
+
+    }
+}

src/solutions/binary_search/mod.rs

@@ -2,3 +2,4 @@ mod find_first_and_last_position_of_element_in_sorted_array;
 mod search_in_rotated_sorted_array;
 mod search_insert_position;
 mod sqrt;
+mod search_2d_matrix;

src/solutions/binary_search/search_2d_matrix.rs

@@ -0,0 +1,47 @@
+struct Solution;
+impl Solution {
+    pub fn search_matrix(matrix: Vec<Vec<i32>>, target: i32) -> bool {
+        let rows = matrix.len();
+        if rows == 0 { return false; }
+        let cols = matrix[0].len();
+        if cols == 0 { return false; }
+        let mut l = 0;
+        let mut r  = rows * cols - 1;
+        while l <= r {
+            let mid = (l + r) / 2;
+            let i = mid / cols;
+            let j = mid % cols;
+            if matrix[i][j] == target {
+                return true;
+            }
+            if matrix[i][j] < target {
+                l = mid + 1;
+            } else {
+                if mid == 0 {
+                    return false;
+                }
+                r = mid - 1;
+            }
+        }
+
+
+
+        false
+
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_search_matrix1() {
+        let matrix = vec![vec![1,3,5,7],vec![10,11,16,20],vec![23,30,34,60]];
+        let target = 3;
+        let res = Solution::search_matrix(matrix, target);
+        assert_eq!(res, true);
+    }
+
+
+}

src/solutions/other/mod.rs

@@ -6,4 +6,4 @@ mod rotate_image;
 mod spiral_matrix;
 mod spiral_matrix_2;
 mod valid_number;
-mod set_matrix_zero;
+mod set_matrix_zero;

src/solutions/str/minimum_window_substring.rs

@@ -0,0 +1,67 @@
+struct Solution;
+
+use std::collections::{HashMap, VecDeque};
+
+impl Solution {
+    pub fn min_window(s: String, t: String) -> String {
+        let s_bytes = s.as_bytes();
+        let t_bytes = t.as_bytes();
+        let mut map = HashMap::<u8, i32>::new();
+        let mut n_free = t.len() as i32;
+
+        let (mut len, mut pos) = (s.len(), 0);
+
+        for &b in t_bytes {
+            let count = map.entry(b).or_insert(0);
+            *count += 1;
+        }
+
+        let mut window = VecDeque::<usize>::new();
+
+        for (i, b) in s_bytes.iter().enumerate() {
+            if let Some(count) = map.get_mut(&b) {
+                *count -= 1;
+                window.push_back(i);
+
+                if *count >= 0 {
+                    n_free -= 1;
+                }
+
+                while let Some(&idx) = window.front() {
+                    let cur_count = map.get_mut(&s_bytes[idx]).unwrap();
+                    if *cur_count < 0 {
+                        *cur_count += 1;
+                        window.pop_front();
+                    } else {
+                        break;
+                    }
+                }
+                if n_free == 0 {
+                    let cur_len = i - *window.front().unwrap();
+                    if cur_len < len {
+                        len = cur_len;
+                        pos = i;
+                    }
+                }
+            }
+        }
+        if len == s.len() {
+            "".to_owned()
+        } else {
+            String::from(&s[pos - len..pos + 1])
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_min_window1() {
+        let s = String::from("ADOBECODEBANC");
+        let t = String::from("ABC");
+        let res = Solution::min_window(s, t);
+        assert_eq!(res, String::from("BANC"));
+    }
+}

src/solutions/str/mod.rs

@@ -1,2 +1,3 @@
 mod multiply_strings;
 mod strstr;
+mod minimum_window_substring;