6-23-2020

Author: safrannn

src/_0009_palindrome_number.rs

@@ -0,0 +1,23 @@
+struct Solution;
+
+impl Solution {
+    pub fn is_palindrome(x: i32) -> bool {
+        if x < 0 {
+            return false;
+        }
+        let mut digits = Vec::new();
+        let mut number = x;
+        while number > 0 {
+            digits.push(number % 10);
+            number /= 10;
+        }
+        digits == digits.iter().copied().rev().collect::<Vec<i32>>()
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::is_palindrome(121), true);
+    assert_eq!(Solution::is_palindrome(-121), false);
+    assert_eq!(Solution::is_palindrome(10), false);
+}

src/_0067_add_binary.rs

@@ -0,0 +1,22 @@
+struct Solution;
+
+impl Solution {
+    pub fn add_binary(a: String, b: String) -> String {
+        let a_ = u128::from_str_radix(&a, 2).unwrap_or(0);
+        let b_ = u128::from_str_radix(&b, 2).unwrap_or(0);
+        format!("{:b}", a_ + b_)
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::add_binary("11".to_string(), "1".to_string()),
+        "100".to_string()
+    );
+
+    assert_eq!(
+        Solution::add_binary("1010".to_string(), "1011".to_string()),
+        "10101".to_string()
+    );
+}

src/_0070_climbing_stairs.rs

@@ -0,0 +1,25 @@
+struct Solution;
+
+impl Solution {
+    pub fn climb_stairs(n: i32) -> i32 {
+        match n {
+            0 => 1,
+            1 => 1,
+            _ => {
+                let mut step = vec![0 as i32; n as usize + 1];
+                step[0] = 1;
+                step[1] = 1;
+                for i in 2..=n {
+                    step[i as usize] = step[i as usize - 1] + step[i as usize - 2];
+                }
+                return step[n as usize];
+            }
+        }
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::climb_stairs(2), 2);
+    assert_eq!(Solution::climb_stairs(3), 3);
+}

src/_0121_best_time_to_buy_and_sell_stock.rs

@@ -0,0 +1,24 @@
+struct Solution;
+
+impl Solution {
+    pub fn max_profit(prices: Vec<i32>) -> i32 {
+        let mut min_value: i32 = std::i32::MAX;
+        let mut max_profit: i32 = 0;
+
+        for v in prices.into_iter() {
+            if v < min_value {
+                min_value = v - 0;
+            } else if v - min_value > max_profit {
+                max_profit = v - min_value;
+            }
+        }
+
+        max_profit
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::max_profit(vec![7, 1, 5, 3, 6, 4]), 5);
+    assert_eq!(Solution::max_profit(vec![7, 6, 4, 3, 1]), 0);
+}

src/_0136_single_number.rs

@@ -0,0 +1,17 @@
+struct Solution;
+
+impl Solution {
+    pub fn single_number(nums: Vec<i32>) -> i32 {
+        let mut result = 0;
+        for v in nums {
+            result ^= v;
+        }
+        result
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::single_number(vec![4, 1, 2, 1, 2]), 4);
+    assert_eq!(Solution::single_number(vec![2, 2, 1]), 1);
+}

src/_0204_count_primes.rs

@@ -0,0 +1,37 @@
+struct Solution;
+
+impl Solution {
+    pub fn count_primes(n: i32) -> i32 {
+        if n < 3 {
+            return 0;
+        }
+        let mut is_prime = vec![true; n as usize];
+        is_prime[0] = false;
+        is_prime[1] = false;
+        let mut i: usize = 2;
+        while i * i < n as usize {
+            if is_prime[i] {
+                let mut j = i * 2;
+                while j < n as usize {
+                    is_prime[j] = false;
+                    j += i;
+                }
+            }
+            i += 1;
+        }
+
+        let mut count: i32 = 0;
+        for v in is_prime {
+            if v {
+                count += 1;
+            }
+        }
+        count
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::count_primes(345), 68);
+    assert_eq!(Solution::count_primes(2), 0);
+}

src/_0219_contains_duplicate_ii.rs

@@ -0,0 +1,34 @@
+struct Solution;
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn contains_nearby_duplicate(nums: Vec<i32>, k: i32) -> bool {
+        let mut map: HashMap<i32, usize> = HashMap::new();
+        let k = k as usize;
+        for (i, v) in nums.into_iter().enumerate() {
+            if let Some(j) = map.get(&v) {
+                if i - j < k {
+                    return true;
+                }
+            }
+            map.insert(v, i);
+        }
+        false
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::contains_nearby_duplicate(vec![1, 2, 3, 1], 3),
+        true
+    );
+    assert_eq!(
+        Solution::contains_nearby_duplicate(vec![1, 0, 1, 1], 1),
+        true
+    );
+    assert_eq!(
+        Solution::contains_nearby_duplicate(vec![1, 2, 3, 1, 2, 3], 2),
+        false
+    );
+}

src/_0266_palindrome_permutation.rs

@@ -0,0 +1,31 @@
+struct Solution;
+
+impl Solution {
+    pub fn can_permute_palindrome(s: String) -> bool {
+        let mut count = vec![0 as u8; 256];
+        for v in s.chars() {
+            count[(v as u8 - 'a' as u8) as usize] += 1;
+        }
+        let mut switch = false;
+        for v in count {
+            if v % 2 != 0 {
+                if switch {
+                    return false;
+                } else {
+                    switch = true;
+                }
+            }
+        }
+        true
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::can_permute_palindrome("code".to_string()), false);
+    assert_eq!(Solution::can_permute_palindrome("aab".to_string()), true);
+    assert_eq!(
+        Solution::can_permute_palindrome("carerac".to_string()),
+        true
+    );
+}

src/_0412_fizz_buzz.rs

@@ -0,0 +1,31 @@
+struct Solution;
+// use vec_string;
+
+impl Solution {
+    pub fn fizz_buzz(n: i32) -> Vec<String> {
+        let mut result: Vec<String> = vec![];
+        let mut fizz: bool;
+        let mut buzz: bool;
+        for i in 1..=n {
+            fizz = i % 3 == 0;
+            buzz = i % 5 == 0;
+            let res = match (fizz, buzz) {
+                (true, true) => "FizzBuzz".to_string(),
+                (true, false) => "Fizz".to_string(),
+                (false, true) => "Buzz".to_string(),
+                (false, false) => format!("{}", i),
+            };
+            result.push(res);
+        }
+        result
+    }
+}
+
+#[test]
+fn test() {
+    let output: Vec<String> = vec_string![
+        "1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14",
+        "FizzBuzz"
+    ];
+    assert_eq!(Solution::fizz_buzz(15), output);
+}

src/_0557_reverse_words_in_a_string_iii.rs

@@ -0,0 +1,19 @@
+struct Solution;
+
+impl Solution {
+    pub fn reverse_words(s: String) -> String {
+        let mut result = vec![];
+        for v in s.split_whitespace().collect::<Vec<&str>>() {
+            result.push(v.chars().rev().collect::<String>());
+        }
+        result.join(" ")
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::reverse_words("Let's take LeetCode contest".to_string()),
+        "s'teL ekat edoCteeL tsetnoc".to_string()
+    );
+}

src/_0605_can_place_flowers.rs

@@ -0,0 +1,28 @@
+struct Solution;
+
+impl Solution {
+    pub fn can_place_flowers(flowerbed: Vec<i32>, n: i32) -> bool {
+        let mut zero_count: i32 = 1;
+        let mut count = 0;
+        let mut flowerbed = flowerbed;
+        flowerbed.push(0);
+        flowerbed.push(1);
+        print!("{:?}", flowerbed);
+
+        for v in flowerbed {
+            if v == 0 {
+                zero_count += 1;
+            } else {
+                count += (zero_count - 1) / 2;
+                zero_count = 0;
+            }
+        }
+        count >= n
+    }
+}
+
+#[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);
+}

src/_0680_valid_palindrome_ii.rs

@@ -0,0 +1,39 @@
+struct Solution;
+
+fn is_palindrome(s: &str) -> bool {
+    for (a, b) in s.chars().zip(s.chars().rev()) {
+        if a != b {
+            return false;
+        }
+    }
+    true
+}
+
+impl Solution {
+    pub fn valid_palindrome(s: String) -> bool {
+        let mut l: usize = 0;
+        let mut r: usize = s.len() - 1;
+        while l < r {
+            if s[l..=l] == s[r..=r] {
+                l += 1;
+                r -= 1;
+            } else if is_palindrome(&s[l..r]) {
+                return true;
+            } else if is_palindrome(&s[(l + 1)..=r]) {
+                return true;
+            } else {
+                return false;
+            }
+        }
+        true
+    }
+}
+#[test]
+fn test() {
+    let s = "aba".to_string();
+    assert_eq!(Solution::valid_palindrome(s), true);
+    let s = "abca".to_string();
+    assert_eq!(Solution::valid_palindrome(s), true);
+    let s = "accca".to_string();
+    assert_eq!(Solution::valid_palindrome(s), true);
+}

src/_0771_jewels_and_stones.rs

@@ -0,0 +1,30 @@
+struct Solution;
+
+impl Solution {
+    pub fn num_jewels_in_stones(j: String, s: String) -> i32 {
+        let mut jewels = vec![false; 58];
+        for v in j.chars() {
+            jewels[(v as u8 - 'A' as u8) as usize] = true;
+        }
+
+        let mut result: i32 = 0;
+        for v in s.chars() {
+            if jewels[(v as u8 - 'A' as u8) as usize] {
+                result += 1;
+            }
+        }
+        result
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::num_jewels_in_stones("aA".to_string(), "aAAbbbb".to_string()),
+        3
+    );
+    assert_eq!(
+        Solution::num_jewels_in_stones("z".to_string(), "ZZ".to_string()),
+        0
+    );
+}

src/_0796_rotate_string.rs

@@ -0,0 +1,25 @@
+struct Solution;
+
+impl Solution {
+    pub fn rotate_string(a: String, b: String) -> bool {
+        if a.len() != b.len() {
+            return false;
+        }
+        let mut pool = "".to_string();
+        pool += &a;
+        pool += &a;
+        pool.contains(&b)
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::rotate_string("abcde".to_string(), "cdeab".to_string()),
+        true
+    );
+    assert_eq!(
+        Solution::rotate_string("abcde".to_string(), "abced".to_string()),
+        false
+    );
+}