6-25-2020

Author: safrannn

src/_0066_plus_one.rs

@@ -0,0 +1,24 @@
+struct Solution;
+
+impl Solution {
+    pub fn plus_one(digits: Vec<i32>) -> Vec<i32> {
+        let mut carry: i32 = 1;
+        let mut sum: i32;
+        let mut result: Vec<i32> = Vec::new();
+        for v in digits.iter().rev() {
+            sum = carry + v;
+            carry = sum / 10;
+            sum = sum % 10;
+            result.insert(0, sum);
+        }
+        if carry != 0 {
+            result.insert(0, carry);
+        }
+        result
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::plus_one(vec![1, 2, 3]), vec![1, 2, 4]);
+}

src/_0206_reverse_linked_list.rs

@@ -0,0 +1,23 @@
+struct Solution;
+use crate::util::*;
+
+impl Solution {
+    pub fn reverse_list(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        let mut p = head;
+        let mut prev = None;
+        while let Some(mut node) = p {
+            p = node.next;
+            node.next = prev;
+            prev = Some(node);
+        }
+        prev
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::reverse_list(ListNode::list(vec![1, 2, 3, 4, 5])),
+        ListNode::list(vec![5, 4, 3, 2, 1])
+    );
+}

src/_0219_contains_duplicate_ii.rs

@@ -7,7 +7,7 @@ impl Solution {
         let k = k as usize;
         for (i, v) in nums.into_iter().enumerate() {
             if let Some(j) = map.get(&v) {
-                if i - j < k {
+                if i - j <= k {
                     return true;
                 }
             }

src/_0383_ransom_note.rs

@@ -0,0 +1,33 @@
+struct Solution;
+
+impl Solution {
+    pub fn can_construct(ransom_note: String, magazine: String) -> bool {
+        let mut characters = vec![0 as i32; 26];
+        for v in magazine.chars() {
+            characters[(v as u8 - 'a' as u8) as usize] += 1;
+        }
+        for v in ransom_note.chars() {
+            if characters[(v as u8 - 'a' as u8) as usize] == 0 {
+                return false;
+            }
+            characters[(v as u8 - 'a' as u8) as usize] -= 1;
+        }
+        true
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::can_construct("a".to_string(), "b".to_string()),
+        false
+    );
+    assert_eq!(
+        Solution::can_construct("aa".to_string(), "ab".to_string()),
+        false
+    );
+    assert_eq!(
+        Solution::can_construct("aa".to_string(), "aab".to_string()),
+        true
+    );
+}

src/_0448_find_all_numbers_disappeared_in_an_array.rs

@@ -0,0 +1,28 @@
+struct Solution;
+
+impl Solution {
+    pub fn find_disappeared_numbers(nums: Vec<i32>) -> Vec<i32> {
+        let mut nums = nums;
+        for i in 0..nums.len() {
+            let index: usize = nums[i].abs() as usize - 1;
+            if nums[index] > 0 {
+                nums[index] *= -1;
+            }
+        }
+        let mut result = vec![];
+        for (i, &v) in nums.iter().enumerate() {
+            if v > 0 {
+                result.push(i as i32 + 1);
+            }
+        }
+        result
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::find_disappeared_numbers(vec![4, 3, 2, 7, 8, 2, 3, 1]),
+        vec![5, 6]
+    );
+}

src/_0605_can_place_flowers.rs

@@ -24,5 +24,8 @@ impl Solution {
 #[test]
 fn test() {
     assert_eq!(Solution::can_place_flowers(vec![1, 0, 0, 0, 1], 1), true);
-    assert_eq!(Solution::can_place_flowers(vec![1, 0, 0, 0, 1], 2), true);
+    assert_eq!(
+        Solution::can_place_flowers(vec![1, 0, 0, 0, 0, 1], 2),
+        false
+    );
 }

src/lib.rs

@@ -24,6 +24,8 @@ mod _0021_merge_two_sorted_lists;
 //
 mod _0053_maximum_subarray;
 //
+mod _0066_plus_one;
+//
 mod _0067_add_binary;
 //
 mod _0070_climbing_stairs;
@@ -38,14 +40,22 @@ mod _0202_happy_number;
 //
 mod _0204_count_primes;
 //
+mod _0219_contains_duplicate_ii;
+//
 mod _0266_palindrome_permutation;
 //
+mod _0383_ransom_note;
+//
 mod _0412_fizz_buzz;
 //
 mod _0415_add_strings;
 //
+mod _0448_find_all_numbers_disappeared_in_an_array;
+//
 mod _0557_reverse_words_in_a_string_iii;
 //
+mod _0605_can_place_flowers;
+//
 mod _0680_valid_palindrome_ii;
 //
 mod _0771_jewels_and_stones;