add new scripts

everthis · everthis · commit 0b460eb2df8e · 2018-08-23T22:43:50.000+08:00
diff --git a/11-container-with-most-water.js b/11-container-with-most-water.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+const maxArea = function(height) {
+  const arr = [];
+  const arr_len = height.length;
+  for (let i = 0, j = arr_len - 1; i < j; ) {
+    arr.push(Math.abs(j - i) * Math.min(height[i], height[j]));
+    if (height[i] < height[j]) {
+      i++;
+    } else {
+      j--;
+    }
+  }
+
+  return Math.max.apply(Math, arr);
+};
diff --git a/12-integer-to-roman.js b/12-integer-to-roman.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number} num
+ * @return {string}
+ */
+const map = {
+  "1000": "M",
+  "900": "CM",
+  "500": "D",
+  "400": "CD",
+  "100": "C",
+  "90": "XC",
+  "50": "L",
+  "40": "XL",
+  "10": "X",
+  "9": "IX",
+  "5": "V",
+  "4": "IV",
+  "1": "I"
+};
+const intToRoman = function(number) {
+  const l = fkey(map, number);
+  if (number == +l) {
+    return map[number];
+  }
+  return map[l] + intToRoman(number - +l);
+};
+
+function fkey(m, num) {
+  const keys = Object.keys(m);
+  const sArr = keys.filter(el => +el <= num);
+  return +Math.max.apply(Math, sArr);
+}
diff --git a/14-longest-common-prefix.js b/14-longest-common-prefix.js
@@ -0,0 +1,13 @@
+/**
+ * @param {string[]} strs
+ * @return {string}
+ */
+const longestCommonPrefix = function(strs) {
+  const A = strs.concat().sort(),
+    a1 = A[0] || "",
+    a2 = A[A.length - 1] || "",
+    L = a1.length,
+    i = 0;
+  while (i < L && a1.charAt(i) === a2.charAt(i)) i++;
+  return a1.substring(0, i);
+};
diff --git a/15-3sum.js b/15-3sum.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+const threeSum = function(nums) {
+  nums = nums.sort((a, b) => a - b);
+  const res = [];
+  let lo, hi, sum;
+  for (let i = 0; i < nums.length - 2; i++) {
+    if (nums[i] > 0) break;
+    if (nums[i] === nums[i - 1]) continue;
+    if (i === 0 || (i > 0 && nums[i] !== nums[i - 1])) {
+      lo = i + 1;
+      hi = nums.length - 1;
+      sum = 0 - nums[i];
+      while (lo < hi) {
+        if (nums[lo] + nums[hi] === sum) {
+          res.push([nums[i], nums[lo], nums[hi]]);
+          while (lo < hi && nums[lo] === nums[lo + 1]) {
+            lo += 1;
+          }
+          while (lo < hi && nums[hi] === nums[hi - 1]) {
+            hi -= 1;
+          }
+          lo += 1;
+          hi -= 1;
+        } else if (nums[lo] + nums[hi] < sum) {
+          lo++;
+        } else {
+          hi--;
+        }
+      }
+    }
+  }
+  return res;
+};
diff --git a/16-3sum-closest.js b/16-3sum-closest.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+const threeSumClosest = function(nums, target) {
+  const nums = nums.sort((a, b) => a - b);
+  let result;
+  let lo;
+  let hi;
+  let sum;
+  result = nums[0] + nums[1] + nums[nums.length - 1];
+  for (let i = 0; i < nums.length - 2; i++) {
+    lo = i + 1;
+    hi = nums.length - 1;
+    while (lo < hi) {
+      sum = nums[i] + nums[lo] + nums[hi];
+      if (sum < target) {
+        while (lo < hi && nums[lo] === nums[lo + 1]) {
+          lo += 1;
+        }
+        lo += 1;
+      } else if (sum > target) {
+        while (lo < hi && nums[hi] === nums[hi - 1]) {
+          hi -= 1;
+        }
+        hi -= 1;
+      } else {
+        return sum;
+      }
+
+      if (Math.abs(target - sum) < Math.abs(target - result)) {
+        result = sum;
+      }
+    }
+  }
+
+  return result;
+};
diff --git a/17-letter-combinations-of-a-phone-number.js b/17-letter-combinations-of-a-phone-number.js
@@ -0,0 +1,39 @@
+/**
+ * @param {string} digits
+ * @return {string[]}
+ */
+const letterCombinations = function(digits) {
+  if (digits === "") {
+    return [];
+  }
+  const charMap = {
+    2: ["a", "b", "c"],
+    3: ["d", "e", "f"],
+    4: ["g", "h", "i"],
+    5: ["j", "k", "l"],
+    6: ["m", "n", "o"],
+    7: ["p", "q", "r", "s"],
+    8: ["t", "u", "v"],
+    9: ["w", "x", "y", "z"]
+  };
+  const res = [];
+  const matrix = [];
+  for (let i = 0; i < digits.length; i++) {
+    matrix.push(charMap[digits.charAt(i)]);
+  }
+  let tmp = matrix[0];
+  for (let j = 1; j < matrix.length; j++) {
+    tmp = helper(matrix, j, tmp);
+  }
+  return tmp;
+};
+function helper(matrix, rowIdx, arr) {
+  const res = [];
+  for (let i = 0; i < arr.length; i++) {
+    const preStr = arr[i];
+    for (let j = 0; j < matrix[rowIdx].length; j++) {
+      res.push(`${preStr}${matrix[rowIdx][j]}`);
+    }
+  }
+  return res;
+}
diff --git a/19-remove-nth-node-from-end-of-list.js b/19-remove-nth-node-from-end-of-list.js
@@ -0,0 +1,31 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} n
+ * @return {ListNode}
+ */
+const removeNthFromEnd = (head, n) => {
+  if (head.next === null) return null;
+
+  let ptrBeforeN = head;
+  let count = 1;
+
+  // While there are more elements
+  let el = head.next;
+  while (el !== null) {
+    if (count > n) ptrBeforeN = ptrBeforeN.next;
+    el = el.next;
+    count++;
+  }
+
+  if (count === n) return head.next;
+
+  ptrBeforeN.next = ptrBeforeN.next.next;
+  return head;
+};
diff --git a/20-valid-parentheses.js b/20-valid-parentheses.js
@@ -0,0 +1,28 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+const isValid = function(s) {
+  const openBrackets = ["(", "{", "["];
+  const closeBrackets = [")", "}", "]"];
+  const oArr = [];
+  let char = "";
+  let cidx = 0;
+  let oidx = 0;
+  for (let i = 0; i < s.length; i++) {
+    char = s.charAt(i);
+    if (closeBrackets.indexOf(char) !== -1) {
+      cidx = closeBrackets.indexOf(char);
+      lastOpenBracket = oArr[oArr.length - 1];
+      oidx = openBrackets.indexOf(lastOpenBracket);
+      if (cidx === oidx) {
+        oArr.pop();
+      } else {
+        return false;
+      }
+    } else {
+      oArr.push(char);
+    }
+  }
+  return oArr.length > 0 ? false : true;
+};
diff --git a/21-merge-two-sorted-lists.js b/21-merge-two-sorted-lists.js
@@ -0,0 +1,24 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+
+const mergeTwoLists = function(l1, l2) {
+  if (l1 === null) return l2;
+  if (l2 === null) return l1;
+  if (l1.val < l2.val) {
+    l1.next = mergeTwoLists(l1.next, l2);
+    return l1;
+  } else {
+    l2.next = mergeTwoLists(l1, l2.next);
+    return l2;
+  }
+};
diff --git a/22-generate-parentheses.js b/22-generate-parentheses.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number} n
+ * @return {string[]}
+ */
+const generateParenthesis = function(n) {
+  const res = [];
+  backtrack(res, "", 0, 0, n);
+  return res;
+};
+function backtrack(arr, cur, open, close, max) {
+  if (cur.length === max * 2) {
+    arr.push(cur);
+    return;
+  }
+  if (open < max) backtrack(arr, cur + "(", open + 1, close, max);
+  if (close < open) backtrack(arr, cur + ")", open, close + 1, max);
+}
diff --git a/24-swap-nodes-in-pairs.js b/24-swap-nodes-in-pairs.js
@@ -0,0 +1,33 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+const swapPairs = function(node) {
+  const head = new ListNode(-1);
+  let cur = head;
+
+  while (node !== null) {
+    if (node.next !== null) {
+      let one = node;
+      let two = node.next;
+      let three = node.next.next;
+      cur.next = two;
+      two.next = one;
+      one.next = three;
+      cur = cur.next.next;
+      node = three;
+    } else {
+      cur.next = node;
+      break;
+    }
+  }
+
+  return head.next;
+};
diff --git a/26-remove-duplicates-from-sorted-array.js b/26-remove-duplicates-from-sorted-array.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const removeDuplicates = function(nums) {
+  if (nums.length === 0) return 0;
+  if (nums.length === 1) return 1;
+  let pre = nums[0];
+  for (let i = 1; i < nums.length; ) {
+    if (nums[i] !== pre) {
+      pre = nums[i];
+      i += 1;
+    } else {
+      nums.splice(i, 1);
+    }
+  }
+  return nums.length;
+};
diff --git a/27-remove-element.js b/27-remove-element.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @param {number} val
+ * @return {number}
+ */
+const removeElement = function(nums, val) {
+  let j = 0;
+  for (let i = 0; i < nums.length; i++) {
+    if (nums[i] !== val) {
+      nums[j] = nums[i];
+      j++;
+    }
+  }
+  return j;
+};
diff --git a/382-linked-list-random-node.js b/382-linked-list-random-node.js
@@ -0,0 +1,37 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param head The linked list's head.
+        Note that the head is guaranteed to be not null, so it contains at least one node.
+ * @param {ListNode} head
+ */
+const Solution = function(head) {
+  this.list = head;
+  this.arr = [];
+  loop(head, this.arr);
+};
+
+/**
+ * Returns a random node's value.
+ * @return {number}
+ */
+Solution.prototype.getRandom = function() {
+  const len = this.arr.length;
+  return this.arr[Math.floor(Math.random() * len)].val;
+};
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * var obj = Object.create(Solution).createNew(head)
+ * var param_1 = obj.getRandom()
+ */
+function loop(node, arr) {
+  if (node == null) return;
+  arr.push(node);
+  loop(node.next, arr);
+}
diff --git a/384-shuffle-an-array.js b/384-shuffle-an-array.js
diff --git a/869-reordered-power-of-2.js b/869-reordered-power-of-2.js
