2020-6-18

Author: safrannn

src/_0007_reverse_integer.rs

@@ -0,0 +1,31 @@
+struct Solution;
+
+impl Solution {
+    pub fn reverse(x: i32) -> i32 {
+        let sign = match x < 0 {
+            true => -1,
+            false => 1,
+        };
+        let mut result: i32 = 0;
+        let mut number: i32 = x.abs();
+
+        while number != 0 {
+            match result.checked_mul(10) {
+                Some(v) => result = v,
+                None => return 0,
+            }
+            match result.checked_add(number % 10) {
+                Some(v) => result = v,
+                None => return 0,
+            }
+            number /= 10;
+        }
+
+        result * sign
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::reverse(123), 321);
+}

src/_0020_valid_parentheses.rs

@@ -2,16 +2,16 @@ struct Solution;
 
 impl Solution {
     pub fn is_valid(s: String) -> bool {
-        let mut stack: Vec<char> = vec![];
+        let mut char_stack: Vec<char> = vec![];
 
         for c in s.chars() {
             match c {
-                '(' | '[' | '{' => stack.push(c),
-                ')' | ']' | '}' => match stack.pop() {
-                    Some(p) => {
-                        if !((p == '(' && c == ')')
-                            || (p == '[' && c == ']')
-                            || (p == '{' && c == '}'))
+                '(' | '{' | '[' => char_stack.push(c),
+                ')' | '}' | ']' => match char_stack.pop() {
+                    Some(l) => {
+                        if !((c == ')' && l == '(')
+                            | (c == '}' && l == '{')
+                            | (c == ']' && l == '['))
                         {
                             return false;
                         }
@@ -21,7 +21,8 @@ impl Solution {
                 _ => {}
             }
         }
-        stack.is_empty()
+
+        char_stack.is_empty()
     }
 }
 

src/_0053_maximum_subarray.rs

@@ -0,0 +1,22 @@
+struct Solution;
+
+impl Solution {
+    pub fn max_sub_array(nums: Vec<i32>) -> i32 {
+        let mut current_max = nums[0];
+        let mut overall_max = nums[0];
+
+        for i in 1..nums.len() {
+            current_max = nums[i].max(current_max + nums[i]);
+            overall_max = overall_max.max(current_max);
+        }
+        overall_max
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::max_sub_array(vec![-2, 1, -3, 4, -1, 2, 1, -5, 4]),
+        6
+    );
+}

src/_0088_merge_sorted_array.rs

@@ -0,0 +1,31 @@
+struct Solution;
+
+impl Solution {
+    pub fn merge_sorted_array(nums1: &mut Vec<i32>, m: i32, nums2: &mut Vec<i32>, n: i32) {
+        let mut i = m - 1;
+        let mut j = n - 1;
+        let mut k = m + n - 1;
+
+        while k >= 0 {
+            if i >= 0 && (j < 0 || nums1[i as usize] >= nums2[j as usize]) {
+                nums1[k as usize] = nums1[i as usize];
+                i -= 1;
+            } else {
+                nums1[k as usize] = nums2[j as usize];
+                j -= 1;
+            }
+            k -= 1;
+        }
+    }
+}
+
+#[test]
+fn test() {
+    let mut arr1 = vec![1, 2, 3, 0, 0, 0];
+    let mut arr2 = vec![2, 5, 6];
+    let m: i32 = 3;
+    let n: i32 = 3;
+    let answer = vec![1, 2, 2, 3, 5, 6];
+    Solution::merge_sorted_array(&mut arr1, m, &mut arr2, n);
+    assert_eq!(arr1, answer);
+}

src/_0415_add_strings.rs

@@ -0,0 +1,59 @@
+struct Solution;
+
+impl Solution {
+    pub fn add_strings(num1: String, num2: String) -> String {
+        use std::{char, iter};
+        // prepare and create result with capacity
+        let len1 = num1.len();
+        let len2 = num2.len();
+        let mut carry = 0;
+        let mut result = String::with_capacity(len1.max(len2) + 1);
+
+        // choose num1 to be the shorter one, num2 the longer one
+        let (num1, num2) = if len1 < len2 {
+            (num1, num2)
+        } else {
+            (num2, num1)
+        };
+
+        // create character tuple (c1,c2) from num1 and num2
+        // fill empty digits with 1
+        for (c1, c2) in num1
+            .chars()
+            .rev()
+            .chain(iter::repeat('0'))
+            .zip(num2.chars().rev())
+        {
+            let n1 = c1.to_digit(10).unwrap();
+            let n2 = c2.to_digit(10).unwrap();
+            let mut sum = n1 + n2 + carry;
+
+            if sum < 10 {
+                carry = 0;
+            } else {
+                carry = 1;
+                sum -= 10;
+            }
+
+            result.push(char::from_digit(sum, 10).unwrap());
+        }
+
+        // handle the last digit with carry
+        if carry == 1 {
+            result.push('1');
+        } else if result.is_empty() {
+            result.push('0')
+        }
+
+        // convert result to reverse string and return
+        result.chars().rev().collect::<String>()
+    }
+}
+
+#[test]
+fn test() {
+    let a = "0".to_string();
+    let b = "0".to_string();
+    let c = "0".to_string();
+    assert_eq!(Solution::add_strings(a, b), c);
+}

src/_0953_verifying_an_alien_dictionary.rs

@@ -0,0 +1,29 @@
+struct Solution;
+
+impl Solution {
+    pub fn is_alien_sorted(words: Vec<String>, order: String) -> bool {
+        let mut dictionary: Vec<char> = vec!['a'; 256];
+        for (i, v) in order.chars().enumerate() {
+            dictionary[v as usize] = (i as u8 + 'a' as u8) as char;
+        }
+
+        let words: Vec<String> = words
+            .into_iter()
+            .map(|word| Solution::translate(&dictionary, word))
+            .collect();
+        let mut words_sort: Vec<String> = words.to_vec();
+        words_sort.sort();
+        words == words_sort
+    }
+
+    fn translate(dictionary: &Vec<char>, word: String) -> String {
+        word.chars().map(|c| dictionary[c as usize]).collect()
+    }
+}
+
+#[test]
+fn test() {
+    let words: Vec<String> = vec!["hello".to_string(), "leetcode".to_string()];
+    let order: String = "hlabcdefgijkmnopqrstuvwxyz".to_string();
+    assert_eq!(Solution::is_alien_sorted(words, order), true);
+}

src/k.rs

@@ -0,0 +1,42 @@
+struct Solution;
+
+impl Solution {
+    fn valid_utf8(data: Vec<i32>) -> bool {
+        let mut count = 0;
+        for x in data {
+            if count == 0 {
+                if x >> 3 == 0b11110 {
+                    count += 3;
+                    continue;
+                }
+                if x >> 4 == 0b1110 {
+                    count += 2;
+                    continue;
+                }
+                if x >> 5 == 0b110 {
+                    count += 1;
+                    continue;
+                }
+                if x >> 7 == 0 {
+                    continue;
+                }
+                return false;
+            } else {
+                if x >> 6 == 0b10 {
+                    count -= 1;
+                    continue;
+                }
+                return false;
+            }
+        }
+        count == 0
+    }
+}
+
+#[test]
+fn test() {
+    let data = vec![197, 130, 1];
+    assert_eq!(Solution::valid_utf8(data), true);
+    let data = vec![235, 140, 4];
+    assert_eq!(Solution::valid_utf8(data), false);
+}

src/lib.rs

@@ -1,22 +1,34 @@
-#![deny(clippy::all)]
+// #![deny(clippy::all)]
 #![allow(dead_code)]
 #![allow(clippy::many_single_char_names)]
 #![allow(clippy::collapsible_if)]
 #![allow(clippy::needless_range_loop)]
 #![allow(clippy::float_cmp)]
 #![allow(clippy::cast_lossless)]
 
+//
+mod k;
 //
 mod util;
 //
 mod _0001_two_sum;
 //
+mod _0007_reverse_integer;
+//
 mod _0020_valid_parentheses;
 //
 mod _0021_merge_two_sorted_lists;
 //
+mod _0053_maximum_subarray;
+//
+mod _0088_merge_sorted_array;
+//
 mod _0202_happy_number;
 //
+mod _0415_add_strings;
+//
+mod _0953_verifying_an_alien_dictionary;
+//
 mod _1281_subtract_the_product_and_sum_of_digits_of_an_integer;
 //
 mod _1287_element_appearing_more_than_25_in_sorted_array;