Merge pull request #1181 from aakhtar3/math

refactor: js - math

Author: aakhtar3

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) */
+}