6-27-2020

Author: safrannn

src/_0083_remove_duplicates_from_sorted_list.rs

@@ -0,0 +1,26 @@
+struct Solution;
+use crate::util::*;
+
+impl Solution {
+    pub fn delete_duplicates(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        let mut p = head.as_mut();
+        while let Some(n) = p {
+            while let Some(m) = n.next.as_mut() {
+                if n.val == m.val {
+                    n.next = m.next.take();
+                } else {
+                    break;
+                }
+            }
+            p = n.next.as_mut();
+        }
+        head
+    }
+}
+
+#[test]
+fn test() {
+    let p = ListNode::list(vec![1, 1, 2, 3, 3]);
+    let q = ListNode::list(vec![1, 2, 3]);
+    assert_eq!(Solution::delete_duplicates(p), q);
+}

src/_0169_majority_element.rs

@@ -0,0 +1,28 @@
+struct Solution;
+
+impl Solution {
+    pub fn majority_element(nums: Vec<i32>) -> i32 {
+        let mut current: i32 = nums[0];
+        let mut occur: i32 = 0;
+
+        for i in 0..nums.len() {
+            if nums[i] == current {
+                occur += 1;
+            } else {
+                occur -= 1;
+
+                if occur == 0 {
+                    current = nums[i];
+                    occur = 1;
+                }
+            }
+        }
+        current
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::majority_element(vec![3, 2, 3]), 3);
+    assert_eq!(Solution::majority_element(vec![2, 2, 1, 1, 1, 2, 2]), 2);
+}

src/_0189_rotate_array.rs

@@ -0,0 +1,17 @@
+struct Solution;
+
+impl Solution {
+    fn rotate(nums: &mut Vec<i32>, k: i32) {
+        let k = k as usize % nums.len();
+        nums[..].reverse();
+        nums[0..k].reverse();
+        nums[k..].reverse();
+    }
+}
+
+#[test]
+fn test() {
+    let mut nums = vec![1, 2, 3, 4, 5, 6, 7];
+    Solution::rotate(&mut nums, 3);
+    assert_eq!(nums, vec![5, 6, 7, 1, 2, 3, 4]);
+}

src/_0205_isomorphic_strings.rs

@@ -0,0 +1,41 @@
+struct Solution;
+
+impl Solution {
+    pub fn is_isomorphic(s: String, t: String) -> bool {
+        let s = s.as_bytes();
+        let t = t.as_bytes();
+
+        let mut s_to_t = vec![None; 256];
+        let mut t_seen = vec![false; 256];
+
+        for i in 0..s.len() {
+            if s_to_t[s[i] as usize].is_none() {
+                if t_seen[t[i] as usize] {
+                    return false;
+                } else {
+                    t_seen[t[i] as usize] = true;
+                }
+                s_to_t[s[i] as usize] = Some(t[i]);
+            } else if s_to_t[s[i] as usize] != Some(t[i]) {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::is_isomorphic("egg".to_string(), "add".to_string()),
+        true
+    );
+    assert_eq!(
+        Solution::is_isomorphic("foo".to_string(), "bar".to_string()),
+        false
+    );
+    assert_eq!(
+        Solution::is_isomorphic("paper".to_string(), "title".to_string()),
+        true
+    );
+}

src/_0243_shortest_word_distance.rs

@@ -0,0 +1,32 @@
+struct Solution;
+
+impl Solution {
+    pub fn shortest_distance(words: Vec<String>, word1: String, word2: String) -> i32 {
+        let mut pos_1: i32 = words.len() as i32;
+        let mut pos_2: i32 = words.len() as i32;
+        let mut diff: i32 = words.len() as i32;
+
+        for (i, word) in words.iter().enumerate() {
+            if word.eq(&word1) {
+                pos_1 = i as i32;
+                diff = (pos_2 - pos_1).abs().min(diff);
+            } else if word.eq(&word2) {
+                pos_2 = i as i32;
+                diff = (pos_2 - pos_1).abs().min(diff);
+            }
+        }
+        diff
+    }
+}
+
+#[test]
+fn test() {
+    let words: Vec<String> = vec_string!["practice", "makes", "perfect", "coding", "makes"];
+    let word1 = "coding".to_string();
+    let word2 = "practice".to_string();
+    assert_eq!(Solution::shortest_distance(words, word1, word2), 3);
+    let words: Vec<String> = vec_string!["practice", "makes", "perfect", "coding", "makes"];
+    let word1 = "makes".to_string();
+    let word2 = "coding".to_string();
+    assert_eq!(Solution::shortest_distance(words, word1, word2), 1);
+}

src/_0256_paint_house.rs

@@ -0,0 +1,25 @@
+struct Solution;
+
+impl Solution {
+    pub fn min_cost(mut costs: Vec<Vec<i32>>) -> i32 {
+        if costs.len() == 0 {
+            return 0;
+        }
+
+        for i in 1..costs.len() {
+            costs[i][0] += std::cmp::min(costs[i - 1][1], costs[i - 1][2]);
+            costs[i][1] += std::cmp::min(costs[i - 1][0], costs[i - 1][2]);
+            costs[i][2] += std::cmp::min(costs[i - 1][0], costs[i - 1][1]);
+        }
+
+        *costs[costs.len() - 1].iter().min().unwrap()
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::min_cost(vec![vec![17, 2, 17], vec![16, 16, 5], vec![14, 3, 19]]),
+        10
+    );
+}

src/_0283_move_zeroes.rs

@@ -0,0 +1,22 @@
+struct Solution;
+
+impl Solution {
+    pub fn move_zeroes(nums: &mut Vec<i32>) {
+        let mut j = 0;
+        for i in 0..nums.len() {
+            let x = nums[i];
+            if x != 0 {
+                nums[i] = 0;
+                nums[j] = x;
+                j += 1;
+            }
+        }
+    }
+}
+
+#[test]
+fn test() {
+    let mut nums = vec![0, 1, 0, 3, 12];
+    Solution::move_zeroes(&mut nums);
+    assert_eq!(nums, vec![1, 3, 12, 0, 0]);
+}

src/_0509_fibonacci_number.rs

@@ -0,0 +1,20 @@
+struct Solution;
+
+impl Solution {
+    pub fn fib(n: i32) -> i32 {
+        let mut num1: i32 = 0;
+        let mut num2: i32 = 1;
+        for _ in 0..n {
+            num1 += num2;
+            std::mem::swap(&mut num1, &mut num2);
+        }
+        num1
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::fib(2), 1);
+    assert_eq!(Solution::fib(3), 2);
+    assert_eq!(Solution::fib(4), 3);
+}

src/_0977_squares_of_a_sorted_array.rs

@@ -0,0 +1,44 @@
+struct Solution;
+
+impl Solution {
+    pub fn sorted_squares(a: Vec<i32>) -> Vec<i32> {
+        let mut left: usize = 0;
+        let mut right: usize = a.len() - 1;
+
+        let mut result: Vec<i32> = vec![0; a.len()];
+        let mut i: usize = a.len() - 1;
+
+        let mut left_result: i32;
+        let mut right_result: i32;
+
+        while left <= right {
+            left_result = a[left] * a[left];
+            right_result = a[right] * a[right];
+
+            if left_result >= right_result {
+                result[i] = left_result;
+                left += 1;
+            } else {
+                result[i] = right_result;
+                right -= 1;
+            }
+            if i > 0 {
+                i -= 1;
+            }
+        }
+        result
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::sorted_squares(vec![-4, -1, 0, 3, 10]),
+        vec![0, 1, 9, 16, 100]
+    );
+    assert_eq!(
+        Solution::sorted_squares(vec![-7, -3, 2, 3, 11]),
+        vec![4, 9, 9, 49, 121]
+    );
+    assert_eq!(Solution::sorted_squares(vec![1]), vec![1]);
+}

src/lib.rs

@@ -30,20 +30,36 @@ mod _0067_add_binary;
 //
 mod _0070_climbing_stairs;
 //
+mod _0083_remove_duplicates_from_sorted_list;
+//
 mod _0088_merge_sorted_array;
 //
 mod _0121_best_time_to_buy_and_sell_stock;
 //
 mod _0136_single_number;
 //
+mod _0169_majority_element;
+//
+mod _0189_rotate_array;
+//
 mod _0202_happy_number;
 //
 mod _0204_count_primes;
 //
+mod _0205_isomorphic_strings;
+//
+mod _0206_reverse_linked_list;
+//
 mod _0219_contains_duplicate_ii;
 //
+mod _0243_shortest_word_distance;
+//
+mod _0256_paint_house;
+//
 mod _0266_palindrome_permutation;
 //
+mod _0283_move_zeroes;
+//
 mod _0383_ransom_note;
 //
 mod _0412_fizz_buzz;
@@ -52,6 +68,8 @@ mod _0415_add_strings;
 //
 mod _0448_find_all_numbers_disappeared_in_an_array;
 //
+mod _0509_fibonacci_number;
+//
 mod _0557_reverse_words_in_a_string_iii;
 //
 mod _0605_can_place_flowers;
@@ -66,6 +84,8 @@ mod _0844_backspace_string_compare;
 //
 mod _0953_verifying_an_alien_dictionary;
 //
+mod _0977_squares_of_a_sorted_array;
+//
 mod _1281_subtract_the_product_and_sum_of_digits_of_an_integer;
 //
 mod _1287_element_appearing_more_than_25_in_sorted_array;