Merge pull request aylei#14 from mapx/master

Solve #792, #1013, and upgrade Cargo.lock

Author: aylei

Cargo.lock

@@ -234,3 +234,5 @@ mod n0309_best_time_to_buy_and_sell_stock_with_cooldown;
 mod n0310_minimum_height_trees;
 mod n0312_burst_balloons;
 mod n0313_super_ugly_number;
+mod n1013_fibonacci_number;
+mod n0792_binary_search;

src/lib.rs

@@ -49,12 +49,12 @@ fn main() {
             .next();
         if code.is_none() {
             println!("Problem {} has no rust version.", &id);
-            solved_ids.push(id);
+            solved_ids.push(problem.question_id);
             continue;
         }
         let code = code.unwrap();
 
-        let file_name = format!("n{:04}_{}", id, problem.title_slug.replace("-", "_"));
+        let file_name = format!("n{:04}_{}", problem.question_id, problem.title_slug.replace("-", "_"));
         let file_path = Path::new("./src").join(format!("{}.rs", file_name));
         if file_path.exists() {
             panic!("problem already initialized");
@@ -65,7 +65,7 @@ fn main() {
             .replace("__PROBLEM_TITLE__", &problem.title)
             .replace("__PROBLEM_DESC__", &build_desc(&problem.content))
             .replace("__PROBLEM_DEFAULT_CODE__", &code.default_code)
-            .replace("__PROBLEM_ID__", &format!("{}", id))
+            .replace("__PROBLEM_ID__", &format!("{}", problem.question_id))
             .replace("__EXTRA_USE__", &parse_extra_use(&code.default_code));
 
         let mut file = fs::OpenOptions::new()

src/main.rs

@@ -0,0 +1,80 @@
+/**
+ * [792] Binary Search
+ *
+ * Given a sorted (in ascending order) integer array nums of n elements and a target value, write a function to search target in nums. If target exists, then return its index, otherwise return -1.
+ *
+ * <br />
+ * Example 1:
+ *
+ *
+ * Input: nums = [-1,0,3,5,9,12], target = 9
+ * Output: 4
+ * Explanation: 9 exists in nums and its index is 4
+ *
+ *
+ *
+ * Example 2:
+ *
+ *
+ * Input: nums = [-1,0,3,5,9,12], target = 2
+ * Output: -1
+ * Explanation: 2 does not exist in nums so return -1
+ *
+ *
+ *  
+ *
+ * Note:
+ *
+ * <ol>
+ * 	You may assume that all elements in nums are unique.
+ * 	n will be in the range [1, 10000].
+ * 	The value of each element in nums will be in the range [-9999, 9999].
+ * </ol>
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+use std::cmp::Ordering;
+
+impl Solution {
+    pub fn search(nums: Vec<i32>, target: i32) -> i32 {
+        let mut lo = 0i32;
+        let mut hi = (nums.len() as i32) - 1;
+        while lo <= hi {
+            let mid = lo + (hi - lo) / 2;
+            match nums[mid as usize].cmp(&target) {
+                Ordering::Less => {
+                    lo = mid + 1;
+                }
+                Ordering::Greater => {
+                    hi = mid - 1;
+                }
+                Ordering::Equal => {
+                    return mid;
+                }
+            }
+        }
+        -1
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_792() {
+        assert_eq!(Solution::search(vec![-1, 0, 3, 5, 9, 12], 9), 4);
+        assert_eq!(Solution::search(vec![-1, 0, 3, 5, 9, 12], 2), -1);
+        assert_eq!(Solution::search(vec![1], 1), 0);
+        assert_eq!(Solution::search(vec![5], -5), -1);
+        assert_eq!(Solution::search(vec![5], 6), -1);
+        assert_eq!(Solution::search(vec![1, 2], 0), -1);
+        assert_eq!(Solution::search(vec![1, 2], 1), 0);
+        assert_eq!(Solution::search(vec![1, 2], 2), 1);
+        assert_eq!(Solution::search(vec![1, 2], 3), -1);
+    }
+}

src/n0792_binary_search.rs

@@ -0,0 +1,75 @@
+/**
+ * [1013] Fibonacci Number
+ *
+ * The Fibonacci numbers, commonly denoted F(n) form a sequence, called the Fibonacci sequence, such that each number is the sum of the two preceding ones, starting from 0 and 1. That is,
+ *
+ *
+ * F(0) = 0,   F(1) = 1
+ * F(N) = F(N - 1) + F(N - 2), for N > 1.
+ *
+ *
+ * Given N, calculate F(N).
+ *
+ *  
+ *
+ * Example 1:
+ *
+ *
+ * Input: 2
+ * Output: 1
+ * Explanation: F(2) = F(1) + F(0) = 1 + 0 = 1.
+ *
+ *
+ * Example 2:
+ *
+ *
+ * Input: 3
+ * Output: 2
+ * Explanation: F(3) = F(2) + F(1) = 1 + 1 = 2.
+ *
+ *
+ * Example 3:
+ *
+ *
+ * Input: 4
+ * Output: 3
+ * Explanation: F(4) = F(3) + F(2) = 2 + 1 = 3.
+ *
+ *
+ *  
+ *
+ * Note:
+ *
+ * 0 ≤ N ≤ 30.
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn fib(n: i32) -> i32 {
+        if n == 0 {
+            return 0;
+        }
+        let mut f = (0, 1);
+        for _ in 1..n {
+            f = (f.1, f.0 + f.1);
+        }
+        return f.1;
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1013() {
+        assert_eq!(Solution::fib(2), 1);
+        assert_eq!(Solution::fib(3), 2);
+        assert_eq!(Solution::fib(4), 3);
+    }
+}

src/n1013_fibonacci_number.rs

@@ -0,0 +1,102 @@
+/**
+ * [1071] Binary Prefix Divisible By 5
+ *
+ * Given an array A of 0s and 1s, consider N_i: the i-th subarray from A[0] to A[i] interpreted as a binary number (from most-significant-bit to least-significant-bit.)
+ *
+ * Return a list of booleans answer, where answer[i] is true if and only if N_i is divisible by 5.
+ *
+ * Example 1:
+ *
+ *
+ * Input: <span id="example-input-1-1">[0,1,1]</span>
+ * Output: <span id="example-output-1">[true,false,false]</span>
+ * Explanation:
+ * The input numbers in binary are 0, 01, 011; which are 0, 1, and 3 in base-10.  Only the first number is divisible by 5, so answer[0] is true.
+ *
+ *
+ * Example 2:
+ *
+ *
+ * Input: <span id="example-input-2-1">[1,1,1]</span>
+ * Output: <span id="example-output-2">[false,false,false]</span>
+ *
+ *
+ * Example 3:
+ *
+ *
+ * Input: <span id="example-input-3-1">[0,1,1,1,1,1]</span>
+ * Output: <span id="example-output-3">[true,false,false,false,true,false]</span>
+ *
+ *
+ * Example 4:
+ *
+ *
+ * Input: <span id="example-input-4-1">[1,1,1,0,1]</span>
+ * Output: <span id="example-output-4">[false,false,false,false,false]</span>
+ *
+ *
+ *  
+ *
+ * Note:
+ *
+ * <ol>
+ * 	1 <= A.length <= 30000
+ * 	A[i] is 0 or 1
+ * </ol>
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn prefixes_div_by5(a: Vec<i32>) -> Vec<bool> {
+        let mut ret = vec![];
+        let mut n = 0;
+        for i in a {
+            let remain = (n * 2 + i) % 5;
+            ret.push(remain == 0);
+            n = remain;
+        }
+        return ret;
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1071() {
+        assert_eq!(
+            Solution::prefixes_div_by5(vec![0, 1, 1]),
+            vec![true, false, false]
+        );
+        assert_eq!(
+            Solution::prefixes_div_by5(vec![1, 1, 1]),
+            vec![false, false, false]
+        );
+        assert_eq!(
+            Solution::prefixes_div_by5(vec![0, 1, 1, 1, 1, 1]),
+            vec![true, false, false, false, true, false]
+        );
+        assert_eq!(
+            Solution::prefixes_div_by5(vec![1, 1, 1, 0, 1]),
+            vec![false, false, false, false, false]
+        );
+        assert_eq!(
+            Solution::prefixes_div_by5(vec![
+                1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0,
+                0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1
+            ]),
+            vec![
+                false, false, false, false, false, false, false, false, false, false, false, false,
+                false, false, false, false, false, false, false, false, false, false, false, false,
+                false, false, false, false, false, false, false, true, false, false, true, true,
+                true, true, false
+            ]
+        );
+    }
+}

src/n1071_binary_prefix_divisible_by_5.rs

@@ -0,0 +1,75 @@
+/**
+ * [1127] Last Stone Weight
+ *
+ * We have a collection of rocks, each rock has a positive integer weight.
+ *
+ * Each turn, we choose the two heaviest rocks and smash them together.  Suppose the stones have weights x and y with x <= y.  The result of this smash is:
+ *
+ *
+ * 	If x == y, both stones are totally destroyed;
+ * 	If x != y, the stone of weight x is totally destroyed, and the stone of weight y has new weight y-x.
+ *
+ *
+ * At the end, there is at most 1 stone left.  Return the weight of this stone (or 0 if there are no stones left.)
+ *
+ *  
+ *
+ * Example 1:
+ *
+ *
+ * Input: [2,7,4,1,8,1]
+ * Output: 1
+ * Explanation:
+ * We combine 7 and 8 to get 1 so the array converts to [2,4,1,1,1] then,
+ * we combine 2 and 4 to get 2 so the array converts to [2,1,1,1] then,
+ * we combine 2 and 1 to get 1 so the array converts to [1,1,1] then,
+ * we combine 1 and 1 to get 0 so the array converts to [1] then that's the value of last stone.
+ *
+ *  
+ *
+ * Note:
+ *
+ * <ol>
+ * 	1 <= stones.length <= 30
+ * 	1 <= stones[i] <= 1000
+ * </ol>
+ */
+pub struct Solution {}
+use std::collections::BinaryHeap;
+
+// submission codes start here
+
+impl Solution {
+    pub fn last_stone_weight(stones: Vec<i32>) -> i32 {
+        let mut heap = BinaryHeap::new();
+        heap.extend(stones);
+        loop {
+            if let Some(rock1) = heap.pop() {
+                if let Some(rock2) = heap.pop() {
+                    if rock1 > rock2 {
+                        heap.push(rock1 - rock2);
+                    }
+                } else {
+                    return rock1;
+                }
+            } else {
+                return 0;
+            }
+        }
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1127() {
+        assert_eq!(Solution::last_stone_weight(vec![2, 7, 4, 1, 8, 1]), 1);
+        assert_eq!(Solution::last_stone_weight(vec![2]), 2);
+        assert_eq!(Solution::last_stone_weight(vec![2, 2]), 0);
+        assert_eq!(Solution::last_stone_weight(vec![1, 2, 2]), 1);
+    }
+}

src/n1127_last_stone_weight.rs

@@ -17,10 +17,10 @@ query questionData($titleSlug: String!) {
 }"#;
 const QUESTION_QUERY_OPERATION: &str = "questionData";
 
-pub fn get_problem(id: u32) -> Option<Problem> {
+pub fn get_problem(frontend_question_id: u32) -> Option<Problem> {
     let problems = get_problems().unwrap();
     for problem in problems.stat_status_pairs.iter() {
-        if problem.stat.question_id == id {
+        if problem.stat.frontend_question_id == frontend_question_id {
 
             if problem.paid_only {
                 return None
@@ -38,6 +38,7 @@ pub fn get_problem(id: u32) -> Option<Problem> {
                 content: resp.data.question.content,
                 sample_test_case: resp.data.question.sample_test_case,
                 difficulty: problem.difficulty.to_string(),
+                question_id: problem.stat.question_id,
             })
         }
     }
@@ -58,6 +59,7 @@ pub struct Problem {
     #[serde(rename = "sampleTestCase")]
     pub sample_test_case: String,
     pub difficulty: String,
+    pub question_id: u32,
 }
 
 #[derive(Serialize, Deserialize)]