init all problems

Author: sscraigie

src/problem/p0001_two_sum.rs

@@ -0,0 +1,57 @@
+/**
+ * [1] Two Sum
+ *
+ * Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
+ * You may assume that each input would have exactly one solution, and you may not use the same element twice.
+ * You can return the answer in any order.
+ *  
+ * <strong class="example">Example 1:
+ * 
+ * Input: nums = [2,7,11,15], target = 9
+ * Output: [0,1]
+ * Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
+ * 
+ * <strong class="example">Example 2:
+ * 
+ * Input: nums = [3,2,4], target = 6
+ * Output: [1,2]
+ * 
+ * <strong class="example">Example 3:
+ * 
+ * Input: nums = [3,3], target = 6
+ * Output: [0,1]
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	2 <= nums.length <= 10^4
+ * 	-10^9 <= nums[i] <= 10^9
+ * 	-10^9 <= target <= 10^9
+ * 	Only one valid answer exists.
+ * 
+ *  
+ * Follow-up: Can you come up with an algorithm that is less than O(n^2)<font face="monospace"> </font>time complexity?
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/two-sum/
+// discuss: https://leetcode.com/problems/two-sum/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
+        vec![]
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+    }
+}

src/problem/p0002_add_two_numbers.rs

@@ -0,0 +1,70 @@
+/**
+ * [2] Add Two Numbers
+ *
+ * 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 contains a single digit. Add the two numbers and return the sum as a linked list.
+ * You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+ *  
+ * <strong class="example">Example 1:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2020/10/02/addtwonumber1.jpg" style="width: 483px; height: 342px;" />
+ * Input: l1 = [2,4,3], l2 = [5,6,4]
+ * Output: [7,0,8]
+ * Explanation: 342 + 465 = 807.
+ * 
+ * <strong class="example">Example 2:
+ * 
+ * Input: l1 = [0], l2 = [0]
+ * Output: [0]
+ * 
+ * <strong class="example">Example 3:
+ * 
+ * Input: l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
+ * Output: [8,9,9,9,0,0,0,1]
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	The number of nodes in each linked list is in the range [1, 100].
+ * 	0 <= Node.val <= 9
+ * 	It is guaranteed that the list represents a number that does not have leading zeros.
+ * 
+ */
+pub struct Solution {}
+use crate::util::linked_list::{ListNode, to_list};
+
+// problem: https://leetcode.com/problems/add-two-numbers/
+// discuss: https://leetcode.com/problems/add-two-numbers/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+// Definition for singly-linked list.
+// #[derive(PartialEq, Eq, Clone, Debug)]
+// pub struct ListNode {
+//   pub val: i32,
+//   pub next: Option<Box<ListNode>>
+// }
+// 
+// impl ListNode {
+//   #[inline]
+//   fn new(val: i32) -> Self {
+//     ListNode {
+//       next: None,
+//       val
+//     }
+//   }
+// }
+impl Solution {
+    pub fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        Some(Box::new(ListNode::new(0)))
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_2() {
+    }
+}

src/problem/p0003_longest_substring_without_repeating_characters.rs

@@ -0,0 +1,54 @@
+/**
+ * [3] Longest Substring Without Repeating Characters
+ *
+ * Given a string s, find the length of the longest <span data-keyword="substring-nonempty">substring</span> without repeating characters.
+ *  
+ * <strong class="example">Example 1:
+ * 
+ * Input: s = "abcabcbb"
+ * Output: 3
+ * Explanation: The answer is "abc", with the length of 3.
+ * 
+ * <strong class="example">Example 2:
+ * 
+ * Input: s = "bbbbb"
+ * Output: 1
+ * Explanation: The answer is "b", with the length of 1.
+ * 
+ * <strong class="example">Example 3:
+ * 
+ * Input: s = "pwwkew"
+ * Output: 3
+ * Explanation: The answer is "wke", with the length of 3.
+ * Notice that the answer must be a substring, "pwke" is a subsequence and not a substring.
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	0 <= s.length <= 5 * 10^4
+ * 	s consists of English letters, digits, symbols and spaces.
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/longest-substring-without-repeating-characters/
+// discuss: https://leetcode.com/problems/longest-substring-without-repeating-characters/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn length_of_longest_substring(s: String) -> i32 {
+        0
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_3() {
+    }
+}

src/problem/p0004_median_of_two_sorted_arrays.rs

@@ -0,0 +1,52 @@
+/**
+ * [4] Median of Two Sorted Arrays
+ *
+ * Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays.
+ * The overall run time complexity should be O(log (m+n)).
+ *  
+ * <strong class="example">Example 1:
+ * 
+ * Input: nums1 = [1,3], nums2 = [2]
+ * Output: 2.00000
+ * Explanation: merged array = [1,2,3] and median is 2.
+ * 
+ * <strong class="example">Example 2:
+ * 
+ * Input: nums1 = [1,2], nums2 = [3,4]
+ * Output: 2.50000
+ * Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	nums1.length == m
+ * 	nums2.length == n
+ * 	0 <= m <= 1000
+ * 	0 <= n <= 1000
+ * 	1 <= m + n <= 2000
+ * 	-10^6 <= nums1[i], nums2[i] <= 10^6
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/median-of-two-sorted-arrays/
+// discuss: https://leetcode.com/problems/median-of-two-sorted-arrays/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn find_median_sorted_arrays(nums1: Vec<i32>, nums2: Vec<i32>) -> f64 {
+        0f64
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_4() {
+    }
+}

src/problem/p0005_longest_palindromic_substring.rs

@@ -0,0 +1,46 @@
+/**
+ * [5] Longest Palindromic Substring
+ *
+ * Given a string s, return the longest <span data-keyword="palindromic-string">palindromic</span> <span data-keyword="substring-nonempty">substring</span> in s.
+ *  
+ * <strong class="example">Example 1:
+ * 
+ * Input: s = "babad"
+ * Output: "bab"
+ * Explanation: "aba" is also a valid answer.
+ * 
+ * <strong class="example">Example 2:
+ * 
+ * Input: s = "cbbd"
+ * Output: "bb"
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	1 <= s.length <= 1000
+ * 	s consist of only digits and English letters.
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/longest-palindromic-substring/
+// discuss: https://leetcode.com/problems/longest-palindromic-substring/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn longest_palindrome(s: String) -> String {
+        String::new()
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_5() {
+    }
+}

src/problem/p0006_zigzag_conversion.rs

@@ -0,0 +1,66 @@
+/**
+ * [6] Zigzag Conversion
+ *
+ * The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)
+ * 
+ * P   A   H   N
+ * A P L S I I G
+ * Y   I   R
+ * 
+ * And then read line by line: "PAHNAPLSIIGYIR"
+ * Write the code that will take a string and make this conversion given a number of rows:
+ * 
+ * string convert(string s, int numRows);
+ * 
+ *  
+ * <strong class="example">Example 1:
+ * 
+ * Input: s = "PAYPALISHIRING", numRows = 3
+ * Output: "PAHNAPLSIIGYIR"
+ * 
+ * <strong class="example">Example 2:
+ * 
+ * Input: s = "PAYPALISHIRING", numRows = 4
+ * Output: "PINALSIGYAHRPI"
+ * Explanation:
+ * P     I    N
+ * A   L S  I G
+ * Y A   H R
+ * P     I
+ * 
+ * <strong class="example">Example 3:
+ * 
+ * Input: s = "A", numRows = 1
+ * Output: "A"
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	1 <= s.length <= 1000
+ * 	s consists of English letters (lower-case and upper-case), ',' and '.'.
+ * 	1 <= numRows <= 1000
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/zigzag-conversion/
+// discuss: https://leetcode.com/problems/zigzag-conversion/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn convert(s: String, num_rows: i32) -> String {
+        String::new()
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_6() {
+    }
+}