update some types error

Author: realdennis

src/ListNode.ts

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

src/arithmetic-slices.ts

@@ -0,0 +1,30 @@
+function numberOfArithmeticSlices(nums: number[]): number {
+  const N = nums.length;
+  const dp = Array.from({ length: N }, () => 0);
+  for (let i = 1; i < N - 1; i++) {
+    if (nums[i] - nums[i - 1] === nums[i + 1] - nums[i]) {
+      dp[i] = dp[i - 1] + 1;
+    }
+  }
+  return dp.reduce((prev, next) => prev + next, 0);
+}
+
+/**
+// space optimize
+function numberOfArithmeticSlices(nums: number[]): number {
+  const N = nums.length;
+
+  let acc = 0;
+  let ret = 0;
+  for (let i = 1; i < N - 1; i++) {
+    let current = 0;
+    if (nums[i] - nums[i - 1] === nums[i + 1] - nums[i]) {
+      acc++;
+    } else {
+      acc = 0;
+    }
+    ret += acc;
+  }
+  return ret;
+}
+*/

src/middle-of-the-linked-list.ts

@@ -0,0 +1,12 @@
+function middleNode(head: ListNode | null): ListNode | null {
+  if (head === null) return null;
+
+  let slow = head,
+    fast: ListNode | null = head;
+
+  while (fast !== null && fast.next !== null) {
+    slow = slow.next!;
+    fast = fast.next.next;
+  }
+  return slow;
+}

src/remove-nth-node-from-end-of-list.ts

@@ -0,0 +1,20 @@
+function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
+  const dummy = new ListNode();
+  dummy.next = head;
+
+  let slow: ListNode | null = dummy,
+    fast: ListNode | null = dummy;
+
+  while (n-- !== 0 && fast != null) fast = fast.next; // revisit later
+  if (fast === null) return head; // means n > list node counts
+
+  while (fast.next !== null) {
+    fast = fast.next;
+    slow = slow!.next;
+  }
+
+  // remove slow.next
+  slow!.next = slow!.next!.next;
+
+  return dummy.next;
+}

src/reverse-node-kth-group.ts

@@ -1,30 +1,21 @@
-/**
- * Definition for singly-linked list.
- * class ListNode {
- *     val: number
- *     next: ListNode | null
- *     constructor(val?: number, next?: ListNode | null) {
- *         this.val = (val===undefined ? 0 : val)
- *         this.next = (next===undefined ? null : next)
- *     }
- * }
- */
-
-const reverse = (head: ListNode, tail: ListNode): void => {
-	const tailNext = tail.next;
-	let prev = tailNext;
-	while (head !== tailNext) {
-		const next = head.next;
-		head.next = prev;
-		prev = head;
-		head = next;
-	}
-};
 function reverseKGroup(head: ListNode | null, k: number): ListNode | null {
-	let f = head;
-	for (let i = 1; i < k && f !== null; i++) f = f.next;
-	if (f === null) return head;
-	f.next = reverseKGroup(f.next, k);
-	reverse(head, f);
-	return f;
+  if (head === null) return null;
+
+  const reverse = (head: ListNode, tail: ListNode): void => {
+    const tailNext = tail.next;
+    let prev = tailNext;
+    while (head !== tailNext) {
+      const next = head.next;
+      head.next = prev;
+      prev = head;
+      head = next!;
+    }
+  };
+
+  let f: ListNode | null = head;
+  for (let i = 1; i < k && f !== null; i++) f = f.next;
+  if (f === null) return head;
+  f.next = reverseKGroup(f.next, k);
+  reverse(head, f);
+  return f;
 }

src/reverse-nodes-in-k-group.ts

@@ -0,0 +1,39 @@
+export {};
+
+const findIndex = (
+  arr: number[],
+  compareFn: (val: number) => number
+): number => {
+  // binary search with compareFn
+  // O(log n)
+
+  const N = arr.length;
+  let lo = 0,
+    hi = N - 1;
+
+  while (lo <= hi) {
+    const mid = Math.floor((lo + hi) / 2);
+    const val = arr[mid];
+
+    if (compareFn(val) === 0) return mid;
+
+    if (compareFn(val) > 0) hi = mid - 1;
+    else lo = mid + 1;
+  }
+
+  return lo - 1;
+};
+function searchMatrix(matrix: number[][], target: number): boolean {
+  // search the row start to find the close small or equal value's index check which row
+
+  const rowIdx = findIndex(
+    matrix.map((row) => row[0]),
+    (val) => (val > target ? 1 : -1)
+  );
+  if (rowIdx === -1) return false;
+
+  const colIdx = findIndex(matrix[rowIdx], (val) => val - target);
+
+  return matrix[rowIdx][colIdx] === target;
+  // search the specific row
+}

src/search-2d-matrix-ii.ts src/search-a-2d-matrix-ii.tssrc/search-2d-matrix-ii.ts renamed to src/search-a-2d-matrix-ii.ts

@@ -0,0 +1,43 @@
+function isValidSudoku(board: string[][]): boolean {
+  const N = board.length;
+
+  const valid = (i: number, j: number): boolean => {
+    const rowSet: Set<string> = new Set();
+    // row validate
+    for (let k = 0; k < N; k++) {
+      if (board[i][k] === ".") continue;
+      if (rowSet.has(board[i][k])) return false;
+      rowSet.add(board[i][k]);
+    }
+
+    const colSet: Set<string> = new Set();
+    // col validate
+    for (let k = 0; k < N; k++) {
+      if (board[k][j] === ".") continue;
+      if (colSet.has(board[k][j])) return false;
+      colSet.add(board[k][j]);
+    }
+
+    const boxSet: Set<string> = new Set();
+    // box validate
+    const istart = Math.floor(i / 3) * 3;
+    const jstart = Math.floor(j / 3) * 3;
+    for (let ii = istart; ii < istart + 3; ii++) {
+      for (let jj = jstart; jj < jstart + 3; jj++) {
+        if (board[ii][jj] === ".") continue;
+        if (boxSet.has(board[ii][jj])) return false;
+        boxSet.add(board[ii][jj]);
+      }
+    }
+    return true;
+  };
+
+  for (let i = 0; i < N; i++) {
+    for (let j = 0; j < N; j++) {
+      if (board[i][j] === ".") {
+        if (valid(i, j) === false) return false;
+      }
+    }
+  }
+  return true;
+}