add scripts.

Author: everthis

10-regular-expression-matching.js

@@ -0,0 +1,27 @@
+/**
+ * @param {string} s
+ * @param {string} p
+ * @return {boolean}
+ */
+const isMatch = function(s, p) {
+  let memory = new Array(s.length + 1)
+    .fill(0)
+    .map(e => new Array(p.length + 1).fill(-1));
+  return memorySearch(s, 0, p, 0, memory);
+};
+
+const memorySearch = (s, i, p, k, memory) => {
+  if (memory[i][k] != -1) return memory[i][k];
+  if (k == p.length) return i == s.length;
+
+  let firstMatch = i < s.length && (s[i] == p[k] || p[k] == ".");
+  if (k + 1 < p.length && p[k + 1] == "*") {
+    memory[i][k] =
+      (firstMatch && memorySearch(s, i + 1, p, k, memory)) ||
+      memorySearch(s, i, p, k + 2, memory);
+  } else {
+    memory[i][k] = firstMatch && memorySearch(s, i + 1, p, k + 1, memory);
+  }
+
+  return memory[i][k];
+};

260-single-number-III.js

@@ -3,14 +3,14 @@
  * @return {number[]}
  */
 const singleNumber = function(nums) {
-    const hash = {}
-    nums.forEach((el, idx) => {
-        if(hash.hasOwnProperty(el)) {
-           hash[el] += 1
-           delete hash[el]
-        } else {
-           hash[el] = 1
-        }
-    })
-    return Object.keys(hash).map(el => +el)
-};
+  const hash = {};
+  nums.forEach((el, idx) => {
+    if (hash.hasOwnProperty(el)) {
+      hash[el] += 1;
+      delete hash[el];
+    } else {
+      hash[el] = 1;
+    }
+  });
+  return Object.keys(hash).map(el => +el);
+};

3-longest-substring-without-repeating-characters.js

@@ -0,0 +1,25 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const lengthOfLongestSubstring = function(s) {
+  // var p=0, q=0; //p: start of the sub, q: end of the queue
+
+  //hashmap in js????? Array.indexOf
+  const sub = [];
+  let max = 0;
+
+  for (let i = 0; i < s.length; i++) {
+    let index = sub.indexOf(s.charAt(i));
+    if (index == -1) {
+      sub.push(s.charAt(i));
+      // q++;
+    } else {
+      //find repeat, get index of repeat el, remve all el before that index
+      sub = sub.slice(index + 1, sub.length);
+      sub.push(s.charAt(i));
+    }
+    max = Math.max(max, sub.length);
+  }
+  return max;
+};

4-median-of-two-sorted-arrays.js

@@ -0,0 +1,49 @@
+/**
+ * @param {number[]} A
+ * @param {number[]} B
+ * @return {number}
+ */
+
+const findMedianSortedArrays = function(A, B) {
+  let m = A.length,
+    n = B.length;
+
+  if (m > n) {
+    return findMedianSortedArrays(B, A);
+  }
+
+  let imin = 0,
+    imax = m,
+    i,
+    j;
+  while (imin <= imax) {
+    i = (imin + imax) >> 1;
+    j = ((m + n + 1) >> 1) - i;
+    if (j > 0 && i < m && B[j - 1] > A[i]) {
+      imin = i + 1;
+    } else if (i > 0 && j < n && A[i - 1] > B[j]) {
+      imax = i - 1;
+    } else {
+      if (i === 0) {
+        num1 = B[j - 1];
+      } else if (j === 0) {
+        num1 = A[i - 1];
+      } else {
+        num1 = Math.max(A[i - 1], B[j - 1]);
+      }
+
+      if ((m + n) & 1) {
+        return num1;
+      }
+
+      if (i === m) {
+        num2 = B[j];
+      } else if (j === n) {
+        num2 = A[i];
+      } else {
+        num2 = Math.min(A[i], B[j]);
+      }
+      return (num1 + num2) / 2.0;
+    }
+  }
+};

406-queue-reconstruction-by-height.js

@@ -3,27 +3,27 @@
  * @return {number[][]}
  */
 const reconstructQueue = function(people) {
-    if (!people) return []
-    const peopledct = {}
-    let height = []
-    const res = []
-    people.forEach((el, idx) => {
-        if (peopledct.hasOwnProperty(el[0])) {
-            peopledct[el[0]].push([el[1], idx])
-        } else {
-            peopledct[el[0]] = [[el[1], idx]]
-            height.push(el[0])
-        }
-    })
-    height = height.sort((a, b) => b - a)
+  if (!people) return [];
+  const peopledct = {};
+  let height = [];
+  const res = [];
+  people.forEach((el, idx) => {
+    if (peopledct.hasOwnProperty(el[0])) {
+      peopledct[el[0]].push([el[1], idx]);
+    } else {
+      peopledct[el[0]] = [[el[1], idx]];
+      height.push(el[0]);
+    }
+  });
+  height = height.sort((a, b) => b - a);
 
-    for (let i = 0; i < height.length; i++) {
-        peopledct[height[i]] = peopledct[height[i]].sort((a, b) => a[0] - b[0])
-        for (el of peopledct[height[i]]) {
-            res.splice(el[0],0, people[el[1]])
-        }
+  for (let i = 0; i < height.length; i++) {
+    peopledct[height[i]] = peopledct[height[i]].sort((a, b) => a[0] - b[0]);
+    for (el of peopledct[height[i]]) {
+      res.splice(el[0], 0, people[el[1]]);
     }
-    return res
+  }
+  return res;
 };
 
-console.log(reconstructQueue([[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]))
+console.log(reconstructQueue([[7, 0], [4, 4], [7, 1], [5, 0], [6, 1], [5, 2]]));

496-next-greater-element-I.js

@@ -4,22 +4,22 @@
  * @return {number[]}
  */
 const nextGreaterElement = function(findNums, nums) {
-    const map = {}
-    const stack = []
-    for(let num of nums) {
-        while(stack.length && stack[stack.length - 1] < num) {
-            let tmp = stack.pop()
-            map[tmp] = num
-        }
-        stack.push(num)
-    }
-    for (let i = 0; i < findNums.length; i++) {
-        findNums[i] = map[findNums[i]] == null ? -1 : map[findNums[i]]
+  const map = {};
+  const stack = [];
+  for (let num of nums) {
+    while (stack.length && stack[stack.length - 1] < num) {
+      let tmp = stack.pop();
+      map[tmp] = num;
     }
+    stack.push(num);
+  }
+  for (let i = 0; i < findNums.length; i++) {
+    findNums[i] = map[findNums[i]] == null ? -1 : map[findNums[i]];
+  }
 
-    return findNums
+  return findNums;
 };
 
-console.log(nextGreaterElement([4,1,2], [1,3,4,2]))
-console.log(nextGreaterElement([2,4], [1,2,3,4]))
-console.log(nextGreaterElement([1,2,3], [9, 8, 7, 3, 2, 1, 6]))
+console.log(nextGreaterElement([4, 1, 2], [1, 3, 4, 2]));
+console.log(nextGreaterElement([2, 4], [1, 2, 3, 4]));
+console.log(nextGreaterElement([1, 2, 3], [9, 8, 7, 3, 2, 1, 6]));

5-longest-palindromic-substring.js

@@ -0,0 +1,49 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const longestPalindrome = function(s) {
+  let T = preProcess(s);
+  let n = T.length;
+  let P = [];
+  let C = 0,
+    R = 0;
+  let i_mirror;
+  for (let i = 1; i < n - 1; i++) {
+    i_mirror = 2 * C - i; // equals to i' = C - (i-C)
+
+    P[i] = R > i ? Math.min(R - i, P[i_mirror]) : 0;
+
+    // Attempt to expand palindrome centered at i
+    while (T[i + 1 + P[i]] == T[i - 1 - P[i]]) P[i]++;
+
+    // If palindrome centered at i expand past R,
+    // adjust center based on expanded palindrome.
+    if (i + P[i] > R) {
+      C = i;
+      R = i + P[i];
+    }
+  }
+
+  // Find the maximum element in P.
+  let maxLen = 0;
+  let centerIndex = 0;
+  for (let j = 1; j < n - 1; j++) {
+    if (P[j] > maxLen) {
+      maxLen = P[j];
+      centerIndex = j;
+    }
+  }
+
+  return s.substr((centerIndex - 1 - maxLen) / 2, maxLen);
+};
+
+function preProcess(s) {
+  let n = s.length;
+  if (n === 0) return "^$";
+  let ret = "^";
+  for (let i = 0; i < n; i++) ret += "#" + s.substr(i, 1);
+
+  ret += "#$";
+  return ret;
+}

513-find-bottom-left-tree-value.js

@@ -10,20 +10,20 @@
  * @return {number}
  */
 const findBottomLeftValue = function(root) {
-    const res = []
-    single(root, 0, res)
-    return res[res.length - 1][0].val
+  const res = [];
+  single(root, 0, res);
+  return res[res.length - 1][0].val;
 };
 
 function single(node, row, arr) {
-    if (node == null) {
-        return null
-    }
-    if (row < arr.length) {
-        arr[row].push(node)
-    } else {
-        arr[row] = [node]
-    }
-    single(node.left, row + 1, arr)
-    single(node.right, row + 1, arr)
-}
+  if (node == null) {
+    return null;
+  }
+  if (row < arr.length) {
+    arr[row].push(node);
+  } else {
+    arr[row] = [node];
+  }
+  single(node.left, row + 1, arr);
+  single(node.right, row + 1, arr);
+}

515-find-largest-value-in-each-tree-row.js

@@ -10,22 +10,22 @@
  * @return {number[]}
  */
 const largestValues = function(root) {
-    const res = []
-    single(root, 0, res)
-    return res
+  const res = [];
+  single(root, 0, res);
+  return res;
 };
 
 function single(node, row, arr) {
-    if (node == null) {
-        return null
+  if (node == null) {
+    return null;
+  }
+  if (row < arr.length) {
+    if (node.val > arr[row]) {
+      arr[row] = node.val;
     }
-    if (row < arr.length) {
-        if (node.val > arr[row]) {
-            arr[row] = node.val
-        }
-    } else {
-        arr[row] = node.val
-    }
-    single(node.left, row + 1, arr)
-    single(node.right, row + 1, arr)
-}
+  } else {
+    arr[row] = node.val;
+  }
+  single(node.left, row + 1, arr);
+  single(node.right, row + 1, arr);
+}

540-single-element-in-a-sorted-array.js

@@ -3,12 +3,12 @@
  * @return {number}
  */
 const singleNonDuplicate = function(nums) {
-    let i=0;
-    while(true){
-        if(nums[i]==nums[i+1]) {
-            i+=2;
-        } else {
-            return nums[i];
-        }
+  let i = 0;
+  while (true) {
+    if (nums[i] == nums[i + 1]) {
+      i += 2;
+    } else {
+      return nums[i];
     }
-};
+  }
+};