7-25-2020

Author: safrannn

src/_0387_first_unique_character_in_a_string.rs

@@ -0,0 +1,30 @@
+struct Solution;
+impl Solution {
+    pub fn first_uniq_char(s: String) -> i32 {
+        let mut h_char_index: Vec<i32> = vec![-1; 26];
+        for (i, v) in s.chars().enumerate() {
+            if h_char_index[v as usize - 'a' as usize] >= 0 {
+                h_char_index[v as usize - 'a' as usize] = -2;
+            } else if h_char_index[v as usize - 'a' as usize] == -1 {
+                h_char_index[v as usize - 'a' as usize] = i as i32;
+            }
+        }
+        let mut result: i32 = s.len() as i32;
+        for v in h_char_index {
+            if v >= 0 {
+                result = result.min(v);
+            }
+        }
+        if result == s.len() as i32 {
+            return -1;
+        } else {
+            return result;
+        }
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::first_uniq_char("leetcode".to_string()), 0);
+    assert_eq!(Solution::first_uniq_char("loveleetcode".to_string()), 2);
+}

src/_0678_valid_parenthesis_string.rs

@@ -0,0 +1,34 @@
+struct Solution;
+
+impl Solution {
+    pub fn check_valid_string(s: String) -> bool {
+        let mut h_low: i32 = 0;
+        let mut h_high: i32 = 0;
+        for v in s.chars() {
+            if v == '(' {
+                h_low += 1;
+            } else {
+                h_low -= 1;
+            }
+
+            if v != ')' {
+                h_high += 1;
+            } else {
+                h_high -= 1;
+            }
+
+            if h_high < 0 {
+                return false;
+            }
+            h_low = h_low.max(0);
+        }
+        h_low == 0
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::check_valid_string("()".to_string()), true);
+    assert_eq!(Solution::check_valid_string("(*)".to_string()), true);
+    assert_eq!(Solution::check_valid_string("(*))".to_string()), true);
+}

src/_0922_sort_array_by_parity_ii.rs

@@ -0,0 +1,30 @@
+struct Solution;
+
+impl Solution {
+    pub fn sort_array_by_parity_ii(mut a: Vec<i32>) -> Vec<i32> {
+        let mut h_even_index: usize = 0;
+        let mut h_odd_index: usize = 1;
+        let n: usize = a.len();
+        while h_even_index < n && h_odd_index < n {
+            while h_even_index < n && a[h_even_index] % 2 == 0 {
+                h_even_index += 2;
+            }
+            while h_odd_index < n && a[h_odd_index] % 2 == 1 {
+                h_odd_index += 2;
+            }
+
+            if h_even_index < n && h_odd_index < n {
+                a.swap(h_even_index, h_odd_index);
+            }
+        }
+        a
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::sort_array_by_parity_ii(vec![4, 2, 5, 7]),
+        vec![4, 5, 2, 7]
+    );
+}

src/_1021_remove_outermost_parentheses.rs

@@ -0,0 +1,42 @@
+struct Solution;
+
+impl Solution {
+    pub fn remove_outer_parentheses(s: String) -> String {
+        let mut result: String = "".to_string();
+        let mut count: i32 = 0;
+        for v in s.chars() {
+            match v {
+                '(' => {
+                    count += 1;
+                    if count > 1 {
+                        result.push(v);
+                    }
+                }
+                ')' => {
+                    count -= 1;
+                    if count != 0 {
+                        result.push(v);
+                    }
+                }
+                _ => {}
+            }
+        }
+        result
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::remove_outer_parentheses("(()())(())".to_string(),),
+        "()()()".to_string()
+    );
+    assert_eq!(
+        Solution::remove_outer_parentheses("(()())(())(()(()))".to_string(),),
+        "()()()()(())".to_string()
+    );
+    assert_eq!(
+        Solution::remove_outer_parentheses("()()".to_string(),),
+        "".to_string()
+    );
+}

src/_1528_shuffle_string.rs

@@ -0,0 +1,37 @@
+struct Solution;
+
+impl Solution {
+    pub fn restore_string(s: String, indices: Vec<i32>) -> String {
+        let s_char: Vec<char> = s.chars().collect();
+        let mut result: Vec<char> = vec!['a'; s.len()];
+
+        for (i, v) in indices.into_iter().enumerate() {
+            result[v as usize] = s_char[i];
+        }
+        result.into_iter().collect()
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::restore_string("abc".to_string(), vec![0, 1, 2]),
+        "abc".to_string()
+    );
+    assert_eq!(
+        Solution::restore_string("codeleet".to_string(), vec![4, 5, 6, 7, 0, 2, 1, 3]),
+        "leetcode".to_string()
+    );
+    assert_eq!(
+        Solution::restore_string("aiohn".to_string(), vec![3, 1, 4, 2, 0]),
+        "nihao".to_string()
+    );
+    assert_eq!(
+        Solution::restore_string("aaiougrt".to_string(), vec![4, 0, 2, 6, 7, 3, 1, 5]),
+        "arigatou".to_string()
+    );
+    assert_eq!(
+        Solution::restore_string("art".to_string(), vec![1, 0, 2]),
+        "rat".to_string()
+    );
+}

src/lib.rs

@@ -100,6 +100,8 @@ mod _0371_sum_of_two_integers;
 //
 mod _0383_ransom_note;
 //
+mod _0387_first_unique_character_in_a_string;
+//
 mod _0412_fizz_buzz;
 //
 mod _0415_add_strings;
@@ -124,6 +126,8 @@ mod _0561_array_partition_i;
 //
 mod _0605_can_place_flowers;
 //
+mod _0678_valid_parenthesis_string;
+//
 mod _0680_valid_palindrome_ii;
 //
 mod _0724_find_pivot_index;
@@ -142,12 +146,16 @@ mod _0844_backspace_string_compare;
 //
 mod _0905_sort_array_by_parity;
 //
+mod _0922_sort_array_by_parity_ii;
+//
 mod _0953_verifying_an_alien_dictionary;
 //
 mod _0977_squares_of_a_sorted_array;
 //
 mod _1013_partition_array_into_three_parts_with_equal_sum;
 //
+mod _1021_remove_outermost_parentheses;
+//
 mod _1029_two_city_scheduling;
 //
 mod _1249_minimum_remove_to_make_valid_parentheses;
@@ -163,3 +171,5 @@ mod _1299_replace_elements_with_greatest_element_on_right_side;
 mod _1304_find_n_unique_integers_sum_up_to_zero;
 //
 mod _1486_xor_operation_in_an_array;
+//
+mod _1528_shuffle_string;