support submission template generation

Author: aylei

Cargo.lock

@@ -4,3 +4,8 @@ version = "0.1.0"
 authors = ["alei <[email protected]>"]
 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 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 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() {
+    }
+}