Merge pull request neetcode-gh#1181 from aakhtar3/math

refactor: js - math

javascript/2013-Detect-Squares.js

@@ -1,43 +1,52 @@
-var DetectSquares = function () {
- this.ptsCount = {};
- this.pts = [];
-};
-
-/**
- * @param {number[]} point
- * @return {void}
+/*
+ * Time O(N) | Space O(N)
+ * https://leetcode.com/problems/detect-squares
  */
-DetectSquares.prototype.add = function (point) {
- var str = point[0] + ',' + point[1];
- if (!this.ptsCount[str]) {
- this.ptsCount[str] = 0;
+class DetectSquares {
+ constructor () {
+  this.map = {}; /* Space O(N) */
+ this.points = [];/* Space O(N) */
  }
+
+ add (point, { map, points } = this) {
+ const [ x, y ] = point;
+ const key = this.getKey(x, y);
+ const value = ((map[key] || 0) + 1);
 
- this.ptsCount[str]++;
- this.pts.push(point);
-};
+  map[key] = value; /* Space O(N) */
+  points.push(point);/* Space O(N) */
+ }
 
-/**
- * @param {number[]} point
- * @return {number}
- */
-DetectSquares.prototype.count = function (point) {
- var res = 0;
- var [x, y] = point;
- for (var [px, py] of this.pts) {
- if (Math.abs(px - x) !== Math.abs(py - y) || x === px || y === py) {
- continue;
+ count (point, { points } = this, score = 0) {
+  const [ x1, y1 ] = point;
+
+  for (const [ x2, y2 ] of points) {/* Time O(N) */
+ const isSame = (Math.abs(x2 - x1) === Math.abs(y2 - y1));
+  const isEqual = ((x1 === x2) || (y1 === y2));
+  const canSkip = (!isSame || isEqual);
+  if (canSkip) continue;
+
+ score += this.getScore(x1, y1, x2, y2);
  }
 
- res += (this.ptsCount[[x, py]] || 0) * (this.ptsCount[[px, y]] || 0);
+ return score;
+ };
+
+ getKey (x, y) {
+ return `${x},${y}`;
  }
 
- return res;
+ getScore (x1, y1, x2, y2, { map } = this) {
+ const [ aKey, bKey ] = [ this.getKey(x1, y2), this.getKey(x2, y1) ];
+ const [ aScore, bScore ] = [ (map[aKey] || 0), (map[bKey] || 0) ];
+
+ return (aScore * bScore);
+ }
 };
 
-/**
+/** 
  * Your DetectSquares object will be instantiated and called as such:
  * var obj = new DetectSquares()
  * obj.add(point)
  * var param_2 = obj.count(point)
- */
+ */

javascript/202-Happy-Number.js

@@ -1,25 +1,114 @@
-function isHappy(n) {
- const visit = new Set();
+/**
+ * Hash Set - seen dynamic
+ * Time O(log(N)) | Space O(log(N))
+ * https://leetcode.com/problems/happy-number/
+ * @param {number} n
+ * @return {boolean}
+ */
+ var isHappy = (n, seen = new Set()) => {
+ const hasCycle = () => ((n === 1) || (seen.has(n)));
+ while (!hasCycle()) {/* Time O(log(N)) */
+ seen.add(n); /* Space O(log(N)) */
+ n = getNext(n); /* Time O(log(N)) */
+ }
+
+ return (n === 1);
+};
+
+var getNext = (n, sum = 0) => {
+ while (0 < n) {/* Time O(log(N)) */
+ const remainder = (n % 10);
+
+ n = Math.floor((n / 10));
+ sum += (remainder * remainder);
+ }
+
+ return sum;
+}
 
- while (!visit.has(n)) {
- visit.add(n);
- n = sumOfSquares(n);
+/**
+ * Hash Set - seen static
+ * Time O(log(N)) | Space O(1)
+ * https://leetcode.com/problems/happy-number/
+ * @param {number} n
+ * @return {boolean}
+ */
+var isHappy = (n) => {
+ const cycles = [ 4, 16, 37, 58, 89, 145, 42, 20 ];
+ const seen = new Set(cycles);/* Time O(1) | Space O(1) */
 
- if (n == 1) return true;
+ const hasCycle = () => ((n === 1) || (seen.has(n)));
+ while (!hasCycle()) { /* Time O(log(N)) | Space O(1) */
+ n = getNext(n);
  }
 
- return false;
+ return n === 1;
 }
 
-function sumOfSquares(n) {
- let output = 0;
+var getNext = (n, sum = 0) => {
+ while (0 < n) {/* Time O(log(N)) */
+ const remainder = (n % 10);
+
+ n = Math.floor((n / 10));
+ sum += (remainder * remainder);
+ }
+
+ return sum;
+}
 
- while (n) {
- let digit = n % 10;
- digit = digit ** 2;
- output += digit;
- n = Math.floor(n / 10);
+/**
+ * Pointer - n === 1 || n === 4
+ * Time O(log(N)) | Space O(1)
+ * https://leetcode.com/problems/happy-number/
+ * @param {number} n
+ * @return {boolean}
+ */
+var isHappy = (n) => {
+ const hasCycle = () => ((n === 1) || (n === 4));
+ while (!hasCycle()) {/* Time O(log(N)) */
+ n = getNext(n); /* Time O(log(N)) */
  }
 
- return output;
+ return n === 1;
 }
+
+var getNext = (n, sum = 0) => {
+ while (0 < n) {/* Time O(log(N)) */
+ const remainder = (n % 10);
+
+ n = Math.floor((n / 10));
+ sum += (remainder * remainder);
+ }
+
+ return sum;
+}
+
+/**
+ * Slow Fast
+ * Time O(log(N)) | Space O(1)
+ * https://leetcode.com/problems/happy-number/
+ * @param {number} n
+ * @return {boolean}
+ */
+var isHappy = (n) => {
+ let [ slow, fast ] = [ n, getNext(n) ];
+
+ const hasCyle = () => ((fast === 1) || (slow === fast));
+ while (!hasCyle()) { /* Time O(log(N)) */
+ slow = getNext(slow); /* Time O(log(N)) */
+ fast = getNext(getNext(fast));/* Time O(log(N)) */
+ }
+
+ return (fast === 1);
+}
+
+var getNext = (n, sum = 0) => {
+ while (0 < n) {/* Time O(log(N)) */
+ const remainder = (n % 10);
+
+ n = Math.floor((n / 10));
+ sum += (remainder * remainder);
+ }
+
+ return sum;
+}

javascript/43-Multiply-Strings.js

@@ -1,30 +1,116 @@
 /**
+ * Matrix
+ * Time O(N * M) | Space O(N + M)
+ * https://leetcode.com/problems/multiply-strings/
  * @param {string} num1
  * @param {string} num2
  * @return {string}
  */
-var multiply = function (num1, num2) {
- if (num1 === '0' || num2 === '0') {
- return '0';
- }
+var multiply = (num1, num2) => {
+ const isZero = ((num1 === '0') || (num2 === '0'));
+ if (isZero) return '0';
+
+ const buffer = initBuffer(num1, num2);/* | Space (N + M) */
+
+ multiplication(num1, num2, buffer) /* Time O(N * M) */
+ removeLeadingZero(buffer); /* Time O(N + M) | Time O(N + M)*/
+
+ return buffer.join(''); /* Time O(N + M) | Space O(N + M) */
+};
 
- var res = new Array(num1.length + num2.length).fill(0);
- var revNum1 = [...num1].reverse();
- var revNum2 = [...num2].reverse();
-
- for (var i1 in revNum1) {
- for (var i2 in revNum2) {
- var digit = revNum1[i1] * revNum2[i2];
- var index = Number(i1) + Number(i2);
- res[index] += digit;
- res[index + 1] += Math.floor(res[index] / 10);
- res[index] = res[index] % 10;
+var initBuffer = (num1, num2) => {
+ const size = (num1.length + num2.length);
+
+ return new Array(size).fill(0);/* Space (N + M) */
+}
+
+var multiplication = (num1, num2, buffer) => {
+ for (let i = (num1.length - 1); (0 <= i); i--) {/* Time O(N) */
+ for (let j = (num2.length - 1); (0 <= j); j--) {/* Time O(M) */
+ update(num1, i, num2, j, buffer); /* Space O(N + M) */
  }
  }
+}
 
- if (res[res.length - 1] === 0) {
- res.pop();
- }
+var removeLeadingZero = (buffer) => {
+ const isLeadZero = (buffer[0] === 0);
+ if (!isLeadZero) return;
+
+ buffer.shift();/* Time O(N + M) | Time O(N + M) */
+}
+
+var update = (num1, i, num2, j, buffer) => {
+ const curPos = (i + j);
+ const prevPos = curPos + 1;
 
- return res.reverse().join('');
+ const carry = buffer[prevPos];
+ const product = getProduct(num1, i, num2, j);
+ const sum = (carry + product);
+
+ const remainder = (sum % 10);
+ const value = ((sum - remainder) / 10);
+
+ buffer[prevPos] = remainder;/* Space O(N + M) */
+ buffer[curPos] += value; /* Space O(N + M) */
+}
+
+var getProduct = (num1, i, num2, j) => {
+ const [ iNum, jNum ] = [ Number(num1[i]), Number(num2[j]) ];
+
+ return (iNum * jNum);
+}
+
+/**
+ * Matrix
+ * Time O(N * M) | Space O(N + M)
+ * https://leetcode.com/problems/multiply-strings/
+ * @param {string} num1
+ * @param {string} num2
+ * @return {string}
+ */
+var multiply = (num1, num2) => {
+ const isZero = ((num1 === '0') || (num2 === '0'));
+ if (isZero) return '0';
+
+ const buffer = initBuffer(num1, num2);/* | Space O(N + M) */
+
+ multiplication(num1, num2, buffer); /* Time O(N * M) | Space O(N + M) */
+ removeLeadingZero(buffer); /* Time O(N + M) | Space O(N + M) */
+
+ return buffer.join(''); /* Time O(N + M) | Space O(N + M) */
 };
+
+var initBuffer = (num1, num2) => new Array(num1.length + num2.length).fill(0);/* Space O(N + M) */
+
+var multiplication = (num1, num2, buffer) => {
+ [ num1, num2 ] = /* Time O(N + M) */
+ [ reverse(num1), reverse(num2) ];
+
+ for (var i1 in num1) {/* Time O(N) */
+ for (var i2 in num2) {/* Time O(M) */
+ update(num1, i1, num2, i2, buffer);/* Space O(N + M) */
+ }
+ }
+
+ buffer.reverse();/* Time O(N + M) */
+}
+
+const reverse = (s) => s
+ .split('') /* Time O(K) | Space O (K) */
+ .reverse();/* Time O(K) */
+
+var update = (num1, i1, num2, i2, buffer) => {
+ const product = num1[i1] * num2[i2];
+ const index = Number(i1) + Number(i2);
+
+ buffer[index] += product; /* Space O(N + M) */
+ buffer[(index + 1)] += Math.floor(buffer[index] / 10);/* Space O(N + M) */
+ buffer[index] = (buffer[index] % 10); /* Space O(N + M) */
+}
+
+var removeLeadingZero = (buffer) => {
+ const isZero = (buffer[0] === 0);
+ if (!isZero) return;
+
+ buffer.shift();/* Time O(N + M) | Space O(N + M) */
+}