change js to md

Author: BaffinLee

001-100/38. Count and Say.md

@@ -0,0 +1,91 @@
+# 38. Count and Say
+
+- Difficulty: Easy.
+- Related Topics: String.
+- Similar Questions: Encode and Decode Strings, String Compression.
+
+## Problem
+
+The count-and-say sequence is the sequence of integers with the first five terms as following:
+```
+1.     1
+2.     11
+3.     21
+4.     1211
+5.     111221
+```
+
+```1``` is read off as ```"one 1"``` or ```11```.
+```11``` is read off as ```"two 1s"``` or ```21```.
+```21``` is read off as ```"one 2```, then ```one 1"``` or ```1211```.
+
+Given an integer *n*, generate the *n*th term of the count-and-say sequence.
+
+Note: Each term of the sequence of integers will be represented as a string.
+
+**Example 1:**
+```
+Input: 1
+Output: "1"
+```
+
+**Example 2:**
+```
+Input: 4
+Output: "1211"
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {number} n
+ * @return {string}
+ */
+var countAndSay = function(n) {
+  var str = '1';
+  var tmp = '';
+  var last = '';
+  var count = 0;
+  var len = 0;
+	
+  for (var i = 1; i < n; i++) {
+    tmp = '';
+    last = '';
+    count = 0;
+    len = str.length;
+			
+    for (var j = 0; j < len; j++) {
+      if (last === '') {
+        last = str[j];
+        count = 1;
+        continue;
+      }
+      if (str[j] === last) {
+        count += 1;
+      } else {
+        tmp += '' + count + last;
+        last = str[j];
+        count = 1;
+      }
+    }
+    
+    if (last) {
+      tmp += '' + count + last;
+    }
+			
+    str = tmp;
+  }
+	
+  return str;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity :
+* Space complexity :

001-100/39. Combination Sum.md

@@ -0,0 +1,77 @@
+# 39. Combination Sum
+
+- Difficulty: Medium.
+- Related Topics: Array, Backtracking.
+- Similar Questions: Letter Combinations of a Phone Number, Combination Sum II, Combinations, Combination Sum III, Factor Combinations, Combination Sum IV.
+
+## Problem
+
+Given a **set** of candidate numbers (```candidates```) **(without duplicates)** and a target number (```target```), find all unique combinations in ```candidates``` where the candidate numbers sums to ```target```.
+
+The **same** repeated number may be chosen from ```candidates``` unlimited number of times.
+
+**Note:**
+
+- All numbers (including ```target```) will be positive integers.
+- The solution set must not contain duplicate combinations.
+
+**Example 1:**
+
+```
+Input: candidates = [2,3,6,7], target = 7,
+A solution set is:
+[
+  [7],
+  [2,2,3]
+]
+```
+
+**Example 2:**
+
+```
+Input: candidates = [2,3,5], target = 8,
+A solution set is:
+[
+  [2,2,2,2],
+  [2,3,3],
+  [3,5]
+]
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+var combinationSum = function(candidates, target) {
+  var res = [];
+  var len = candidates.length;
+  candidates.sort((a, b) => (a - b));
+  dfs(res, [], 0, len, candidates, target);
+  return res;
+};
+
+var dfs = function (res, stack, index, len, candidates, target) {
+  var tmp = null;
+  if (target < 0) return;
+  if (target === 0) return res.push(stack);
+  for (var i = index; i < len; i++) {
+    if (candidates[i] > target) break;
+    tmp = Array.from(stack);
+    tmp.push(candidates[i]);
+    dfs(res, tmp, i, len, candidates, target - candidates[i]);
+  }
+};
+```
+
+**Explain:**
+
+对树进行深度优先的搜索。注意解法不能重复，即下次搜索从 index 开始
+
+**Complexity:**
+
+* Time complexity : O(n^2).
+* Space complexity : O(n^2).

001-100/40. Combination Sum II.md

@@ -0,0 +1,82 @@
+# 40. Combination Sum II
+
+- Difficulty: Medium.
+- Related Topics: Array, Backtracking.
+- Similar Questions: Combination Sum.
+
+## Problem
+
+Given a collection of candidate numbers (```candidates```) and a target number (```target```), find all unique combinations in ```candidates``` where the candidate numbers sums to ```target```.
+
+Each number in ```candidates``` may only be used **once** in the combination.
+
+**Note:**
+
+- All numbers (including ```target```) will be positive integers.
+- The solution set must not contain duplicate combinations.
+
+**Example 1:**
+
+```
+Input: candidates = [10,1,2,7,6,1,5], target = 8,
+A solution set is:
+[
+  [1, 7],
+  [1, 2, 5],
+  [2, 6],
+  [1, 1, 6]
+]
+```
+
+**Example 2:**
+
+```
+Input: candidates = [2,5,2,1,2], target = 5,
+A solution set is:
+[
+  [1,2,2],
+  [5]
+]
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+var combinationSum2 = function(candidates, target) {
+  var res = [];
+  var len = candidates.length;
+  candidates.sort((a, b) => (a - b));
+  dfs(res, [], 0, len, candidates, target);
+  return res;
+};
+
+var dfs = function (res, stack, index, len, candidates, target) {
+  var tmp = null;
+  if (target < 0) return;
+  if (target === 0) return res.push(stack);
+  for (var i = index; i < len; i++) {
+    if (candidates[i] > target) break;
+    if (i > index && candidates[i] === candidates[i - 1]) continue;
+    tmp = Array.from(stack);
+    tmp.push(candidates[i]);
+    dfs(res, tmp, i + 1, len, candidates, target - candidates[i]);
+  }
+};
+```
+
+**Explain:**
+
+与之前一题不同的地方是：
+
+1. 候选数字可能有重复的
+2. 单个候选数字不能重复使用
+
+**Complexity:**
+
+* Time complexity : O(n^2).
+* Space complexity : O(n^2).

001-100/41. First Missing Positive.md

@@ -0,0 +1,74 @@
+# 41. First Missing Positive
+
+- Difficulty: Hard.
+- Related Topics: Array.
+- Similar Questions: Missing Number, Find the Duplicate Number, Find All Numbers Disappeared in an Array, Couples Holding Hands.
+
+## Problem
+
+Given an unsorted integer array, find the smallest missing positive integer.
+
+**Example 1:**
+
+```
+Input: [1,2,0]
+Output: 3
+```
+
+**Example 2:**
+
+```
+Input: [3,4,-1,1]
+Output: 2
+```
+
+**Example 3:**
+
+```
+Input: [7,8,9,11,12]
+Output: 1
+```
+
+**Note:**
+
+Your algorithm should run in **O**(**n**) time and uses constant extra space.
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var firstMissingPositive = function(nums) {
+	var len = nums.length;
+	var tmp = 0;
+	var i = 0;
+	while (i < len) {
+		tmp = nums[i];
+		if (tmp > 0 && tmp !== i + 1 && tmp !== nums[tmp - 1]) swap(nums, i, tmp - 1);
+		else i++;
+	}
+	for (var j = 0; j < len; j++) {
+		if (nums[j] !== j + 1) return j + 1;
+	}
+	return len + 1;
+};
+
+var swap = function (arr, i, j) {
+	var tmp = arr[i];
+	arr[i] = arr[j];
+	arr[j] = tmp;
+};
+```
+
+**Explain:**
+
+循环把 `nums[i]` 放到 `nums[nums[i] - 1]` 那里，最后 `nums[i] !== i + 1` 就是不对的
+
+即比如 `[3, 4, -2, 1]` => `[1, -2, 3, 4]`，即缺 `2`
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).

001-100/42. Trapping Rain Water.md

@@ -0,0 +1,61 @@
+# 42. Trapping Rain Water
+
+- Difficulty: Hard.
+- Related Topics: Array, Two Pointers, Stack.
+- Similar Questions: Container With Most Water, Product of Array Except Self, Trapping Rain Water II, Pour Water.
+
+## Problem
+
+Given **n** non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.
+
+![](http://www.leetcode.com/static/images/problemset/rainwatertrap.png)
+
+The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. **Thanks Marcos** for contributing this image!
+
+**Example:**
+
+```
+Input: [0,1,0,2,1,0,1,3,2,1,2,1]
+Output: 6
+```
+
+## Solution
+
+```javascript
+var trap = function(height) {
+  var res = 0;
+  var left = 0;
+  var right = height.length - 1;
+  var leftMax = 0;
+  var rightMax = 0;
+
+  while (left < right) {
+    if (height[left] < height[right]) {
+      if (height[left] >= leftMax) {
+        leftMax = height[left];
+      } else {
+        res += leftMax - height[left];
+      }
+      left++;
+    } else {
+      if (height[right] >= rightMax) {
+        rightMax = height[right];
+      } else {
+        res += rightMax - height[right];
+      }
+      right--;
+    }
+  }
+
+  return res;
+};
+```
+
+**Explain:**
+
+双指针
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).