change 5-10 to md

Author: BaffinLee

001-100/10. Regular Expression Matching.md

@@ -0,0 +1,115 @@
+# 10. Regular Expression Matching
+
+- Difficulty: Hard.
+- Related Topics: String, Dynamic Programming, Backtracking.
+- Similar Questions: Wildcard Matching.
+
+## Problem
+
+Given an input string (```s```) and a pattern (```p```), implement regular expression matching with support for ```'.'``` and ```'*'```.
+
+```
+'.' Matches any single character.
+'*' Matches zero or more of the preceding element.
+```
+
+The matching should cover the **entire** input string (not partial).
+
+**Note:**
+
+- ```s``` could be empty and contains only lowercase letters ```a-z```.
+- ```p``` could be empty and contains only lowercase letters ```a-z```, and characters like ```.``` or ```*```.
+
+**Example 1:**
+
+```
+Input:
+s = "aa"
+p = "a"
+Output: false
+Explanation: "a" does not match the entire string "aa".
+```
+
+**Example 2:**
+
+```
+Input:
+s = "aa"
+p = "a*"
+Output: true
+Explanation: '*' means zero or more of the precedeng element, 'a'. Therefore, by repeating 'a' once, it becomes "aa".
+```
+
+**Example 3:**
+
+```
+Input:
+s = "ab"
+p = ".*"
+Output: true
+Explanation: ".*" means "zero or more (*) of any character (.)".
+```
+
+**Example 4:**
+
+```
+Input:
+s = "aab"
+p = "c*a*b"
+Output: true
+Explanation: c can be repeated 0 times, a can be repeated 1 time. Therefore it matches "aab".
+```
+
+**Example 5:**
+
+```
+Input:
+s = "mississippi"
+p = "mis*is*p*."
+Output: false
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {string} s
+ * @param {string} p
+ * @return {boolean}
+ */
+var isMatch = function(s, p) {
+  var dp = Array(s.length + 1).fill(0).map(_ => Array(p.length + 1));
+  return helper(dp, 0, 0, s, p);
+};
+
+var helper = function (dp, i, j, s, p) {
+  var res = false;
+  if (dp[i][j] !== undefined) return dp[i][j];
+  if (j === p.length) {
+    res = i === s.length;
+  } else {
+    if (i === s.length) {
+      res = p[j + 1] === '*' && helper(dp, i, j + 2, s, p);
+    } else if (s[i] === p[j] || p[j] === '.') {
+      if (p[j + 1] === '*') {
+        res = helper(dp, i + 1, j, s, p) || helper(dp, i, j + 2, s, p) || helper(dp, i + 1, j + 2, s, p);
+      } else {
+        res = helper(dp, i + 1, j + 1, s, p);
+      }
+    } else {
+      res = p[j + 1] === '*' && helper(dp, i, j + 2, s, p);
+    }
+  }
+  dp[i][j] = res;
+  return res;
+};
+```
+
+**Explain:**
+
+动态规划，```dp[i][j]``` 代表 ```s[i]``` 与 ```p[j]``` 是否可匹配。
+
+**Complexity:**
+
+* Time complexity : O(mn).
+* Space complexity : O(mn).

001-100/5. Longest Palindromic Substring.md

@@ -0,0 +1,67 @@
+# 5. Longest Palindromic Substring
+
+- Difficulty: Medium.
+- Related Topics: String, Dynamic Programming.
+- Similar Questions: Shortest Palindrome, Palindrome Permutation, Palindrome Pairs, Longest Palindromic Subsequence, Palindromic Substrings.
+
+## Problem
+
+Given a string **s**, find the longest palindromic substring in **s**. You may assume that the maximum length of **s** is 1000.
+
+**Example 1:**
+
+```
+Input: "babad"
+Output: "bab"
+Note: "aba" is also a valid answer.
+```
+
+**Example 2:**
+
+```
+Input: "cbbd"
+Output: "bb"
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var longestPalindrome = function(s) {
+  var start = 0;
+  var end = 0;
+  var len = s.length;
+  var num = 0;
+  for (var i = 0; i < len; i++) {
+    num = Math.max(expandAroundCenter(s, i, i), expandAroundCenter(s, i, i + 1));
+    if (num > end - start) {
+      start = i - Math.floor((num - 1) / 2);
+      end = i + Math.floor(num / 2);
+    }
+  }
+  return s.slice(start, end + 1);
+};
+
+var expandAroundCenter = function (s, left, right) {
+  var l = left;
+  var r = right;
+  var len = s.length;
+  while (l >= 0 && r < len && s[l] === s[r]) {
+    l--;
+    r++;
+  }
+  return r - l - 1;
+};
+```
+
+**Explain:**
+
+遍历每个字符，检查以这个字符或相邻两个字符为中心是否回文，记录最长的回文字符位置。
+
+**Complexity:**
+
+* Time complexity : O(n^2).
+* Space complexity : O(1).

001-100/6. ZigZag Conversion.md

@@ -0,0 +1,78 @@
+# 6. ZigZag Conversion
+
+- Difficulty: Medium.
+- Related Topics: String.
+- Similar Questions: .
+
+## Problem
+
+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);
+```
+
+**Example 1:**
+
+```
+Input: s = "PAYPALISHIRING", numRows = 3
+Output: "PAHNAPLSIIGYIR"
+```
+
+**Example 2:**
+
+```
+Input: s = "PAYPALISHIRING", numRows = 4
+Output: "PINALSIGYAHRPI"
+Explanation:
+
+P     I    N
+A   L S  I G
+Y A   H R
+P     I
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {string} s
+ * @param {number} numRows
+ * @return {string}
+ */
+var convert = function(s, numRows) {
+  if (s.length <= numRows || numRows < 2) return s;
+  var len = s.length;
+  var num = 2 * (numRows - 1);
+  var res = Array(numRows).fill('');
+  var tmp = 0;
+  for (var i = 0; i < len; i++) {
+    tmp = i % num;
+    if (tmp < numRows) {
+      res[tmp] += s[i];
+    } else {
+      res[num - tmp] += s[i];
+    }
+  }
+  return res.join('');
+};
+```
+
+**Explain:**
+
+曲线每 ```2 * (numRows - 1)``` 个数按规律出现。
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).

001-100/7. Reverse Integer.md

@@ -0,0 +1,63 @@
+# 7. Reverse Integer
+
+- Difficulty: Easy.
+- Related Topics: Math.
+- Similar Questions: String to Integer (atoi).
+
+## Problem
+
+Given a 32-bit signed integer, reverse digits of an integer.
+
+**Example 1:**
+
+```
+Input: 123
+Output: 321
+```
+
+**Example 2:**
+
+```
+Input: -123
+Output: -321
+```
+
+**Example 3:**
+
+```
+Input: 120
+Output: 21
+```
+
+**Note:**
+Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−231,  231 − 1]. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.
+
+## Solution
+
+```javascript
+/**
+ * @param {number} x
+ * @return {number}
+ */
+var reverse = function(x) {
+  var INT_MAX = 2147483647;
+  var INT_MIN = - INT_MAX - 1;
+  var res = 0;
+  var num = x;
+  while (num !== 0) {
+    res = (res * 10) + (num % 10);
+    num = num > 0 ? Math.floor(num / 10) : Math.ceil(num / 10);
+    if (res > INT_MAX || res < INT_MIN) return 0;
+  }
+  return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(log(n)).
+* Space complexity : O(n).