update

Author: BaffinLee

001-100/18. 4Sum.md

@@ -28,7 +28,55 @@ A solution set is:
 ## Solution
 
 ```javascript
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[][]}
+ */
+var fourSum = function(nums, target) {
+  if (nums.length < 4) return [];
 
+  var len = nums.length;
+  var res = [];
+  var l = 0;
+  var r = 0;
+  var sum = 0;
+
+  nums.sort((a, b) => (a - b));
+
+  for (var i = 0; i < len - 3; i++) {
+    if (i > 0 && nums[i] === nums[i - 1]) continue;
+    if (nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) break;
+    if (nums[i] + nums[len - 1] + nums[len - 2] + nums[len - 3] < target) continue;
+    
+    for (var j = i + 1; j < len - 2; j++) {
+      if (j > i + 1 && nums[j] === nums[j - 1]) continue;
+      if (nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target) break;
+      if (nums[i] + nums[j] + nums[len - 1] + nums[len - 2] < target) continue;
+      
+      l = j + 1;
+      r = len - 1;
+
+      while (l < r) {
+        sum = nums[i] + nums[j] + nums[l] + nums[r];
+
+        if (sum < target) {
+          l++;
+        } else if (sum > target) {
+          r--;
+        } else {
+          res.push([nums[i], nums[j], nums[l], nums[r]]);
+          while (l < r && nums[l] === nums[l + 1]) l++;
+          while (l < r && nums[r] === nums[r - 1]) r--;
+          l++;
+          r--;
+        }
+      }
+    }
+  }
+
+  return res;
+};
 ```
 
 **Explain:**

001-100/19. Remove Nth Node From End of List.md

@@ -0,0 +1,76 @@
+# 19. Remove Nth Node From End of List
+
+- Difficulty: Medium.
+- Related Topics: Linked List, Two Pointers.
+- Similar Questions: .
+
+## Problem
+
+Given a linked list, remove the **n**-th node from the end of list and return its head.
+
+**Example:**
+
+```
+Given linked list: 1->2->3->4->5, and n = 2.
+
+After removing the second node from the end, the linked list becomes 1->2->3->5.
+```
+
+**Note:**
+
+Given **n** will always be valid.
+
+**Follow up:**
+
+Could you do this in one pass?
+
+## Solution
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} n
+ * @return {ListNode}
+ */
+var removeNthFromEnd = function(head, n) {
+  var h = new ListNode(0);
+  var ll = h;
+  var rr = h;
+  
+  h.next = head;
+
+  for (var i = 0; i < n + 1; i++) {
+    rr = rr.next;
+  }
+
+  while (rr !== null) {
+    ll = ll.next;
+    rr= rr.next;
+  }
+  
+  ll.next = ll.next.next;
+  
+  return h.next;
+};
+```
+
+**Explain:**
+
+1. 两个指针 ```a```, ```b```，初始都指向开头
+2. 把 ```b``` 指针往后移动，直到两指针的位置相差 ```n```
+3. 同时移动两指针，直到 ```b``` 指针到了最后。这时候因为两指针的位置相差 ```n```，```a``` 指针的位置就是从后面数第 ```n+1``` 个
+4. 在 ```a``` 指针那里删掉后面一个，即第 ```n``` 个
+
+要注意可能会出现删掉 ```head``` 的情况。
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).

001-100/20. Valid Parentheses.md

@@ -0,0 +1,86 @@
+# 20. Valid Parentheses
+
+- Difficulty: Easy.
+- Related Topics: String, Stack.
+- Similar Questions: Generate Parentheses, Longest Valid Parentheses, Remove Invalid Parentheses.
+
+## Problem
+
+Given a string containing just the characters ```'('```, ```')'```, ```'{'```, ```'}'```, ```'['``` and ```']'```, determine if the input string is valid.
+
+An input string is valid if:
+
+- Open brackets must be closed by the same type of brackets.
+- Open brackets must be closed in the correct order.
+
+Note that an empty string is also considered valid.
+
+**Example 1:**
+
+```
+Input: "()"
+Output: true
+```
+
+**Example 2:**
+
+```
+Input: "()[]{}"
+Output: true
+```
+
+**Example 3:**
+
+```
+Input: "(]"
+Output: false
+```
+
+**Example 4:**
+
+```
+Input: "([)]"
+Output: false
+```
+
+**Example 5:**
+
+```
+Input: "{[]}"
+Output: true
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isValid = function(s) {
+  var stack = [];
+  var len = s.length;
+  var map = {
+    '(': ')',
+    '[': ']',
+    '{': '}'
+  };
+  for (var i = 0; i < len; i++) {
+    if (stack.length > 0 && map[stack[stack.length - 1]] === s[i]) {
+      stack.pop();
+    } else {
+      stack.push(s[i]);
+    }
+  }
+  return stack.length === 0;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).

001-100/21. Merge Two Sorted Lists.md

@@ -0,0 +1,58 @@
+# 21. Merge Two Sorted Lists
+
+- Difficulty: Easy.
+- Related Topics: Linked List.
+- Similar Questions: Merge k Sorted Lists, Merge Sorted Array, Sort List, Shortest Word Distance II.
+
+## Problem
+
+Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.
+
+**Example:**
+```
+Input: 1->2->4, 1->3->4
+Output: 1->1->2->3->4->4
+```
+
+## Solution
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+var mergeTwoLists = function(l1, l2) {
+  var head = new ListNode(0);
+  var now = head;
+  var p1 = l1;
+  var p2 = l2;
+  while (p1 || p2) {
+    if (p1 === null || (p2 !== null && p2.val < p1.val)) {
+      now.next = p2;
+      p2 = p2.next;
+    } else {
+      now.next = p1;
+      p1 = p1.next;
+    }
+    now = now.next;
+  }
+  return head.next;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(m+n).
+* Space complexity : O(m+n).

001-100/22. Generate Parentheses.md

@@ -0,0 +1,57 @@
+# 22. Generate Parentheses
+
+- Difficulty: Medium.
+- Related Topics: String, Backtracking.
+- Similar Questions: Letter Combinations of a Phone Number, Valid Parentheses.
+
+## Problem
+
+Given *n* pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
+
+For example, given *n* = 3, a solution set is:
+
+```
+[
+  "((()))",
+  "(()())",
+  "(())()",
+  "()(())",
+  "()()()"
+]
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {number} n
+ * @return {string[]}
+ */
+var generateParenthesis = function(n) {
+  var res = [];
+  if (n < 1) return res;
+  generate(res, '', n, n);
+  return res;
+};
+
+var generate = function (res, str, ll, rr) {
+  if (ll || rr) {
+    if (rr > ll) generate(res, str + ')', ll, rr - 1);
+    if (ll) generate(res, str + '(', ll - 1, rr);
+  } else {
+    res.push(str);
+  }
+};
+```
+
+**Explain:**
+
+每一层最多两种情况：
+
+1. 右括号比左括号多，加右括号
+2. 还有左括号，加左括号
+
+**Complexity:**
+
+* Time complexity : O((4^n)/(n^(-1))).
+* Space complexity : O((4^n)/(n^(-1))).

401-500/415. Add Strings.md

@@ -0,0 +1,51 @@
+# 415. Add Strings
+
+- Difficulty: Easy.
+- Related Topics: Math.
+- Similar Questions: Add Two Numbers, Multiply Strings.
+
+## Problem
+
+Given two non-negative integers ```num1``` and ```num2``` represented as string, return the sum of ```num1``` and ```num2```.
+
+**Note:**
+
+- The length of both ```num1``` and ```num2``` is < 5100.
+- Both ```num1``` and ```num2``` contains only digits ```0-9```.
+- Both ```num1``` and ```num2``` does not contain any leading zero.
+- You **must not use any built-in BigInteger library** or **convert the inputs to integer** directly.
+
+## Solution
+
+```javascript
+/**
+ * @param {string} num1
+ * @param {string} num2
+ * @return {string}
+ */
+var addStrings = function(num1, num2) {
+    var len1 = num1.length;
+    var len2 = num2.length;
+    var max = Math.max(len1, len2);
+    var res = Array(max);
+    var carry = 0;
+    var val = 0;
+    
+    for (var i = 0; i < max; i++) {
+        val = Number(num1[len1 - 1 - i] || 0) + Number(num2[len2 - 1 - i] || 0) + carry;
+        carry = Math.floor(val / 10);
+        res[max - 1 - i] = val % 10;
+    }
+    
+    return (carry || '') + res.join('');
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity :
+* Space complexity :