8-8-2020

Author: safrannn

src/_1496_path_crossing.rs

@@ -0,0 +1,34 @@
+struct Solution;
+
+use std::collections::HashSet;
+
+impl Solution {
+    pub fn is_path_crossing(path: String) -> bool {
+        let mut position: (i32, i32) = (0, 0);
+        let mut h_set: HashSet<(i32, i32)> = HashSet::new();
+        h_set.insert((0, 0));
+        for h_move in path.chars() {
+            match h_move {
+                'N' => position.1 -= 1,
+                'S' => position.1 += 1,
+                'E' => position.0 += 1,
+                'W' => position.0 -= 1,
+                _ => {}
+            }
+            if !h_set.insert(position) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::is_path_crossing("NNSWWEWSSESSWENNW".to_string()),
+        true
+    );
+    assert_eq!(Solution::is_path_crossing("NES".to_string()), false);
+    assert_eq!(Solution::is_path_crossing("NESWW".to_string()), true);
+}

src/_1539_kth_missing_positive_number.rs

@@ -0,0 +1,24 @@
+struct Solution;
+
+impl Solution {
+    pub fn find_kth_positive(arr: Vec<i32>, k: i32) -> i32 {
+        let mut arr = arr;
+        let mut k = k;
+        let mut h_dummy: i32 = 1;
+        let mut index: usize = 0;
+        while k > 0 {
+            if index < arr.len() && h_dummy == arr[index] {
+                index += 1;
+            } else {
+                k -= 1;
+            }
+            h_dummy += 1;
+        }
+        h_dummy - 1
+    }
+}
+#[test]
+fn test() {
+    assert_eq!(Solution::find_kth_positive(vec![2, 3, 4, 7, 11], 5), 9);
+    assert_eq!(Solution::find_kth_positive(vec![1, 2, 3, 4], 2), 6);
+}

src/_1540_can_convert_string_in_k_moves.rs

@@ -0,0 +1,51 @@
+struct Solution;
+
+impl Solution {
+    pub fn can_convert_string(s: String, t: String, k: i32) -> bool {
+        let mut h_shift: Vec<i32> = vec![-1; 26];
+        let n_s = s.len();
+        let n_t = t.len();
+        let s_char: Vec<char> = s.chars().collect();
+        let t_char: Vec<char> = t.chars().collect();
+        if n_s != n_t {
+            return false;
+        }
+
+        for i in 0..n_s {
+            if s_char[i] == t_char[i] {
+                continue;
+            } else {
+                let mut h_diff = t_char[i] as i32 - s_char[i] as i32;
+                if h_diff < 0 {
+                    h_diff += 26;
+                }
+                let h_diff: usize = h_diff as usize % 26;
+                if h_shift[h_diff] > 0 {
+                    h_shift[h_diff] += 26;
+                } else {
+                    h_shift[h_diff] = h_diff as i32;
+                }
+                if h_shift[h_diff] > k {
+                    return false;
+                }
+            }
+        }
+        true
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::can_convert_string("input".to_string(), "output".to_string(), 9),
+        true
+    );
+    assert_eq!(
+        Solution::can_convert_string("abc".to_string(), "bcd".to_string(), 10),
+        false
+    );
+    assert_eq!(
+        Solution::can_convert_string("aab".to_string(), "bbb".to_string(), 27),
+        true
+    );
+}

src/lib.rs

@@ -202,10 +202,14 @@ mod _1304_find_n_unique_integers_sum_up_to_zero;
 //
 mod _1486_xor_operation_in_an_array;
 //
+mod _1496_path_crossing;
+//
 mod _1528_shuffle_string;
 //
 mod _1534_count_good_triplets;
 //
 mod _1535_find_the_winner_of_an_array_game;
 //
 mod _1537_get_the_maximum_score;
+//
+mod _1540_can_convert_string_in_k_moves;