initial commit

Author: realdennis

.gitignore

@@ -0,0 +1 @@
+node_modules/

LCA-binary.ts

@@ -0,0 +1,69 @@
+// class TreeNode {
+// 	val: number;
+// 	left: TreeNode | null;
+// 	right: TreeNode | null;
+// 	constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+// 		this.val = val === undefined ? 0 : val;
+// 		this.left = left === undefined ? null : left;
+// 		this.right = right === undefined ? null : right;
+// 	}
+// }
+
+/**
+    DFS approach
+    
+    1. DFS find path p & path q
+    2. The last common of the path p & path q is the LCA
+
+**/
+
+function lowestCommonAncestor(
+	root: TreeNode | null,
+	p: TreeNode | null,
+	q: TreeNode | null
+): TreeNode | null {
+	const dfsPath = (targetNode: TreeNode): number[] => {
+		const path: number[] = [];
+		let ret: number[] = [];
+		const dfs = (curr = root): void => {
+			if (curr === null) return;
+			if (curr === targetNode) {
+				ret = path;
+				return;
+			}
+			if (ret.length !== 0) return;
+			path.push(curr.val);
+			dfs(curr.left);
+			dfs(curr.right);
+			path.pop();
+		};
+		dfs();
+		return ret;
+	};
+	const pathP = dfsPath(p);
+	const pathQ = dfsPath(q);
+
+	let lastCommonVal: number = root.val;
+	while (pathP.length !== 0 && pathQ.length !== 0) {
+		const pFirst = pathP.shift();
+		const qFirst = pathQ.shift();
+		if (pFirst !== qFirst) break;
+		pFirst === qFirst && (lastCommonVal = pFirst);
+	}
+
+	// BFS find node
+	const findByVal = (val): TreeNode => {
+		const queue: TreeNode[] = [];
+		queue.push(root);
+		while (queue.length !== 0) {
+			let len = queue.length;
+			while (len-- !== 0) {
+				const curr = queue.shift();
+				if (curr.val === val) return curr;
+				curr.left && queue.push(curr.left);
+				curr.right && queue.push(curr.right);
+			}
+		}
+	};
+	return findByVal(lastCommonVal);
+}

Trapping-Rain-Water.ts

@@ -0,0 +1,48 @@
+/**
+    Using stack solve this
+    
+    1. Kepp a stack [], which keep push [value, index]
+    2. Iteration
+         check the stack end
+            1. if end.value < curr.value
+                1. pop end
+                2. diffVal = endVal - lastVal
+                3. diffIdx = curIdx - endIdx
+                3. diffVal * (diffIdx - 1)
+            2. else
+                1. diffVal = curVal - lastVal ----> now use the curVal
+                2. diffIdx = curIdx - endIdx
+                3. diffVal * (diffIdx - 1)
+                4. push curr
+    
+**/
+
+function trap(height: number[]): number {
+	let ans: number = 0;
+	let lastVal: number = 0;
+	const stack: [number, number][] = [];
+	for (let i = 0; i < height.length; i++) {
+		const curVal = height[i];
+		const curIdx = i;
+		if (stack.length === 0) stack.push([curVal, curIdx]);
+		else {
+			while (stack.length !== 0 && stack[stack.length - 1][0] <= curVal) {
+				const end = stack.pop();
+				const [endVal, endIdx] = end;
+				const diffIdx = curIdx - endIdx;
+				const diffVal = endVal - lastVal;
+				ans += diffVal * (diffIdx - 1);
+				lastVal = endVal;
+			}
+			if (stack.length !== 0) {
+				const end = stack[stack.length - 1];
+				const [endVal, endIdx] = end;
+				const diffIdx = curIdx - endIdx;
+				const diffVal = curVal - lastVal;
+				ans += diffVal * (diffIdx - 1);
+			}
+			stack.push([curVal, curIdx]);
+		}
+	}
+	return ans;
+}

add-two-numbers.ts

@@ -0,0 +1,29 @@
+function addTwoNumbers(
+	l1: ListNode | null,
+	l2: ListNode | null
+): ListNode | null {
+	let root = l1;
+	let carry = 0;
+	while (l1 !== null && l2 !== null) {
+		l1.val = carry + l1.val + l2.val;
+		carry = 0;
+
+		// handle carry
+		if (l1.val > 9) {
+			carry = Math.floor(l1.val / 10);
+			l1.val %= 10;
+		}
+
+		// extend the shortest list
+		if (l1.next === null && l2.next !== null) l1.next = new ListNode(0);
+		if (l1.next !== null && l2.next === null) l2.next = new ListNode(0);
+
+		// [corner case] handle the lastest carry case
+		if (l1.next === null && l2.next === null && carry !== 0)
+			l1.next = new ListNode(carry);
+
+		l1 = l1.next;
+		l2 = l2.next;
+	}
+	return root;
+}

count-complete-tree.ts

@@ -0,0 +1,48 @@
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+function countNodes(root: TreeNode | null): number {
+	if (root === null) return 0;
+
+	const getHeight = (node: TreeNode | null): number => {
+		let height = 0;
+		let ptr = node;
+		while (ptr !== null) {
+			height++;
+			ptr = ptr.left;
+		}
+		return height;
+	};
+	const isFullTree = (node: TreeNode | null): boolean => {
+		if (node === null) return true;
+		let left = node.left,
+			right = node.right;
+		while (left !== null && right !== null) {
+			left = left.left;
+			right = right.right;
+		}
+		return left === right; // should be null in same time
+	};
+	const traversal = (node: TreeNode | null, lo: number, hi: number): number => {
+		let mi = Math.floor((lo + hi) / 2);
+		if (isFullTree(node)) return hi;
+		if (!isFullTree(node.right)) return traversal(node.right, mi + 1, hi);
+		if (!isFullTree(node.left)) return traversal(node.left, lo, mi);
+
+		return mi;
+	};
+
+	const treeHeight = getHeight(root);
+	return traversal(root, 2 ** (treeHeight - 1), 2 ** treeHeight - 1);
+}

decode-string.ts

@@ -0,0 +1,28 @@
+function decodeString(s: string): string {
+	let res: string = "";
+	let numStr: string = "";
+	const stack: [string, string][] = [];
+
+	for (let i = 0; i < s.length; i++) {
+		const ch = s.charAt(i);
+		if (
+			ch.charCodeAt(0) - "a".charCodeAt(0) >= 0 &&
+			ch.charCodeAt(0) - "a".charCodeAt(0) < 26
+		) {
+			res += ch;
+		}
+		if (!Number.isNaN(Number(ch))) {
+			numStr += ch;
+		}
+
+		if (ch === "[") {
+			stack.push([res, numStr]);
+		}
+		if (ch === "]") {
+			const [_res, _numStr] = stack.pop();
+			res = _res + res.repeat(Number(_numStr));
+		}
+	}
+
+	return res;
+}

find-min.ts

@@ -0,0 +1,23 @@
+const findIndex = (
+	arr: number[],
+	fn: (val: number, index: number) => number
+) => {
+	let lo = 0,
+		hi = arr.length - 1;
+	while (lo <= hi) {
+		const mi = Math.floor((lo + hi) / 2);
+		if (fn(arr[mi], mi) === 0) return mi;
+		if (fn(arr[mi], mi) < 0) lo = mi + 1;
+		if (fn(arr[mi], mi) > 0) hi = mi - 1;
+	}
+	return lo - 1;
+};
+
+function findMin(nums: number[]): number {
+	const maxIdx = findIndex(nums, (val: number, index: number): number => {
+		if (val < nums[0]) return 1;
+		else return -1;
+	});
+
+	return (maxIdx + 1) % nums.length;
+}

find-positive-solution.ts

@@ -0,0 +1,20 @@
+/**
+ * // This is the CustomFunction's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class CustomFunction {
+ *      f(x: number, y: number): number {}
+ * }
+ */
+
+function findSolution(customfunction: CustomFunction, z: number): number[][] {
+	const f = customfunction.f.bind(customfunction); // somehow only typescript got the context error
+	const ret: number[][] = [];
+	for (let i = 1; i <= 1000; i++) {
+		for (let j = 1; j <= 1000; j++) {
+			if (f(i, j) > z) break;
+			if (f(i, j) === z) ret.push([i, j]);
+		}
+	}
+
+	return ret;
+}

find_island.ts

@@ -0,0 +1,61 @@
+/**
+    Let's iteration and check their adjacency node if they are both '1' 
+        1. Iteration from [0,0] to [m,n]
+        2. For [i,j], if it's '1' check the [i+1,j] [i,j+1]
+            1. if yes, then union(find(i,j), find(i+1,j))
+        3. Before access the arry, notice the corner case
+        
+    Let's define the union/find structure
+        1. mxn table
+        2. find(i,j) 
+            1. if(table[i][j] is empty then table[i][j] = [i,j];
+                1. generateId: just increase the unique key
+            2. else return find(table[i][j])
+        3. union(a,b)
+            1. find(a) = find(b);
+**/
+
+function numIslands(grid: string[][]): number {
+	const m = grid.length;
+	const n = grid[0].length;
+
+	const parent: number[][][] = Array.from({ length: m }, (val) =>
+		Array.from({ length: n }, (val) => [-1, -1])
+	);
+
+	const find = (...u: number[]): number[] => {
+		const [i, j] = u;
+		const [pI, pJ] = parent[i][j];
+		if (pI === -1 && pJ === -1) {
+			parent[i][j] = [i, j];
+			return [i, j];
+		} else {
+			return pI === i && pJ === j ? [i, j] : find(pI, pJ);
+		}
+	};
+	const union = (u1: number[], u2: number[]): void => {
+		console.log(u1, u2);
+		const p1 = find(...u1);
+		const [i, j] = find(...u2);
+		parent[i][j] = p1;
+	};
+
+	for (let i = 0; i < m; i++) {
+		for (let j = 0; j < n; j++) {
+			if (grid[i][j] === "0") continue;
+			if (i + 1 !== m && j + 1 !== n && grid[i + 1][j + 1] === "1")
+				union([i, j], [i + 1, j + 1]);
+			if (i + 1 !== m && grid[i + 1][j] === "1") union([i, j], [i + 1, j]);
+			if (j + 1 !== n && grid[i][j + 1] === "1") union([i, j], [i, j + 1]);
+		}
+	}
+	const collections: Set<string> = new Set();
+	for (let i = 0; i < m; i++) {
+		for (let j = 0; j < n; j++) {
+			const p = parent[i][j];
+			if (p[0] === -1 && p[1] === -1) continue;
+			collections.add(`${p[0]}-${p[1]}`);
+		}
+	}
+	return collections.size;
+}

first-missing-positive.ts

@@ -0,0 +1,25 @@
+function firstMissingPositive(nums: number[]): number {
+	let i = 0;
+	while (i < nums.length) {
+		const idx = nums[i];
+
+		// we don't care
+		if (idx < 1 || idx >= nums.length) {
+			i++;
+			continue;
+		}
+
+		// prevent infinite loop
+		if (nums[i] === nums[idx - 1]) {
+			i++;
+			continue;
+		}
+
+		[nums[idx - 1], nums[i]] = [nums[i], nums[idx - 1]];
+	}
+
+	for (let i = 0; i < nums.length; i++) {
+		if (nums[i] !== i + 1) return i + 1;
+	}
+	return nums.length + 1;
+}