fix: compiler error

Author: lidongjies

Cargo.lock

@@ -1,18 +1,18 @@
 [package]
 name = "leetcode-rust"
 version = "0.1.0"
-authors = ["alei <rayingecho@gmail.com>"]
+authors = ["lidongjies <lidongjies@gmail.com>"]
 edition = "2018"
 
 [dependencies]
-reqwest = "0.9.8"
+reqwest = { version = "0.11.11", features = ["json", "blocking"] }
 serde = "1.0"
 serde_json = "1.0"
 serde_derive = "1.0"
-rand = "0.6.5"
+rand = "0.8.5"
 regex = "1.3.4"
-futures = { version = "0.3.3", features = ["thread-pool"] }
-surf = "1.0.3"
+futures = { version = "0.3.21", features = ["thread-pool"] }
+surf = "2.3.2"
 
 [lib]
 doctest = false

Cargo.toml

@@ -26,7 +26,7 @@ pub fn get_problem(frontend_question_id: u32) -> Option<Problem> {
                 return None;
             }
 
-            let client = reqwest::Client::new();
+            let client = reqwest::blocking::Client::new();
             let resp: RawProblem = client
                 .post(GRAPHQL_URL)
                 .json(&Query::question_query(
@@ -97,7 +97,10 @@ pub async fn get_problem_async(problem_stat: StatWithStatus) -> Option<Problem>
 }
 
 pub fn get_problems() -> Option<Problems> {
-    reqwest::get(PROBLEMS_URL).unwrap().json().unwrap()
+    reqwest::blocking::get(PROBLEMS_URL)
+        .unwrap()
+        .json()
+        .unwrap()
 }
 
 #[derive(Serialize, Deserialize)]

src/fetcher.rs

@@ -152,7 +152,7 @@ fn generate_random_id(except_ids: &[u32]) -> u32 {
     use std::fs;
     let mut rng = rand::thread_rng();
     loop {
-        let res: u32 = rng.gen_range(1, 1106);
+        let res: u32 = rng.gen_range(1..1106);
         if !except_ids.contains(&res) {
             return res;
         }

src/main.rs

@@ -0,0 +1,72 @@
+/**
+ * [100] Same Tree
+ *
+ * Given the roots of two binary trees p and q, write a function to check if they are the same or not.
+ * Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.
+ *  
+ * Example 1:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2020/12/20/ex1.jpg" style="width: 622px; height: 182px;" />
+ * Input: p = [1,2,3], q = [1,2,3]
+ * Output: true
+ * 
+ * Example 2:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2020/12/20/ex2.jpg" style="width: 382px; height: 182px;" />
+ * Input: p = [1,2], q = [1,null,2]
+ * Output: false
+ * 
+ * Example 3:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2020/12/20/ex3.jpg" style="width: 622px; height: 182px;" />
+ * Input: p = [1,2,1], q = [1,1,2]
+ * Output: false
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	The number of nodes in both trees is in the range [0, 100].
+ * 	-10^4 <= Node.val <= 10^4
+ * 
+ */
+pub struct Solution {}
+use crate::util::tree::{TreeNode, to_tree};
+
+// problem: https://leetcode.com/problems/same-tree/
+// discuss: https://leetcode.com/problems/same-tree/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+// 
+// impl TreeNode {
+//   #[inline]
+//   pub fn new(val: i32) -> Self {
+//     TreeNode {
+//       val,
+//       left: None,
+//       right: None
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn is_same_tree(p: Option<Rc<RefCell<TreeNode>>>, q: Option<Rc<RefCell<TreeNode>>>) -> bool {
+        false
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_100() {
+    }
+}

src/problem/p0100_same_tree.rs

@@ -0,0 +1,68 @@
+/**
+ * [101] Symmetric Tree
+ *
+ * Given the root of a binary tree, check whether it is a mirror of itself (i.e., symmetric around its center).
+ *  
+ * Example 1:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/symtree1.jpg" style="width: 354px; height: 291px;" />
+ * Input: root = [1,2,2,3,4,4,3]
+ * Output: true
+ * 
+ * Example 2:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/symtree2.jpg" style="width: 308px; height: 258px;" />
+ * Input: root = [1,2,2,null,3,null,3]
+ * Output: false
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	The number of nodes in the tree is in the range [1, 1000].
+ * 	-100 <= Node.val <= 100
+ * 
+ *  
+ * Follow up: Could you solve it both recursively and iteratively?
+ */
+pub struct Solution {}
+use crate::util::tree::{TreeNode, to_tree};
+
+// problem: https://leetcode.com/problems/symmetric-tree/
+// discuss: https://leetcode.com/problems/symmetric-tree/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+// 
+// impl TreeNode {
+//   #[inline]
+//   pub fn new(val: i32) -> Self {
+//     TreeNode {
+//       val,
+//       left: None,
+//       right: None
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn is_symmetric(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
+        false
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_101() {
+    }
+}

src/problem/p0101_symmetric_tree.rs

@@ -0,0 +1,71 @@
+/**
+ * [102] Binary Tree Level Order Traversal
+ *
+ * Given the root of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level).
+ *  
+ * Example 1:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg" style="width: 277px; height: 302px;" />
+ * Input: root = [3,9,20,null,null,15,7]
+ * Output: [[3],[9,20],[15,7]]
+ * 
+ * Example 2:
+ * 
+ * Input: root = [1]
+ * Output: [[1]]
+ * 
+ * Example 3:
+ * 
+ * Input: root = []
+ * Output: []
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	The number of nodes in the tree is in the range [0, 2000].
+ * 	-1000 <= Node.val <= 1000
+ * 
+ */
+pub struct Solution {}
+use crate::util::tree::{TreeNode, to_tree};
+
+// problem: https://leetcode.com/problems/binary-tree-level-order-traversal/
+// discuss: https://leetcode.com/problems/binary-tree-level-order-traversal/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+// 
+// impl TreeNode {
+//   #[inline]
+//   pub fn new(val: i32) -> Self {
+//     TreeNode {
+//       val,
+//       left: None,
+//       right: None
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
+        vec![]
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_102() {
+    }
+}

src/problem/p0102_binary_tree_level_order_traversal.rs

@@ -0,0 +1,71 @@
+/**
+ * [103] Binary Tree Zigzag Level Order Traversal
+ *
+ * Given the root of a binary tree, return the zigzag level order traversal of its nodes' values. (i.e., from left to right, then right to left for the next level and alternate between).
+ *  
+ * Example 1:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg" style="width: 277px; height: 302px;" />
+ * Input: root = [3,9,20,null,null,15,7]
+ * Output: [[3],[20,9],[15,7]]
+ * 
+ * Example 2:
+ * 
+ * Input: root = [1]
+ * Output: [[1]]
+ * 
+ * Example 3:
+ * 
+ * Input: root = []
+ * Output: []
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	The number of nodes in the tree is in the range [0, 2000].
+ * 	-100 <= Node.val <= 100
+ * 
+ */
+pub struct Solution {}
+use crate::util::tree::{TreeNode, to_tree};
+
+// problem: https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/
+// discuss: https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+// 
+// impl TreeNode {
+//   #[inline]
+//   pub fn new(val: i32) -> Self {
+//     TreeNode {
+//       val,
+//       left: None,
+//       right: None
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn zigzag_level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
+        vec![]
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_103() {
+    }
+}