this week. Array

Author: BowMonkey

src/solution/mod.rs

@@ -12,3 +12,9 @@ mod s0169_majority_element;
 mod s0217_contains_duplicate;
 mod s0219_contains_duplicate_ii;
 mod s0228_summary_ranges;
+mod s0268_missing_number;
+mod s0283_move_zeroes;
+mod s0303_range_sum_query_immutable;
+mod s0409_longest_palindrome;
+mod s0349_intersection_of_two_arrays;
+mod s0350_intersection_of_two_arrays_ii;

src/solution/s0268_missing_number.rs

@@ -0,0 +1,68 @@
+/**
+ * [268] Missing Number
+ *
+ * Given an array nums containing n distinct numbers in the range [0, n], return the only number in the range that is missing from the array.
+ *  
+ * <strong class="example">Example 1:
+ *
+ * Input: nums = [3,0,1]
+ * Output: 2
+ * Explanation: n = 3 since there are 3 numbers, so all numbers are in the range [0,3]. 2 is the missing number in the range since it does not appear in nums.
+ *
+ * <strong class="example">Example 2:
+ *
+ * Input: nums = [0,1]
+ * Output: 2
+ * Explanation: n = 2 since there are 2 numbers, so all numbers are in the range [0,2]. 2 is the missing number in the range since it does not appear in nums.
+ *
+ * <strong class="example">Example 3:
+ *
+ * Input: nums = [9,6,4,2,3,5,7,0,1]
+ * Output: 8
+ * Explanation: n = 9 since there are 9 numbers, so all numbers are in the range [0,9]. 8 is the missing number in the range since it does not appear in nums.
+ *
+ *  
+ * Constraints:
+ *
+ * 	n == nums.length
+ * 	1 <= n <= 10^4
+ * 	0 <= nums[i] <= n
+ * 	All the numbers of nums are unique.
+ *
+ *  
+ * Follow up: Could you implement a solution using only O(1) extra space complexity and O(n) runtime complexity?
+ *
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/missing-number/
+// discuss: https://leetcode.com/problems/missing-number/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn missing_number(nums: Vec<i32>) -> i32 {
+        let total = nums.len() * (nums.len() + 1) / 2;
+        let mut sum = 0;
+        for n in 0..nums.len() {
+            sum += nums[n];
+        }
+        total as i32 - sum
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_268_1() {
+        assert_eq!(Solution::missing_number(vec![9, 6, 4, 2, 3, 5, 7, 0, 1]), 8)
+    }
+    #[test]
+    fn test_268_2() {
+        assert_eq!(Solution::missing_number(vec![0, 3, 1]), 2)
+    }
+}

src/solution/s0283_move_zeroes.rs

@@ -0,0 +1,77 @@
+/**
+ * [283] Move Zeroes
+ *
+ * Given an integer array nums, move all 0's to the end of it while maintaining the relative order of the non-zero elements.
+ * Note that you must do this in-place without making a copy of the array.
+ *  
+ * <strong class="example">Example 1:
+ * Input: nums = [0,1,0,3,12]
+ * Output: [1,3,12,0,0]
+ * <strong class="example">Example 2:
+ * Input: nums = [0]
+ * Output: [0]
+ *  
+ * Constraints:
+ *
+ * 	1 <= nums.length <= 10^4
+ * 	-2^31 <= nums[i] <= 2^31 - 1
+ *
+ *  
+ * Follow up: Could you minimize the total number of operations done?
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/move-zeroes/
+// discuss: https://leetcode.com/problems/move-zeroes/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+impl Solution {
+    pub fn move_zeroes(nums: &mut Vec<i32>) {
+        let mut end = 0;
+        for it in 0..nums.len() {
+            if nums[it] != 0 {
+                nums[end] = nums[it];
+                if it != end {
+                    nums[it] = 0;
+                }
+                end += 1;
+            }
+        }
+    }
+    pub fn move_zeroes_1(nums: &mut Vec<i32>) {
+        let mut start = 0;
+        let mut end = 0;
+        while end < nums.len() {
+            while start < nums.len() && nums[start] != 0 {
+                start += 1;
+            }
+            if start >= nums.len() {
+                return;
+            }
+            end = start;
+            while end < nums.len() && nums[end] == 0 {
+                end += 1;
+            }
+            if end >= nums.len() {
+                return;
+            }
+            nums.swap(start, end);
+            start += 1;
+        }
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_283() {
+        let mut v = vec![0, 1, 0, 3, 12];
+        let res = vec![1, 3, 12, 0, 0];
+        Solution::move_zeroes(&mut v);
+        assert_eq!(v, res);
+    }
+}

src/solution/s0303_range_sum_query_immutable.rs

@@ -0,0 +1,82 @@
+/**
+ * [303] Range Sum Query - Immutable
+ *
+ * Given an integer array nums, handle multiple queries of the following type:
+ * <ol>
+ * 	Calculate the sum of the elements of nums between indices left and right inclusive where left <= right.
+ * </ol>
+ * Implement the NumArray class:
+ * 
+ * 	NumArray(int[] nums) Initializes the object with the integer array nums.
+ * 	int sumRange(int left, int right) Returns the sum of the elements of nums between indices left and right inclusive (i.e. nums[left] + nums[left + 1] + ... + nums[right]).
+ * 
+ *  
+ * <strong class="example">Example 1:
+ * 
+ * Input
+ * ["NumArray", "sumRange", "sumRange", "sumRange"]
+ * [[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]
+ * Output
+ * [null, 1, -1, -3]
+ * Explanation
+ * NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
+ * numArray.sumRange(0, 2); // return (-2) + 0 + 3 = 1
+ * numArray.sumRange(2, 5); // return 3 + (-5) + 2 + (-1) = -1
+ * numArray.sumRange(0, 5); // return (-2) + 0 + 3 + (-5) + 2 + (-1) = -3
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	1 <= nums.length <= 10^4
+ * 	-10^5 <= nums[i] <= 10^5
+ * 	0 <= left <= right < nums.length
+ * 	At most 10^4 calls will be made to sumRange.
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/range-sum-query-immutable/
+// discuss: https://leetcode.com/problems/range-sum-query-immutable/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+struct NumArray {
+    preSum:Vec<i32>,
+    }
+
+
+/** 
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl NumArray {
+
+    fn new(nums: Vec<i32>) -> Self {
+        let mut preSum=vec![0;nums.len()+1];
+        for i in 1..=nums.len(){
+            preSum[i] = preSum[i-1] + nums[i-1];
+        }
+        Self{preSum}
+    }
+    
+    fn sum_range(&self, left: i32, right: i32) -> i32 {
+        self.preSum[(right+1) as usize] - self.preSum[left as usize]
+    }
+}
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * let obj = NumArray::new(nums);
+ * let ret_1: i32 = obj.sum_range(left, right);
+ */
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_303() {
+    }
+}

src/solution/s0349_intersection_of_two_arrays.rs

@@ -0,0 +1,61 @@
+/**
+ * [349] Intersection of Two Arrays
+ *
+ * Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must be unique and you may return the result in any order.
+ *  
+ * <strong class="example">Example 1:
+ *
+ * Input: nums1 = [1,2,2,1], nums2 = [2,2]
+ * Output: [2]
+ *
+ * <strong class="example">Example 2:
+ *
+ * Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
+ * Output: [9,4]
+ * Explanation: [4,9] is also accepted.
+ *
+ *  
+ * Constraints:
+ *
+ * 	1 <= nums1.length, nums2.length <= 1000
+ * 	0 <= nums1[i], nums2[i] <= 1000
+ *
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/intersection-of-two-arrays/
+// discuss: https://leetcode.com/problems/intersection-of-two-arrays/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+use std::collections::HashMap;
+impl Solution {
+    pub fn intersection(nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
+        let mut res: Vec<i32> = vec![];
+        let mut mp: HashMap<i32, i32> = HashMap::new();
+        //1. collect nums in nums1, set count to 1
+        for i in 0..nums1.len() {
+            mp.insert(nums1[i], 1);
+        }
+        //2. go through nums2
+        for i in 0..nums2.len() {
+            if let Some(&tmp) = mp.get(&nums2[i]) {
+                if tmp == 1 {
+                    res.push(nums2[i]);
+                }
+                mp.insert(nums2[i], tmp + 1);
+            }
+        }
+        res
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_349() {}
+}

src/solution/s0350_intersection_of_two_arrays_ii.rs

@@ -0,0 +1,76 @@
+/**
+ * [350] Intersection of Two Arrays II
+ *
+ * Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must appear as many times as it shows in both arrays and you may return the result in any order.
+ *  
+ * <strong class="example">Example 1:
+ *
+ * Input: nums1 = [1,2,2,1], nums2 = [2,2]
+ * Output: [2,2]
+ *
+ * <strong class="example">Example 2:
+ *
+ * Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
+ * Output: [4,9]
+ * Explanation: [9,4] is also accepted.
+ *
+ *  
+ * Constraints:
+ *
+ * 	1 <= nums1.length, nums2.length <= 1000
+ * 	0 <= nums1[i], nums2[i] <= 1000
+ *
+ *  
+ * Follow up:
+ *
+ * 	What if the given array is already sorted? How would you optimize your algorithm?
+ * 	What if nums1's size is small compared to nums2's size? Which algorithm is better?
+ * 	What if elements of nums2 are stored on disk, and the memory is limited such that you cannot load all elements into the memory at once?
+ *
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/intersection-of-two-arrays-ii/
+// discuss: https://leetcode.com/problems/intersection-of-two-arrays-ii/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+use std::collections::HashMap;
+impl Solution {
+    pub fn intersect(nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
+        let mut res: Vec<i32> = vec![];
+        let mut mp: HashMap<i32, i32> = HashMap::new();
+        //1. collect nums in nums1, record counts
+        for i in 0..nums1.len() {
+            match mp.get(&nums1[i]) {
+                Some(&cnt) => {
+                    mp.insert(nums1[i], cnt + 1);
+                }
+                None => {
+                    mp.insert(nums1[i], 1);
+                }
+            }
+        }
+        //2. go through nums2
+        for i in 0..nums2.len() {
+            if let Some(&cnt) = mp.get(&nums2[i]) {
+                res.push(nums2[i]);
+                if cnt - 1 <= 0 {
+                    mp.remove(&nums2[i]);
+                } else {
+                    mp.insert(nums2[i], cnt - 1);
+                }
+            }
+        }
+        res
+    }
+}
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_350() {}
+}