update

Author: realdennis

src/4-sum-ii.ts

@@ -0,0 +1,26 @@
+function fourSumCount(
+  A: number[],
+  B: number[],
+  C: number[],
+  D: number[]
+): number {
+  // group {C,D}, collect their sum, n*n
+
+  const map: Map<number, number> = new Map();
+  for (const c of C) {
+    for (const d of D) {
+      const sum = c + d;
+      map.set(sum, (map.get(sum) || 0) + 1);
+    }
+  }
+
+  // group {A,B} to check if there's a pair sum, which -sum could match in map
+  let ret = 0;
+  for (const a of A) {
+    for (const b of B) {
+      const sum = a + b;
+      if (map.has(-1 * sum)) ret += map.get(-1 * sum) || 0;
+    }
+  }
+  return ret;
+}

src/Node.ts

@@ -0,0 +1,12 @@
+class Node {
+  val: number;
+  prev: Node | null;
+  next: Node | null;
+  child: Node | null;
+  constructor(val?: number, prev?: Node, next?: Node, child?: Node) {
+    this.val = val === undefined ? 0 : val;
+    this.prev = prev === undefined ? null : prev;
+    this.next = next === undefined ? null : next;
+    this.child = child === undefined ? null : child;
+  }
+}

src/flatten-a-multilevel-doubly-linded-list.ts

@@ -0,0 +1,19 @@
+function flatten(head: Node | null): Node | null {
+  const stack: Node[] = []; // store the next
+  let ptr = head;
+  while (ptr !== null) {
+    if (ptr.child !== null) {
+      const next = ptr.next;
+      const child = ptr.child;
+      next !== null && stack.push(next);
+      ptr.next = child;
+      ptr.child = null;
+    }
+    if (ptr.next === null && stack.length !== 0) ptr.next = stack.pop() as Node;
+    if (ptr.next !== null) ptr.next.prev = ptr;
+
+    ptr = ptr.next;
+  }
+
+  return head;
+}

src/game-of-life.ts

@@ -0,0 +1,69 @@
+function gameOfLife(board: number[][]): void {
+  /**
+      1. State change rule
+          dead cell 
+              - 3 live neighbors become live
+          
+          live cell: 
+              - < 2 neighbor dies
+              - 2-3 neighbor live
+              - >3 neighbor dies
+      
+      2. To implement the in-place approach, we rely other two state
+          s1      s2
+          die  -> die  : 00 -> 00
+          die  -> live : 00 -> 10
+          live -> live : 01 -> 11
+          live -> die  : 01 -> 01
+  
+          using %2 to get s1
+          using >>1 to get s2
+    **/
+
+  const M = board.length;
+  const N = board[0].length;
+
+  const getNeighbors = (i: number, j: number): number => {
+    let ret = 0;
+    for (let ptr1 = i - 1; ptr1 <= i + 1; ptr1++) {
+      // check boundary
+      if (ptr1 < 0 || ptr1 >= M) continue;
+      for (let ptr2 = j - 1; ptr2 <= j + 1; ptr2++) {
+        // check boundary
+        if (ptr2 < 0 || ptr2 >= N) continue;
+
+        // check non-self
+        if (ptr1 === i && ptr2 === j) continue;
+
+        if (board[ptr1][ptr2] % 2 === 1) ret++; // using %2 to check the s1
+      }
+    }
+    return ret;
+  };
+
+  const transform = (prevState: number, neighbors: number): number => {
+    if (prevState === 0) {
+      if (neighbors === 3) return 2;
+      // 00->10
+      else return 0; // 00->00
+    } else {
+      if (neighbors < 2 || neighbors > 3) return 1;
+      // 01 -> 01
+      else return 3; // 01->11
+    }
+  };
+
+  // transform
+  for (let i = 0; i < M; i++) {
+    for (let j = 0; j < N; j++) {
+      board[i][j] = transform(board[i][j], getNeighbors(i, j));
+    }
+  }
+
+  // recover for next iteration
+  for (let i = 0; i < M; i++) {
+    for (let j = 0; j < N; j++) {
+      board[i][j] >>= 1;
+    }
+  }
+}

src/reshape-the-matrix.ts

@@ -0,0 +1,10 @@
+function matrixReshape(mat: number[][], r: number, c: number): number[][] {
+  const M = mat.length,
+    N = mat[0].length;
+  if (M * N !== r * c) return mat; // illegal case
+
+  const flat = mat.reduce((prev, next) => [...prev, ...next], []);
+  return Array.from({ length: r }, () =>
+    Array.from({ length: c }, () => flat.shift() as number)
+  );
+}

tsconfig.json

@@ -5,8 +5,7 @@
     "target": "es5" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */,
     "module": "commonjs" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */,
     "lib": [
-      "es2015",
-      "dom"
+      "es2015"
     ] /* Specify library files to be included in the compilation. */,
     // "allowJs": true,                       /* Allow javascript files to be compiled. */
     // "checkJs": true,                       /* Report errors in .js files. */