feat(leetcode): add 342

Author: man-fish

README.md

@@ -1,2 +1,3 @@
 # typescript-algorithms
+
 some datastructs and algorithms written by ts.

src/playground/leetcode/342power-of-four/isPowerOfFour.ts

@@ -0,0 +1,34 @@
+//   0 1 0 1 0 1 0 1
+//    64  16   4   1
+// -----------------
+//   1 0 0 0 0 0 0 0
+//   0 1 1 1 1 1 1 1
+// &----------------
+//   0 0 0 0 0 0 0 0
+export default function isPowerOfFour(num: number): boolean {
+    return (
+        num > 0 && // is positive.
+        (num & (num - 1)) === 0 && // is power of 2.
+        (num & 0x55555555) === num // is power of 4.
+    );
+    /** 
+        return (
+            (num > 0 && (num ^ 0x1) === 0) ||
+            (num ^ 0x4) === 0 ||
+            (num ^ 0x10) === 0 ||
+            (num ^ 0x40) === 0 ||
+            (num ^ 0x100) === 0 ||
+            (num ^ 0x400) === 0 ||
+            (num ^ 0x1000) === 0 ||
+            (num ^ 0x4000) === 0 ||
+            (num ^ 0x10000) === 0 ||
+            (num ^ 0x40000) === 0 ||
+            (num ^ 0x100000) === 0 ||
+            (num ^ 0x400000) === 0 ||
+            (num ^ 0x1000000) === 0 ||
+            (num ^ 0x4000000) === 0 ||
+            (num ^ 0x10000000) === 0 ||
+            (num ^ 0x40000000) === 0
+        );
+    */
+}

src/playground/leetcode/face/1.ts

@@ -0,0 +1,79 @@
+export default function findDiagonalOrder(matrix: number[][]): number[] {
+    let n = matrix.length;
+    if (!n) return [];
+    let m = matrix[0].length;
+    let turns = 2 * n - 1;
+    let res = [];
+    let forward = true;
+    let x = 0;
+    let y = 0;
+    res.push(matrix[0][0]);
+    for (let i = 2; i < turns; i++) {
+        let overHalf = i > Math.ceil(turns / 2);
+        x = forward && !overHalf ? x + 1 : x;
+        y = forward && !overHalf ? y : y + 1;
+        forward = !forward;
+        res.push(matrix[y][x]);
+        if (forward) {
+            while (y > 0 && x < n - 1) {
+                x += 1;
+                y -= 1;
+                console.log([y, x]);
+                res.push(matrix[y][x]);
+            }
+        } else {
+            while (x > 0 && y < n - 1) {
+                x -= 1;
+                y += 1;
+                console.log([y, x]);
+                res.push(matrix[y][x]);
+            }
+        }
+    }
+    res.push(matrix[n - 1][n - 1]);
+
+    return res;
+}
+
+function findDiagonalOrder2(matrix: number[][]): number[] {
+    let n = matrix.length;
+    let idxes = new Array(n).fill(0);
+    let res = [];
+    let m = matrix[0].length;
+    let edge = Math.max(m, n);
+    let levels = 2 * edge - 1;
+    let towns = 1;
+    let overHalf = false;
+    for (let i = 0; i < levels; i++) {
+        let idx = 0;
+        overHalf = i >= Math.ceil(levels / 2);
+        if (!overHalf) {
+            while (idx < towns && idx < n) {
+                res.push(matrix[idx][idxes[idx]]);
+                idxes[idx]++;
+                idx++;
+            }
+            towns++;
+        } else {
+            while (idx < towns) {
+                if (edge - idx > n) {
+                    idx++;
+                    continue;
+                }
+                res.push(matrix[edge - idx][idxes[edge - idx]]);
+                idxes[edge - idx]++;
+                idx++;
+            }
+            towns--;
+        }
+    }
+    return res;
+}
+
+let res = findDiagonalOrder2([
+    [1, 2, 3],
+    [4, 5, 6],
+    [7, 8, 9],
+]);
+
+console.log(res);