support submission template generation

Author: aylei

Cargo.lock

@@ -4,3 +4,8 @@ version = "0.1.0"
 authors = ["alei <rayingecho@gmail.com>"]
 edition = "2018"
 
+[dependencies]
+reqwest = "0.9.8"
+serde = "1.0"
+serde_json = "1.0"
+serde_derive = "1.0"

Cargo.toml

@@ -1,13 +1,15 @@
 # My Leetcode Solution in Rust
 
-Each `.rs` file consists of three parts:
+Run `cargo run {id}` to initialize the template submission file of "question #id".
 
-* problem description
-* my solution
-* test cases
+Run `cargo test test_{id}` to test the solution for "question #id".
 
-Run `cargo test test_{id}` to test the solution for problem #id.
+Working in progress, to do:
 
-Working in progress, solutions list:
+- [ ] auto generation of solution list
 
-* [1 - two sum](src/n1_two_sum.rs)
+## Usage
+
+* Remove all the solution .rs
+* Clean lib.rs file
+* Start your leetcode journey in rust by typing `cargo run {question_id}`

README.md

@@ -0,0 +1,4 @@
+mod n0001_two_sum;
+mod n0002_add_two_numbers;
+mod n0003_longest_substring;
+mod n0004_median_of_two_sorted_arrays;

src/lib.rs

@@ -1,7 +1,75 @@
-// make cargo happy
-pub mod n1_two_sum;
-pub mod n2_add_two_numbers;
+#[macro_use]
+extern crate serde_derive;
+#[macro_use]
+extern crate serde_json;
 
+mod problem;
+
+use std::env;
+use std::fs;
+use std::path::{Path};
+use std::io::Write;
+
+/// main() helps to generate the submission template .rs
 fn main() {
+    let args: Vec<String> = env::args().collect();
+    if args.len() < 2 {
+        panic!("problem id must be provided");
+    }
+    let id = &args[1];
+    let id = id.parse::<u32>().expect(&format!("not a number: {}", id));
+
+    let problem = problem::get_problem(id)
+        .expect(&format!("problem #{} not found", id));
+    let code = problem.code_definition.iter()
+        .filter(|&d| { d.value == "rust" })
+        .next()
+        .expect("problem has no rust support yet");
+
+    let file_name = format!("n{:04}_{}", id, problem.title_slug.replace("-", "_"));
+    let file_path = Path::new("./src").join(format!("{}.rs", file_name));
+    if file_path.exists() {
+        panic!("problem already initialized");
+    }
+
+    let template = fs::read_to_string("./template.rs").unwrap();
+    let source = template
+        .replace("__PROBLEM_TITLE__", &problem.title)
+        .replace("__PROBLEM_DESC__", &build_desc(&problem.content))
+        .replace("__PROBLEM_DEFAULT_CODE__", &code.default_code)
+        .replace("__PROBLEM_ID__", &format!("{}", id));
+
+    let mut file = fs::OpenOptions::new()
+        .write(true)
+        .create(true)
+        .truncate(true)
+        .open(&file_path)
+        .unwrap();
+
+    file.write_all(source.as_bytes()).unwrap();
+    drop(file);
+
+    let mut lib_file = fs::OpenOptions::new()
+        .write(true)
+        .append(true)
+        .open("./src/lib.rs")
+        .unwrap();
+    writeln!(lib_file, "mod {};", file_name);
+}
 
+fn build_desc(content: &str) -> String {
+    content
+        .replace("<strong>", "")
+        .replace("</strong>", "")
+        .replace("<em>", "")
+        .replace("</em>", "")
+        .replace("</p>", "")
+        .replace("<p>", "")
+        .replace("<b>", "")
+        .replace("</b>", "")
+        .replace("</pre>", "")
+        .replace("<pre>", "")
+        .replace("&nbsp;", "")
+        .replace("\n\n", "\n")
+        .replace("\n", "\n * ")
 }

src/main.rs

@@ -1,24 +1,21 @@
-/*
+/**
  * [1] Two Sum
  *
- * https://leetcode.com/problems/two-sum/description/
- *
  * Given an array of integers, return indices of the two numbers such that they
  * add up to a specific target.
- * 
+ *
  * You may assume that each input would have exactly one solution, and you may
  * not use the same element twice.
- * 
+ *
  * Example:
- * 
- * 
+ *
+ *
  * Given nums = [2, 7, 11, 15], target = 9,
- * 
+ *
  * Because nums[0] + nums[1] = 2 + 7 = 9,
  * return [0, 1].
  *
  */
-
 pub struct Solution {}
 
 // submission codes start here

src/n1_two_sum.rs renamed to src/n0001_two_sum.rs

@@ -1,14 +1,6 @@
-/*
+/**
  * [2] Add Two Numbers
  *
- * https://leetcode.com/problems/add-two-numbers/description/
- *
- * algorithms
- * Medium (30.03%)
- * Total Accepted:    705.4K
- * Total Submissions: 2.3M
- * Testcase Example:  '[2,4,3]\n[5,6,4]'
- *
  * You are given two non-empty linked lists representing two non-negative
  * integers. The digits are stored in reverse order and each of their nodes
  * contain a single digit. Add the two numbers and return it as a linked list.
@@ -17,41 +9,13 @@
  * number 0 itself.
  * 
  * Example:
- * 
- * 
+ *
+ *
  * Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
  * Output: 7 -> 0 -> 8
  * Explanation: 342 + 465 = 807.
  *
  */
-
-#[derive(PartialEq, Eq, Debug)]
-pub struct ListNode {
-    pub val: i32,
-    pub next: Option<Box<ListNode>>
-}
-
-impl ListNode {
-    #[inline]
-    fn new(val: i32) -> Self {
-        ListNode {
-            next: None,
-            val
-        }
-    }
-}
-
-// helper function for test
-pub fn to_list(vec: Vec<i32>) -> Option<Box<ListNode>> {
-    let mut current = None;
-    for &v in vec.iter().rev() {
-        let mut node = ListNode::new(v);
-        node.next = current;
-        current = Some(Box::new(node));
-    }
-    current
-}
-
 pub struct Solution {}
 
 // submission codes start here
@@ -85,6 +49,33 @@ impl Solution {
 
 // submission codes end
 
+#[derive(PartialEq, Eq, Debug)]
+pub struct ListNode {
+    pub val: i32,
+    pub next: Option<Box<ListNode>>
+}
+
+impl ListNode {
+    #[inline]
+    fn new(val: i32) -> Self {
+        ListNode {
+            next: None,
+            val
+        }
+    }
+}
+
+// helper function for test
+pub fn to_list(vec: Vec<i32>) -> Option<Box<ListNode>> {
+    let mut current = None;
+    for &v in vec.iter().rev() {
+        let mut node = ListNode::new(v);
+        node.next = current;
+        current = Some(Box::new(node));
+    }
+    current
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/n2_add_two_numbers.rs renamed to src/n0002_add_two_numbers.rs

@@ -0,0 +1,40 @@
+/**
+ * [3] Longest Substring Without Repeating Characters
+ *
+ * You are given two non-empty linked lists representing two non-negative
+ * integers. The digits are stored in reverse order and each of their nodes
+ * contain a single digit. Add the two numbers and return it as a linked list.
+ *
+ * You may assume the two numbers do not contain any leading zero, except the
+ * number 0 itself.
+ *
+ * Example:
+ *
+ * Input: "abcabcbb"
+ * Output: 3
+ * Explanation: The answer is "abc", with the length of 3.
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn length_of_longest_substring(s: String) -> i32 {
+
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_3() {
+        assert_eq!(Solution::length_of_longest_substring("abcabcbb".to_string()), 3);
+        assert_eq!(Solution::length_of_longest_substring("bbbb".to_string()), 1);
+        assert_eq!(Solution::length_of_longest_substring("pwwkew".to_string()), 3);
+    }
+}

src/n0003_longest_substring.rs

@@ -0,0 +1,48 @@
+/**
+ * [4] Median of Two Sorted Arrays
+ *
+ * There are two sorted arrays nums1 and nums2 of size m and n respectively.
+ * 
+ * Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).
+ * 
+ * You may assume nums1 and nums2cannot be both empty.
+ * 
+ * Example 1:
+ * 
+ *
+ * nums1 = [1, 3]
+ * nums2 = [2]
+ * 
+ * The median is 2.0
+ * 
+ * 
+ * Example 2:
+ * 
+ * 
+ * nums1 = [1, 2]
+ * nums2 = [3, 4]
+ * 
+ * The median is (2 + 3)/2 = 2.5
+ * 
+ * 
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn find_median_sorted_arrays(nums1: Vec<i32>, nums2: Vec<i32>) -> f64 {
+        
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_4() {
+    }
+}

src/n0004_median_of_two_sorted_arrays.rs

@@ -0,0 +1,159 @@
+extern crate serde_json;
+extern crate reqwest;
+
+use std::fmt::{Display, Formatter, Error};
+
+const PROBLEMS_URL: &str = "https://leetcode.com/api/problems/algorithms/";
+const GRAPHQL_URL: &str = "https://leetcode.com/graphql";
+const QUESTION_QUERY_STRING: &str = r#"
+query questionData($titleSlug: String!) {
+    question(titleSlug: $titleSlug) {
+        content
+        stats
+        codeDefinition
+        sampleTestCase
+        metaData
+    }
+}"#;
+const QUESTION_QUERY_OPERATION: &str = "questionData";
+
+pub fn get_problem(id: u32) -> Option<Problem> {
+    let problems = get_problems().unwrap();
+    for problem in problems.stat_status_pairs.iter() {
+        if problem.stat.question_id == id {
+            let client = reqwest::Client::new();
+            let resp: RawProblem = client.post(GRAPHQL_URL)
+                .json(&Query::question_query(problem.stat.question_title_slug.as_ref().unwrap()))
+                .send().unwrap()
+                .json().unwrap();
+            return Some(Problem {
+                title: problem.stat.question_title.clone().unwrap(),
+                title_slug: problem.stat.question_title_slug.clone().unwrap(),
+                code_definition: serde_json::from_str( & resp.data.question.code_definition).unwrap(),
+                content: resp.data.question.content,
+                sample_test_case: resp.data.question.sample_test_case,
+                difficulty: problem.difficulty.to_string(),
+            })
+        }
+    }
+    None
+}
+
+fn get_problems() -> Option<Problems> {
+    reqwest::get(PROBLEMS_URL).unwrap().json().unwrap()
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Problem {
+    pub title: String,
+    pub title_slug: String,
+    pub content: String,
+    #[serde(rename = "codeDefinition")]
+    pub code_definition: Vec<CodeDefinition>,
+    #[serde(rename = "sampleTestCase")]
+    pub sample_test_case: String,
+    pub difficulty: String,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct CodeDefinition {
+    pub value: String,
+    pub text: String,
+    #[serde(rename = "defaultCode")]
+    pub default_code: String,
+}
+
+
+#[derive(Debug, Serialize, Deserialize)]
+struct Query {
+    #[serde(rename = "operationName")]
+    operation_name: String,
+    variables: serde_json::Value,
+    query: String,
+}
+
+impl Query {
+    fn question_query(title_slug: &str) -> Query {
+        Query {
+            operation_name: QUESTION_QUERY_OPERATION.to_owned(),
+            variables: json!({"titleSlug": title_slug}),
+            query: QUESTION_QUERY_STRING.to_owned(),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct RawProblem {
+    data: Data,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct Data {
+    question: Question,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct Question {
+    content: String,
+    stats: String,
+    #[serde(rename = "codeDefinition")]
+    code_definition: String,
+    #[serde(rename = "sampleTestCase")]
+    sample_test_case: String,
+    #[serde(rename = "metaData")]
+    meta_data: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct Problems {
+    user_name: String,
+    num_solved: u32,
+    num_total: u32,
+    ac_easy: u32,
+    ac_medium: u32,
+    ac_hard: u32,
+    stat_status_pairs: Vec<StatWithStatus>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct StatWithStatus {
+    stat: Stat,
+    difficulty: Difficulty,
+    paid_only: bool,
+    is_favor: bool,
+    frequency: u32,
+    progress: u32,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct Stat {
+    question_id: u32,
+    #[serde(rename = "question__article__slug")]
+    question_article_slug: Option<String>,
+    #[serde(rename = "question__title")]
+    question_title: Option<String>,
+    #[serde(rename = "question__title_slug")]
+    question_title_slug: Option<String>,
+    #[serde(rename = "question__hide")]
+    question_hide: bool,
+    total_acs: u32,
+    total_submitted: u32,
+    frontend_question_id: u32,
+    is_new_question: bool,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct Difficulty {
+    level: u32,
+}
+
+impl Display for Difficulty {
+    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
+        match self.level {
+            1 => f.write_str("Easy"),
+            2 => f.write_str("Medium"),
+            3 => f.write_str("Hard"),
+            _ => f.write_str("Unknown"),
+        }
+    }
+}

src/problem.rs

@@ -0,0 +1,21 @@
+/**
+ * [__PROBLEM_ID__] __PROBLEM_TITLE__
+ *
+ * __PROBLEM_DESC__
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+__PROBLEM_DEFAULT_CODE__
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test___PROBLEM_ID__() {
+    }
+}