07-28-2020

Author: safrannn

src/_0005_longest_palindromic_substring.rs

@@ -0,0 +1,42 @@
+struct Solution;
+use std::iter::FromIterator;
+
+impl Solution {
+    pub fn longest_palindrome(s: String) -> String {
+        if s == "" {
+            return s;
+        }
+        let mut start: usize = 0;
+        let mut end: usize = 0;
+        let s: Vec<char> = s.chars().collect();
+
+        for i in 0..s.len() {
+            let mut left: usize = i;
+            let mut right: usize = i;
+            while right + 1 < s.len() && s[right + 1] == s[left] {
+                right += 1;
+            }
+            while left > 0 && right < s.len() - 1 && s[left - 1] == s[right + 1] {
+                left -= 1;
+                right += 1;
+            }
+            if right - left > end - start {
+                start = left;
+                end = right;
+            }
+        }
+        String::from_iter(&s[start..=end])
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::longest_palindrome("babad".to_string()),
+        "bab".to_string()
+    );
+    assert_eq!(
+        Solution::longest_palindrome("cbbd".to_string()),
+        "bb".to_string()
+    );
+}

src/_0011_container_with_most_water.rs

@@ -0,0 +1,25 @@
+struct Solution;
+
+impl Solution {
+    pub fn max_area(height: Vec<i32>) -> i32 {
+        let mut h_left: usize = 0;
+        let mut h_right: usize = height.len() - 1;
+        let mut max_area: i32 = 0;
+
+        while h_left < h_right {
+            let h_area: i32 = height[h_left].min(height[h_right]) * (h_right - h_left) as i32;
+            max_area = max_area.max(h_area);
+            if height[h_left] < height[h_right] {
+                h_left += 1;
+            } else {
+                h_right -= 1;
+            }
+        }
+        max_area
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::max_area(vec![1, 8, 6, 2, 5, 4, 8, 3, 7]), 49);
+}

src/_0198_house_robber.rs

@@ -0,0 +1,21 @@
+struct Solution;
+
+impl Solution {
+    pub fn rob(nums: Vec<i32>) -> i32 {
+        let mut h_previous_max: i32 = 0;
+        let mut h_current_max: i32 = 0;
+
+        for v in nums {
+            let h_temp: i32 = h_current_max;
+            h_current_max = (h_previous_max + v).max(h_current_max);
+            h_previous_max = h_temp;
+        }
+        h_current_max
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::rob(vec![1, 2, 3, 1]), 4);
+    assert_eq!(Solution::rob(vec![2, 7, 9, 3, 1]), 12);
+}

src/_0238_product_of_array_except_self.rs

@@ -0,0 +1,27 @@
+struct Solution;
+impl Solution {
+    pub fn product_except_self(nums: Vec<i32>) -> Vec<i32> {
+        let length: usize = nums.len();
+        let mut answer: Vec<i32> = vec![1; length];
+
+        let mut h_product: i32 = 1;
+        for i in 0..length {
+            answer[i] = h_product;
+            h_product *= nums[i]
+        }
+        h_product = 1;
+        for i in (0..length).rev() {
+            answer[i] *= h_product;
+            h_product *= nums[i];
+        }
+        answer
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::product_except_self(vec![1, 2, 3, 4]),
+        vec![24, 12, 8, 6]
+    );
+}

src/lib.rs

@@ -14,10 +14,14 @@ mod _0001_two_sum;
 //
 mod _0002_add_two_numbers;
 //
+mod _0005_longest_palindromic_substring;
+//
 mod _0007_reverse_integer;
 //
 mod _0009_palindrome_number;
 //
+mod _0011_container_with_most_water;
+//
 mod _0014_longest_common_prefix;
 //
 mod _0015_3sum;
@@ -64,6 +68,8 @@ mod _0169_majority_element;
 //
 mod _0189_rotate_array;
 //
+mod _0198_house_robber;
+//
 mod _0200_number_of_islands;
 //
 mod _0202_happy_number;
@@ -78,6 +84,8 @@ mod _0210_course_schedule_ii;
 //
 mod _0219_contains_duplicate_ii;
 //
+mod _0238_product_of_array_except_self;
+//
 mod _0242_valid_anagram;
 //
 mod _0243_shortest_word_distance;