add new scripts.

Author: everthis

100-same-tree.js

@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {boolean}
+ */
+const isSameTree = function(p, q) {
+  return isSame(p, q);
+};
+
+const isSame = (p, q) => {
+  if (p === null && q === null) return true;
+
+  if ((p !== null && q === null) || (p === null && q !== null)) return false;
+
+  if (p.val !== q.val) return false;
+
+  return isSame(p.left, q.left) && isSame(p.right, q.right);
+};

104-maximum-depth-of-binary-tree.js

@@ -0,0 +1,18 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const maxDepth = function(root) {
+  if (!root) return 0;
+  const left = maxDepth(root.left);
+  const right = maxDepth(root.right);
+  let depth = left > right ? left : right;
+  return (depth += 1);
+};

118-pascal's-triangle.js

@@ -0,0 +1,38 @@
+/**
+ * @param {number} numRows
+ * @return {number[][]}
+ */
+const generate = function(numRows) {
+  // row 0 => [1] length 0
+  // row 1 => [1, 1] length 1
+  // row 2 => [1, 2, 1] length 2
+  // row 3 => [1, 3, 3, 1] length 3
+
+  // current[i] = prev[i - 1] + prev[i]
+
+  const res = [];
+  for (let row = 0; row < numRows; row += 1) {
+    if (row === 0) {
+      res.push([1]);
+      continue;
+    }
+
+    if (row === 1) {
+      res.push([1, 1]);
+      continue;
+    }
+
+    const newRow = [];
+    const maxIdx = row;
+    for (let i = 0; i <= maxIdx; i += 1) {
+      if (i === 0 || i === maxIdx) {
+        newRow.push(1);
+      } else {
+        newRow.push(res[row - 1][i - 1] + res[row - 1][i]);
+      }
+    }
+    res.push(newRow);
+  }
+
+  return res;
+};

119-pascal's-triangle-II.js

@@ -0,0 +1,16 @@
+/**
+ * @param {number} rowIndex
+ * @return {number[]}
+ */
+const getRow = function(rowIndex) {
+  if (!rowIndex) return [1];
+  if (rowIndex === 1) return [1, 1];
+  const res = [1, 1];
+  for (let i = 2; i <= rowIndex; i++) {
+    res[i] = 1;
+    for (let j = i - 1; j >= 1; j--) {
+      res[j] = res[j] + res[j - 1];
+    }
+  }
+  return res;
+};

146-lru-cache.js

@@ -0,0 +1,82 @@
+class Node {
+  constructor(key, val) {
+    this.val = val;
+    this.key = key;
+    this.next = this.pre = null;
+  }
+}
+
+const LRUCache = function(capacity) {
+  this.capacity = capacity;
+  this.count = 0;
+  this.start = new Node(-1, -1);
+  this.end = new Node(-1, -1);
+  this.start.next = this.end;
+  this.end.pre = this.start;
+  this.map = {};
+};
+
+// insert node into the next of the start
+const insertAfter = function(start, node) {
+  let next = start.next;
+  start.next = node;
+  node.pre = start;
+  node.next = next;
+  next.pre = node;
+};
+
+const detach = function(node) {
+  let pre = node.pre,
+    next = node.next;
+  pre.next = next;
+  next.pre = pre;
+  node.next = node.pre = null;
+};
+
+/**
+ * @param {number} key
+ * @return {number}
+ */
+LRUCache.prototype.get = function(key) {
+  let node = this.map[key];
+  if (node != undefined) {
+    detach(node);
+    insertAfter(this.start, node);
+    return node.val;
+  } else {
+    return -1;
+  }
+};
+
+/**
+ * @param {number} key
+ * @param {number} value
+ * @return {void}
+ */
+LRUCache.prototype.put = function(key, value) {
+  let node = this.map[key];
+  if (!node) {
+    if (this.count == this.capacity) {
+      // deleting last nodes
+      let t = this.end.pre;
+      detach(t);
+      delete this.map[t.key];
+    } else {
+      this.count++;
+    }
+    node = new Node(key, value);
+    this.map[key] = node;
+    insertAfter(this.start, node);
+  } else {
+    node.val = value;
+    detach(node);
+    insertAfter(this.start, node);
+  }
+};
+
+/**
+ * Your LRUCache object will be instantiated and called as such:
+ * var obj = Object.create(LRUCache).createNew(capacity)
+ * var param_1 = obj.get(key)
+ * obj.put(key,value)
+ */

151-reverse-words-in-a-string.js

@@ -0,0 +1,11 @@
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+const reverseWords = function(str) {
+  return str
+    .trim()
+    .split(/\s+/)
+    .reverse()
+    .join(" ");
+};

241-different-ways-to-add-parentheses.js

@@ -0,0 +1,36 @@
+/**
+ * @param {string} input
+ * @return {number[]}
+ */
+const diffWaysToCompute = function(input) {
+  const res = [];
+  let left;
+  let right;
+  for (let i = 0; i < input.length; i++) {
+    if (input[i] < "0") {
+      left = diffWaysToCompute(input.slice(0, i));
+      right = diffWaysToCompute(input.slice(i + 1));
+      for (let rl of left) {
+        for (let rr of right) {
+          switch (input[i]) {
+            case "+":
+              res.push(rl + rr);
+              break;
+            case "-":
+              res.push(rl - rr);
+              break;
+            case "*":
+              res.push(rl * rr);
+              break;
+            default:
+              break;
+          }
+        }
+      }
+    }
+  }
+  if (res.length === 0) {
+    res.push(+input);
+  }
+  return res;
+};

445-add-two-numbers-II.js

@@ -0,0 +1,42 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+const addTwoNumbers = function(l1, l2) {
+  const s1 = [];
+  const s2 = [];
+  while (l1 !== null) {
+    s1.push(l1.val);
+    l1 = l1.next;
+  }
+  while (l2 !== null) {
+    s2.push(l2.val);
+    l2 = l2.next;
+  }
+
+  let list = new ListNode(0);
+  let sum = 0;
+  while (s1.length > 0 || s2.length > 0) {
+    if (s1.length > 0) {
+      sum += s1.pop();
+    }
+    if (s2.length > 0) {
+      sum += s2.pop();
+    }
+    list.val = sum % 10;
+    const head = new ListNode(Math.floor(sum / 10));
+    head.next = list;
+    list = head;
+    sum = Math.floor(sum / 10);
+  }
+
+  return list.val === 0 ? list.next : list;
+};

83-remove-duplicates-from-sorted-list.js

@@ -0,0 +1,22 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+const deleteDuplicates = function(head) {
+  let current = head;
+  while (current !== null && current.next !== null) {
+    if (current.val === current.next.val) {
+      current.next = current.next.next;
+    } else {
+      current = current.next;
+    }
+  }
+  return head;
+};