[casentino] WEEK 04 Solutions

coin-change/casentino.ts

@@ -0,0 +1,12 @@
+function coinChange(coins: number[], amount: number): number {
+  const dp = new Array(amount + 1).fill(amount);
+  dp[0] = 0;
+  for (let i = 1; i <= amount; i++) {
+    for (let j = 0; j < coins.length; j++) {
+      if (i - coins[j] >= 0) {
+        dp[i] = Math.min(dp[i - coins[j]] + 1, dp[i]);
+      }
+    }
+  }
+  return dp[amount] === Number.POSITIVE_INFINITY ? -1 : dp[amount];
+}

find-minimum-in-rotated-sorted-array/casentino.ts

@@ -0,0 +1,15 @@
+function findMin(nums: number[]): number {
+  let left = 0;
+  let right = nums.length - 1;
+
+  while (left < right) {
+    const middle = Math.floor((left + right) / 2);
+
+    if (nums[middle] < nums[right]) {
+      right = middle;
+    } else {
+      left = middle + 1;
+    }
+  }
+  return nums[left];
+}

maximum-depth-of-binary-tree/casentino.ts

@@ -0,0 +1,36 @@
+/**
+ * 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 maxDepth(root: TreeNode | null): number {
+  function recursive(node: TreeNode | null, count: number) {
+    if (!node) {
+      return count;
+    }
+    const left = recursive(node.left, count + 1);
+    const right = recursive(node.right, count + 1);
+    return left > right ? left : right;
+  }
+  return recursive(root, 0);
+}
+
+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;
+  }
+}

merge-two-sorted-lists/casentino.ts

@@ -0,0 +1,40 @@
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+function mergeTwoLists(list1: ListNode | null, list2: ListNode | null): ListNode | null {
+  if (!list1 || !list2) {
+    return list1 ?? list2;
+  }
+  function merge(node1: ListNode | null, node2: ListNode | null) {
+    if (!node1 || !node2) {
+      return node1 ?? node2;
+    }
+    if (node1.val < node2.val) {
+      node1.next = merge(node1.next, node2);
+    }
+    if (node1.val >= node2.val) {
+      node2.next = merge(node1, node2.next);
+    }
+
+    return node1.val < node2.val ? node1 : node2;
+  }
+  return merge(list1, list2);
+}
+
+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;
+  }
+}

word-search/casentino.ts

@@ -0,0 +1,44 @@
+function exist(board: string[][], word: string): boolean {
+  const m = board.length;
+  const n = board[0].length;
+
+  const visited = Array.from({ length: m }, () => new Array(n).fill(0));
+  function findDirection(currentI: number, currentJ: number, findNextIdx: number) {
+    if (findNextIdx === word.length) {
+      return true;
+    }
+    if (
+      currentI < 0 ||
+      currentJ < 0 ||
+      currentI >= m ||
+      currentJ >= n ||
+      board[currentI][currentJ] !== word[findNextIdx]
+    ) {
+      return false;
+    }
+    if (visited[currentI][currentJ] === 1) {
+      return false;
+    }
+    visited[currentI][currentJ] = 1;
+
+    const isApproachLastWord =
+      findDirection(currentI + 1, currentJ, findNextIdx + 1) ||
+      findDirection(currentI - 1, currentJ, findNextIdx + 1) ||
+      findDirection(currentI, currentJ - 1, findNextIdx + 1) ||
+      findDirection(currentI, currentJ + 1, findNextIdx + 1);
+
+    if (!isApproachLastWord) {
+      visited[currentI][currentJ] = 0;
+    }
+    return isApproachLastWord;
+  }
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      const result = findDirection(i, j, 0);
+      if (result) {
+        return true;
+      }
+    }
+  }
+  return false;
+}