7-21-2020

Author: safrannn

src/_0496_next_greater_element_i.rs

@@ -0,0 +1,34 @@
+struct Solution;
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn next_greater_element(nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
+        let mut h_map: HashMap<i32, i32> = HashMap::new();
+        let mut h_stack: Vec<i32> = vec![];
+
+        for v in nums2 {
+            while let Some(last) = h_stack.pop() {
+                if v >= last {
+                    h_map.insert(last, v);
+                } else {
+                    h_stack.push(last);
+                    break;
+                }
+            }
+            h_stack.push(v);
+        }
+        nums1.iter().map(|v| *h_map.get(v).unwrap_or(&-1)).collect()
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::next_greater_element(vec![4, 1, 2], vec![1, 3, 4, 2]),
+        vec![-1, 3, -1]
+    );
+    assert_eq!(
+        Solution::next_greater_element(vec![2, 4], vec![1, 2, 3, 4]),
+        vec![3, -1]
+    );
+}

src/_0503_next_greater_element_ii.rs

@@ -0,0 +1,31 @@
+struct Solution;
+
+impl Solution {
+    pub fn next_greater_elements(nums: Vec<i32>) -> Vec<i32> {
+        let n = nums.len();
+        let mut result: Vec<i32> = vec![-1; n];
+        let mut h_stack: Vec<usize> = vec![];
+
+        for i in 0..2 * n {
+            let i_: usize = i % n;
+            while let Some(last) = h_stack.pop() {
+                if nums[i_] > nums[last] {
+                    result[last] = nums[i_] as i32;
+                } else {
+                    h_stack.push(last);
+                    break;
+                }
+            }
+            h_stack.push(i_);
+        }
+        result
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::next_greater_elements(vec![1, 2, 1]),
+        vec![2, -1, 2]
+    );
+}

src/_0556_next_greater_element_iii.rs

@@ -0,0 +1,49 @@
+struct Solution;
+
+impl Solution {
+    pub fn next_greater_element(n: i32) -> i32 {
+        let mut num: i32 = n.clone();
+        let mut last: i32 = num % 10;
+        let mut h_array: Vec<i32> = vec![last];
+        num /= 10;
+
+        while num > 0 {
+            let mut current = num % 10;
+            if last <= current {
+                h_array.push(current);
+            } else {
+                let h_array_len: usize = h_array.len();
+                let mut num_replace: i32 = h_array[h_array_len - 1];
+                let mut index_replace: usize = h_array_len - 1;
+                for i in 0..h_array_len {
+                    if h_array[i] > current && h_array[i] <= num_replace {
+                        num_replace = h_array[i].clone();
+                        index_replace = i;
+                        break;
+                    }
+                }
+                h_array[index_replace] = current;
+                current = num_replace;
+                num = num / 10 * 10 + current;
+                for v in h_array.iter() {
+                    if num as i64 * 10 + *v as i64 > std::i32::MAX as i64 {
+                        return -1;
+                    } else {
+                        num = num * 10 + v;
+                    }
+                }
+                return num;
+            }
+            last = current;
+            num /= 10;
+        }
+        -1
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::next_greater_element(12), 21);
+    assert_eq!(Solution::next_greater_element(21), -1);
+    assert_eq!(Solution::next_greater_element(1999999999), -1);
+}

src/_0561_array_partition_i.rs

@@ -0,0 +1,12 @@
+struct Solution;
+
+impl Solution {
+    pub fn array_pair_sum(mut nums: Vec<i32>) -> i32 {
+        nums.sort_unstable();
+        nums.chunks(2).fold(0, |sum, pair| sum + pair[0])
+    }
+}
+#[test]
+fn test() {
+    assert_eq!(Solution::array_pair_sum(vec![1, 4, 3, 2]), 4);
+}

src/_0905_sort_array_by_parity.rs

@@ -0,0 +1,28 @@
+struct Solution;
+
+impl Solution {
+    pub fn sort_array_by_parity(mut a: Vec<i32>) -> Vec<i32> {
+        let mut even: usize = 0;
+        let mut odd: usize = a.len() - 1;
+        while even < odd {
+            while a[even] % 2 == 0 && even < odd {
+                even += 1;
+            }
+            while a[odd] % 2 == 1 && even < odd {
+                odd -= 1;
+            }
+            if even < odd {
+                a.swap(even, odd);
+            }
+        }
+        a
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::sort_array_by_parity(vec![3, 1, 2, 4]),
+        vec![4, 2, 1, 3]
+    );
+}

src/_1013_partition_array_into_three_parts_with_equal_sum.rs

@@ -0,0 +1,39 @@
+struct Solution;
+
+impl Solution {
+    pub fn can_three_parts_equal_sum(a: Vec<i32>) -> bool {
+        let sum_total: i32 = a.iter().sum();
+        if sum_total % 3 != 0 {
+            return false;
+        }
+        let mut count: i32 = 0;
+        let mut sum_temp: i32 = 0;
+        for v in a.iter() {
+            sum_temp += v;
+            if sum_temp == sum_total / 3 {
+                count += 1;
+                sum_temp = 0;
+            }
+            if count == 3 {
+                return true;
+            }
+        }
+        false
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::can_three_parts_equal_sum(vec![0, 2, 1, -6, 6, -7, 9, 1, 2, 0, 1]),
+        true
+    );
+    assert_eq!(
+        Solution::can_three_parts_equal_sum(vec![0, 2, 1, -6, 6, 7, 9, -1, 2, 0, 1]),
+        false
+    );
+    assert_eq!(
+        Solution::can_three_parts_equal_sum(vec![3, 3, 6, 5, -2, 2, 5, 1, -9, 4]),
+        true
+    );
+}

src/_1249_minimum_remove_to_make_valid_parentheses.rs

@@ -0,0 +1,44 @@
+struct Solution;
+
+impl Solution {
+    pub fn min_remove_to_make_valid(s: String) -> String {
+        let mut characters: Vec<char> = s.chars().collect::<Vec<char>>();
+        let mut h_stack: Vec<usize> = vec![];
+        for i in 0..characters.len() {
+            match characters[i] {
+                ')' => match h_stack.pop() {
+                    None => characters[i] = '_',
+                    _ => {}
+                },
+                '(' => {
+                    h_stack.push(i);
+                }
+                _ => {}
+            }
+        }
+        while let Some(index) = h_stack.pop() {
+            characters[index] = '_';
+        }
+        characters.iter().filter(|&x| *x != '_').collect::<String>()
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::min_remove_to_make_valid("lee(t(c)o)de)".to_string()),
+        "lee(t(c)o)de".to_string()
+    );
+    assert_eq!(
+        Solution::min_remove_to_make_valid("a)b(c)d".to_string()),
+        "ab(c)d".to_string()
+    );
+    assert_eq!(
+        Solution::min_remove_to_make_valid("))((".to_string()),
+        "".to_string()
+    );
+    assert_eq!(
+        Solution::min_remove_to_make_valid("(a(b(c)d)".to_string()),
+        "a(b(c)d)".to_string()
+    );
+}

src/lib.rs

@@ -100,12 +100,20 @@ mod _0415_add_strings;
 //
 mod _0448_find_all_numbers_disappeared_in_an_array;
 //
+mod _0496_next_greater_element_i;
+//
+mod _0503_next_greater_element_ii;
+//
 mod _0509_fibonacci_number;
 //
+mod _0556_next_greater_element_iii;
+//
 mod _0557_reverse_words_in_a_string_iii;
 //
 mod _0560_subarray_sum_equals_k;
 //
+mod _0561_array_partition_i;
+//
 mod _0605_can_place_flowers;
 //
 mod _0680_valid_palindrome_ii;
@@ -120,12 +128,18 @@ mod _0796_rotate_string;
 //
 mod _0844_backspace_string_compare;
 //
+mod _0905_sort_array_by_parity;
+//
 mod _0953_verifying_an_alien_dictionary;
 //
 mod _0977_squares_of_a_sorted_array;
 //
+mod _1013_partition_array_into_three_parts_with_equal_sum;
+//
 mod _1029_two_city_scheduling;
 //
+mod _1249_minimum_remove_to_make_valid_parentheses;
+//
 mod _1281_subtract_the_product_and_sum_of_digits_of_an_integer;
 //
 mod _1287_element_appearing_more_than_25_in_sorted_array;