feat: initial commit

Author: lachlan-bennetts

src/questions/Pre-Questions/100.SameTree.ts

@@ -0,0 +1,63 @@
+// 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 isSameTree(p: TreeNode | null, q: TreeNode | null): boolean {
+  let pCurr = p;
+  let qCurr = q;
+  const pStack: TreeNode[] = [];
+  const qStack: TreeNode[] = [];
+
+  if (q && p) {
+    qStack.push(q);
+    pStack.push(p);
+  }
+
+  while (
+    (pCurr !== null || pStack.length > 0) &&
+    (qCurr !== null || qStack.length > 0)
+  ) {
+    // 1. Reach the leftmost node of the pCurr node
+    while (pCurr !== null && qCurr !== null) {
+      pStack.push(pCurr);
+      qStack.push(qCurr);
+      pCurr = pCurr.left;
+      qCurr = qCurr.left;
+    }
+
+    if (
+      (pCurr && qCurr && pCurr.val !== qCurr.val) ||
+      (pCurr && !qCurr) ||
+      (!pCurr && qCurr)
+    )
+      return false;
+
+    // 2. Current must be null at this point
+    pCurr = pStack.pop()!;
+    qCurr = qStack.pop()!;
+
+    if (
+      (pCurr && qCurr && pCurr.val !== qCurr.val) ||
+      (pCurr && !qCurr) ||
+      (!pCurr && qCurr)
+    )
+      return false;
+
+    // 3. Visit the right subtree
+    pCurr = pCurr.right;
+    qCurr = qCurr.right;
+  }
+  return (
+    pCurr === null &&
+    qCurr === null &&
+    pStack.length === 0 &&
+    qStack.length === 0
+  );
+}

src/questions/Pre-Questions/101.SymmetricTree.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 isSymmetric(root: TreeNode | null): boolean {
+  if (!root) {
+    return false;
+  }
+  const lhs = root.left;
+  const rhs = root.right;
+  let matched = true;
+
+  const dfs = (lhs: TreeNode | null, rhs: TreeNode | null) => {
+    if (!matched) {
+      return;
+    }
+    if ((lhs && !rhs) || (!lhs && rhs)) {
+      matched = false;
+      return;
+    }
+    if (!lhs || !rhs) {
+      return;
+    }
+    if (lhs.val !== rhs.val) {
+      matched = false;
+      return;
+    }
+
+    dfs(lhs.left, rhs.right);
+    dfs(lhs.right, rhs.left);
+  };
+
+  dfs(lhs, rhs);
+  return matched;
+}

src/questions/Pre-Questions/108.MaxDepthOfBinaryTree.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 {
+  if (!root) return 0;
+
+  const dfs = (node, depth) => {
+    if (!node) return 0;
+
+    const lhsDepth = dfs(node.left, depth + 1);
+    const rhsDepth = dfs(node.right, depth + 1);
+
+    const currentDepth =
+      lhsDepth > rhsDepth ? lhsDepth : rhsDepth > depth ? rhsDepth : depth;
+    return currentDepth;
+  };
+
+  return dfs(root, 0);
+}

src/questions/Pre-Questions/118.Pascals-Triangle.ts

@@ -0,0 +1,21 @@
+function generate(numRows: number): number[][] {
+  if (numRows === 0) return [];
+  if (numRows === 1) return [[1]];
+
+  let result: number[][] = [[1]];
+
+  for (let i: number = 1; i < numRows; i++) {
+    let prevRow: number[] = result[i - 1];
+    let newRow: number[] = [];
+
+    newRow.push(1);
+
+    for (let j: number = 1; j < prevRow.length; j++) {
+      newRow.push(prevRow[j - 1] + prevRow[j]);
+    }
+
+    newRow.push(1);
+    result.push(newRow);
+  }
+  return result;
+}

src/questions/Pre-Questions/121.Buy-Sell-Stock.ts

@@ -0,0 +1,50 @@
+/* 
+You are given an array prices where prices[i] is the price of a given stock on the ith day.
+
+You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock.
+
+Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, return 0.
+
+ 
+
+Example 1:
+
+Input: prices = [7,1,5,3,6,4]
+Output: 5
+Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
+Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.
+Example 2:
+
+Input: prices = [7,6,4,3,1]
+Output: 0
+Explanation: In this case, no transactions are done and the max profit = 0.
+ 
+
+Constraints:
+
+1 <= prices.length <= 105
+0 <= prices[i] <= 104
+*/
+
+function maxProfit(prices: number[]): number {
+  if (prices.length === 0) return 0;
+
+  let minPrice = prices[0];
+  let maxProfit = 0;
+
+  for (let i = 1; i < prices.length; i++) {
+    const currentPrice = prices[i];
+    if (currentPrice < minPrice) {
+      minPrice = currentPrice;
+    } else {
+      const profit = currentPrice - minPrice;
+      if (profit > maxProfit) {
+        maxProfit = profit;
+      }
+    }
+  }
+
+  return maxProfit;
+}
+
+maxProfit([7, 5, 4, 3, 2, 8]);

src/questions/Pre-Questions/122.Buy-Sell-Stock-II.ts

@@ -0,0 +1,14 @@
+function singleNumber(nums: number[]): number {
+  const numSet = new Set<number>();
+
+  for (let i = 0; i < nums.length; i++) {
+    const num = nums[i];
+    if (numSet.has(num)) {
+      numSet.delete(num);
+    } else {
+      numSet.add(num);
+    }
+  }
+
+  return numSet.values().next().value;
+}

src/questions/Pre-Questions/123.SingleNumber.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 hasCycle(head: ListNode | null): boolean {
+  const nodeSet = new Set();
+  nodeSet.add(head?.val);
+  let current = new ListNode(0, head);
+  let bool = false;
+
+  while (bool) {
+    if (current.next === null) break;
+    if (nodeSet.has(current.next.val)) {
+      bool = true;
+    } else {
+      nodeSet.add(current.next.val);
+      current = current.next;
+    }
+  }
+  return bool;
+}

src/questions/Pre-Questions/141.LinkedListCycle.ts

@@ -0,0 +1,30 @@
+function addTwoNumbers(
+  l1: ListNode | null,
+  l2: ListNode | null,
+): ListNode | null {
+  let dummy = new ListNode(0);
+  let current = dummy;
+  let carry = 0;
+
+  while (l1 !== null || l2 !== null) {
+    let sum = carry;
+    if (l1 !== null) {
+      sum += l1.val;
+      l1 = l1.next;
+    }
+    if (l2 !== null) {
+      sum += l2.val;
+      l2 = l2.next;
+    }
+
+    carry = Math.floor(sum / 10);
+    current.next = new ListNode(sum % 10);
+    current = current.next;
+  }
+
+  if (carry > 0) {
+    current.next = new ListNode(carry);
+  }
+
+  return dummy.next;
+}

src/questions/Pre-Questions/2.AddTwoNumbers.ts

@@ -0,0 +1,23 @@
+function lengthOfLongestSubstring(s: string): number {
+  let count = 0;
+  let finalCount = 0;
+  let obj = {};
+  let j = 1;
+
+  for (let i = 0; i <= s.length - 1; i++) {
+    if (!obj[s[i]]) {
+      obj[s[i]] = s[i];
+      count += 1;
+      finalCount = Math.max(count, finalCount);
+    } else {
+      count = 1;
+      i = j;
+      obj = {
+        [s[i]]: s[i],
+      };
+      j++;
+    }
+  }
+
+  return finalCount;
+}