submit

Author: EasyHard

.dir-locals.el

@@ -4,7 +4,7 @@
                         (defun find-file-func ()
                           (when (eq 0 (buffer-size))
                             (insert-buffer-substring "javascript-template.js"))
-                          (setq-local compile-command (format "DEBUG=1 node %s" (buffer-name)))
+                          (setq-local compile-command (format "DEBUG=1 node --harmony %s" (buffer-name)))
                           (local-set-key (kbd "<f9>") 'compile)
                           )
                         (add-hook 'find-file-hook 'find-file-func)

binary-tree-postorder-traversal.js

@@ -0,0 +1,58 @@
+var DEBUG = process.env.DEBUG;
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var postorderTraversal = function(root) {
+  if (!root) return [];
+  var stack = [];
+  var ans = [];
+  stack.push({
+    node: root,
+    next: 'L'
+  });
+  while (stack.length) {
+    var c = stack.pop();
+    if (!c.node) continue;
+    if (c.next === 'L') {
+      stack.push({
+        node: c.node,
+        next: 'R'
+      });
+      stack.push({
+        node: c.node.left,
+        next: 'L'
+      });
+    } else if (c.next === 'R') {
+      stack.push({
+        node: c.node
+      });
+      stack.push({
+        node: c.node.right,
+        next: 'L'
+      });
+    } else {
+      ans.push(c.node.val);
+    }
+  }
+  return ans;
+};
+
+function test(f) {
+
+  [
+    [{val: 9, left: {val: 1}, right: {val: 10}}]
+  ].forEach(function (input) {
+    console.log(f.apply(undefined, input));
+  });
+}
+
+if (DEBUG) test(postorderTraversal);

candy-input1.js

@@ -0,0 +1,48 @@
+var DEBUG = process.env.DEBUG;
+
+
+/**
+ * @param {number[]} ratings
+ * @return {number}
+ */
+var candy = function(ratings) {
+  if (ratings.length === 0) return 0;
+  var v = [1];
+  var count = 1;
+  for (var i = 1; i < ratings.length; i++) {
+    if (ratings[i-1] < ratings[i]) {
+      count++;
+      v.push(count);
+    } else {
+      count = 1;
+      v.push(count);
+    }
+  }
+  for (var i = ratings.length - 2; i >= 0; i--) {
+    if (ratings[i+1] < ratings[i]) {
+      v[i] = Math.max(v[i], v[i+1]+1);
+    }
+  }
+  return v.reduce(function (prev, item) {
+    return prev + item;
+  }, 0);
+};
+
+
+function test(f) {
+
+  [
+    [[1]],
+    [[2]],
+    [[2,2]],
+    [[3,2,1]],
+    [[3,2,1,1,2,3]],
+    [[3,3,2,1,1,2,3,3]],
+    [require('./candy-input1.js')],
+    [require('./candy-input2.js')]
+  ].forEach(function (input) {
+    console.log(f.apply(undefined, input));
+  });
+}
+
+if (DEBUG) test(candy);

candy-input2.js

@@ -0,0 +1,71 @@
+var DEBUG = process.env.DEBUG;
+
+var ops = {
+  '+': function (a, b) { return a + b;},
+  '-': function (a, b) { return a - b;},
+  '*': function (a, b) { return a * b;}
+};
+
+/**
+ * @param {string} input
+ * @return {number[]}
+ */
+var diffWaysToCompute = function(input) {
+  var m = aExpr(input);
+  return m.sort(function (a, b) {return a - b;});
+};
+
+function aExpr(input) {
+  var ans = [];
+  for (var i = 0; i < input.length; i++) {
+    if (input[i] in ops) {
+      var a1 = aExpr(input.slice(0, i));
+      var a2 = aExpr(input.slice(i+1));
+      for (var v1 in a1)
+        for (var v2 in a2)
+          ans.push(ops[input[i]](a1[v1], a2[v2]));
+    }
+  }
+  if (ans.length === 0)
+    ans.push(sExpr(input).value());
+  return ans;
+}
+
+function sExpr(str) {
+  var i = 0;
+  while (i < str.length && ! (str[i] in ops)) i++;
+  if (i === str.length) {
+    return new Expr(str);
+  } else {
+    return new Expr(str[i], sExpr(str.slice(0, i)), sExpr(str.slice(i+1)));
+  }
+}
+
+function Expr(op, expr1, expr2) {
+  this.op = op;
+  this.expr1 = expr1;
+  this.expr2 = expr2;
+}
+
+Expr.prototype.value = function () {
+  if (isNaN(Number(this.op))) {
+    var v1 = this.expr1.value();
+    var v2 = this.expr2.value();
+    return ops[this.op](v1, v2);
+  } else {
+    return Number(this.op);
+  }
+};
+
+
+function test(f) {
+
+  [
+    ["2*3-4*5"],
+    ["2-1-1"]
+  ].forEach(function (input) {
+    console.log(f.apply(undefined, input));
+  });
+}
+
+if (DEBUG) test(diffWaysToCompute);

candy.js

@@ -0,0 +1,44 @@
+var DEBUG = process.env.DEBUG;
+
+/**
+ * @param {number[][]} dungeon
+ * @return {number}
+ */
+var calculateMinimumHP = function(dungeon) {
+  var n = dungeon.length;
+  var m = dungeon[0].length;
+  var ans = [];
+  for (var i = 0; i < m; i++) ans.push(0);
+  ans.push(Math.pow(2, 31));
+  ans[m-1] = dungeon[n-1][m-1] > 0 ? 1 : -dungeon[n-1][m-1] + 1;
+  for (var i = m-2; i >= 0; i--) {
+    var t = ans[i+1];
+    t = t - dungeon[n-1][i];
+    if (t <= 0) t = 1;
+    ans[i] = t;
+  }
+  for (var j = n-2; j >= 0; j--) {
+    for (var i = m - 1; i >= 0; i--) {
+      t = Math.min(ans[i+1], ans[i]);
+      t = t - dungeon[j][i];
+      if (t <= 0) t = 1;
+      ans[i] = t;
+    }
+  }
+  return ans[0];
+};
+
+
+function test(f) {
+
+  [
+    [[[-2, -3, 3],
+     [-5, -10, 1],
+     [10, 30, -5]]
+    ]
+  ].forEach(function (input) {
+    console.log(f.apply(undefined, input));
+  });
+}
+
+if (DEBUG) test(calculateMinimumHP);

different-ways-to-add-parentheses.js

@@ -0,0 +1,56 @@
+var DEBUG = process.env.DEBUG;
+
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+
+Array.prototype.max = function () {
+  return this.reduce((p, c) => Math.max(p, c), -1);
+};
+
+Array.prototype.min = function () {
+  return this.reduce((prev, curr) => Math.min(prev, curr), Math.pow(2, 32));
+};
+var maximumGap = function(nums) {
+  if (nums.length < 2) return 0;
+  var nb = nums.length*2;
+  var min = nums.min();
+  var max = nums.max();
+  var len = Math.ceil( (max-min) / nb);
+
+  var b = {};
+  nums.forEach(num => {
+    var idx = Math.floor((num - min) / len);
+    b[idx] = b[idx] || {nums: []};
+    b[idx].nums.push(num);
+  });
+  for (var idx in b) {
+    b[idx].max = b[idx].nums.max();
+    b[idx].min = b[idx].nums.min();
+  }
+  var ans = 0;
+  for (var i = 0; i <= nb;) {
+    var j = i + 1;
+    while (j <= nb && !b[j]) j++;
+    if (j > nb) break;
+    ans = Math.max(ans, b[j].min - b[i].max);
+    i = j;
+  }
+  return ans;
+};
+
+function test(f) {
+
+  [
+    [[1, 2]],
+    [[2, 2, 2, 2, 2, 2]],
+    [[1,2,3,4,5]],
+    [[77, 55, 22, 33, 1]]
+  ].forEach(function (input) {
+    console.log(f.apply(undefined, input));
+  });
+}
+
+if (DEBUG) test(maximumGap);

dungeon-game.js

@@ -0,0 +1,74 @@
+var DEBUG = process.env.DEBUG;
+
+
+/**
+ * @param {number} n
+ * @return {string[][]}
+ */
+var loc = [];
+var ans = [];
+var usedCols = {};
+var N;
+function cons(t) {
+  var s = '';
+  for (var i = 0; i < t; i++)
+    s += '.';
+  s += 'Q';
+  for (var i = t + 1; i < N; i++)
+    s += '.';
+  return s;
+}
+
+function dfs(d) {
+  if (d === N) {
+    var tmp = [], t1 = [];
+    for (var j = 0; j < N; j++) {
+      tmp.push(cons(loc[j]));
+      //t1.push(cons(N-loc[j]));
+    }
+    ans.push(tmp);
+    return;
+  }
+  for (var i = 0; i < N; i++) {
+    if (!usedCols[i]) {
+      var bad = false;
+      for (var j = 0; j < d; j++)
+        if (d - j === Math.abs(i - loc[j]))
+          bad = true;
+      if (!bad) {
+        usedCols[i] = true;
+        loc.push(i);
+        dfs(d+1);
+        loc.pop();
+        usedCols[i] = false;
+      }
+    }
+  }
+}
+var solveNQueens = function(n) {
+  N = n;
+  ans = [];
+  usedCols = {};
+  //for (var i = 0; i < Math.floor((n + 1) / 2); i++) {
+    loc = [];
+    dfs(0);
+  //}
+  return ans;
+};
+
+
+function test(f) {
+
+  [
+    [4],
+    [5],
+    [6],
+    [7],
+    [8],
+    [9]
+  ].forEach(function (input) {
+    console.log(f.apply(undefined, input));
+  });
+}
+
+if (DEBUG) test(solveNQueens);