solve aylei#26 aylei#27 aylei#28

Author: aylei

src/lib.rs

@@ -25,3 +25,7 @@ mod n0022_generate_parentheses;
 mod n0023_merge_k_sorted_lists;
 mod n0024_swap_nodes_in_pairs;
 mod n0025_reverse_nodes_in_k_group;
+mod n0026_remove_duplicates_from_sorted_array;
+mod n0027_remove_element;
+mod n0028_implement_strstr;
+mod n0029_divide_two_integers;

src/n0026_remove_duplicates_from_sorted_array.rs

@@ -0,0 +1,73 @@
+/**
+ * [26] Remove Duplicates from Sorted Array
+ *
+ * Given a sorted array nums, remove the duplicates <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in-place</a> such that each element appear only once and return the new length.
+ * 
+ * Do not allocate extra space for another array, you must do this by modifying the input array <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in-place</a> with O(1) extra memory.
+ * 
+ * Example 1:
+ * 
+ * 
+ * Given nums = [1,1,2],
+ * 
+ * Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.
+ * 
+ * It doesn't matter what you leave beyond the returned length.
+ * 
+ * Example 2:
+ * 
+ * 
+ * Given nums = [0,0,1,1,1,2,2,3,3,4],
+ * 
+ * Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively.
+ * 
+ * It doesn't matter what values are set beyond the returned length.
+ * 
+ * 
+ * Clarification:
+ * 
+ * Confused why the returned value is an integer but your answer is an array?
+ * 
+ * Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well.
+ * 
+ * Internally you can think of this:
+ * 
+ * 
+ * // nums is passed in by reference. (i.e., without making a copy)
+ * int len = removeDuplicates(nums);
+ * 
+ * // any modification to nums in your function would be known by the caller.
+ * // using the length returned by your function, it prints the first len elements.
+ * for (int i = 0; i < len; i++) {
+ *     print(nums[i]);
+ * }
+ * 
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn remove_duplicates(nums: &mut Vec<i32>) -> i32 {
+        nums.dedup();
+        nums.len() as i32
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_26() {
+        assert_eq!(Solution::remove_duplicates(&mut vec![]), 0);
+        let mut vec1 = vec![1,1,1,1,3];
+        assert_eq!(Solution::remove_duplicates(&mut vec1), 2);
+        assert_eq!(vec1, vec![1,3]);
+        let mut vec2 = vec![1,1,2];
+        assert_eq!(Solution::remove_duplicates(&mut vec2), 2);
+        assert_eq!(vec2, vec![1,2]);
+    }
+}

src/n0027_remove_element.rs

@@ -0,0 +1,86 @@
+/**
+ * [27] Remove Element
+ *
+ * Given an array nums and a value val, remove all instances of that value <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in-place</a> and return the new length.
+ * 
+ * Do not allocate extra space for another array, you must do this by modifying the input array <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in-place</a> with O(1) extra memory.
+ * 
+ * The order of elements can be changed. It doesn't matter what you leave beyond the new length.
+ * 
+ * Example 1:
+ * 
+ * 
+ * Given nums = [3,2,2,3], val = 3,
+ * 
+ * Your function should return length = 2, with the first two elements of nums being 2.
+ * 
+ * It doesn't matter what you leave beyond the returned length.
+ * 
+ * 
+ * Example 2:
+ * 
+ * 
+ * Given nums = [0,1,2,2,3,0,4,2], val = 2,
+ * 
+ * Your function should return length = 5, with the first five elements of nums containing 0, 1, 3, 0, and 4.
+ * 
+ * Note that the order of those five elements can be arbitrary.
+ * 
+ * It doesn't matter what values are set beyond the returned length.
+ * 
+ * Clarification:
+ * 
+ * Confused why the returned value is an integer but your answer is an array?
+ * 
+ * Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well.
+ * 
+ * Internally you can think of this:
+ * 
+ * 
+ * // nums is passed in by reference. (i.e., without making a copy)
+ * int len = removeElement(nums, val);
+ * 
+ * // any modification to nums in your function would be known by the caller.
+ * // using the length returned by your function, it prints the first len elements.
+ * for (int i = 0; i < len; i++) {
+ *     print(nums[i]);
+ * }
+ * 
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn remove_element(nums: &mut Vec<i32>, val: i32) -> i32 {
+        if nums.len() < 1 { return 0 }
+        let (mut start, mut end) = (0_usize, nums.len()-1);
+        while start < end {
+            if nums[start] == val {
+                nums[start] = nums[end-1];
+                end -= 1;
+            } else {
+                start += 1;
+            }
+        }
+        end as i32
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_27() {
+        let mut vec1 = vec![0,1,2,2,3,0,4,2];
+        assert_eq!(Solution::remove_element(&mut vec1, 2), 5);
+        assert_eq!(vec1[0..5], [0,1,4,0,3]);
+        assert_eq!(Solution::remove_element(&mut vec![], 2), 0);
+        assert_eq!(Solution::remove_element(&mut vec![1,2,2,2,2,2,2], 2), 1);
+        assert_eq!(Solution::remove_element(&mut vec![2,2,2,2,2,2,2], 2), 0);
+        assert_eq!(Solution::remove_element(&mut vec![1], 1), 0);
+    }
+}

src/n0028_implement_strstr.rs

@@ -0,0 +1,50 @@
+/**
+ * [28] Implement strStr()
+ *
+ * Implement <a href="http://www.cplusplus.com/reference/cstring/strstr/" target="_blank">strStr()</a>.
+ * 
+ * Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.
+ * 
+ * Example 1:
+ * 
+ * 
+ * Input: haystack = "hello", needle = "ll"
+ * Output: 2
+ * 
+ * 
+ * Example 2:
+ * 
+ * 
+ * Input: haystack = "aaaaa", needle = "bba"
+ * Output: -1
+ * 
+ * 
+ * Clarification:
+ * 
+ * What should we return when needle is an empty string? This is a great question to ask during an interview.
+ * 
+ * For the purpose of this problem, we will return 0 when needle is an empty string. This is consistent to C's <a href="http://www.cplusplus.com/reference/cstring/strstr/" target="_blank">strstr()</a> and Java's <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#indexOf(java.lang.String)" target="_blank">indexOf()</a>.
+ * 
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn str_str(haystack: String, needle: String) -> i32 {
+        if needle.is_empty() { return 0 }
+        haystack.find(&needle).map_or(-1_i32, |v| v as i32)
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_28() {
+        assert_eq!(Solution::str_str("hello".to_string(), "ll".to_string()), 2)
+    }
+}

src/n0029_divide_two_integers.rs

@@ -0,0 +1,50 @@
+/**
+ * [29] Divide Two Integers
+ *
+ * Given two integers dividend and divisor, divide two integers without using multiplication, division and mod operator.
+ * 
+ * Return the quotient after dividing dividend by divisor.
+ * 
+ * The integer division should truncate toward zero.
+ * 
+ * Example 1:
+ * 
+ * 
+ * Input: dividend = 10, divisor = 3
+ * Output: 3
+ * 
+ * Example 2:
+ * 
+ * 
+ * Input: dividend = 7, divisor = -3
+ * Output: -2
+ * 
+ * Note:
+ * 
+ * 
+ * 	Both dividend and divisor will be 32-bit signed integers.
+ * 	The divisor will never be 0.
+ * 	Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [-2^31,  2^31 - 1]. For the purpose of this problem, assume that your function returns 2^31 - 1 when the division result overflows.
+ * 
+ * 
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn divide(dividend: i32, divisor: i32) -> i32 {
+        
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_29() {
+    }
+}