Merge pull request neetcode-gh#412 from loczek/main

Added 62 solutions for typescript

Author: neetcode-gh

typescript/100-Same-Tree.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 isSameTree(p: TreeNode | null, q: TreeNode | null): boolean {
+  if (p === null && q === null) return true;
+
+  if ((p === null && q !== null) || (p !== null && q === null)) return false;
+
+  let leftSame = isSameTree(p.left, q.left);
+  let rightSame = isSameTree(p.right, q.right);
+
+  if (p.val === q.val && leftSame && rightSame) {
+    return true;
+  }
+
+  return false;
+}

typescript/102-Binary-Tree-Level-Order-Traversal.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 levelOrder(root: TreeNode | null): number[][] {
+  const levels: number[][] = [];
+
+  function getHeight(node: TreeNode | null, height: number) {
+    if (!node) return 0;
+
+    if (node.left || node.right) {
+      getHeight(node.left, height + 1);
+      getHeight(node.right, height + 1);
+    }
+
+    if (levels[height]) {
+      levels[height].push(node.val);
+    } else {
+      levels[height] = [node.val];
+    }
+  }
+
+  getHeight(root, 0);
+
+  return levels;
+}

typescript/104-Maximum-Depth-of-Binary-Tree.ts

@@ -0,0 +1,19 @@
+/**
+ * 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;
+
+  return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
+}

typescript/11-Container-With-Most-Water.ts

@@ -0,0 +1,19 @@
+function maxArea(height: number[]): number {
+  let l = 0;
+  let r = height.length - 1;
+  let max = 0;
+
+  while (l < r) {
+    let area = (r - l) * Math.min(height[l], height[r]);
+
+    max = Math.max(max, area);
+
+    if (height[l] < height[r]) {
+      l += 1;
+    } else {
+      r -= 1;
+    }
+  }
+
+  return max;
+}

typescript/110-Balanced-Binary-Tree.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 isBalanced(root: TreeNode | null): boolean {
+  let array = getHeight(root);
+  return array[0];
+}
+
+function getHeight(root: TreeNode | null) {
+  if (!root) return [true, 0];
+
+  let [leftBalanced, leftHeight] = getHeight(root.left);
+  let [rightBalanced, rightHeight] = getHeight(root.right);
+
+  let balanced = leftBalanced && rightBalanced && Math.abs(rightHeight - leftHeight) <= 1;
+
+  return [balanced, 1 + Math.max(leftHeight, rightHeight)];
+}

typescript/121-Best-Time-To-Buy-and-Sell-Stock.ts

@@ -0,0 +1,19 @@
+function maxProfit(prices: number[]): number {
+  let max = 0;
+  let l = 0;
+  let r = 1;
+
+  while (r < prices.length) {
+    if (prices[l] < prices[r]) {
+      let profit = prices[r] - prices[l];
+      if (profit > max) {
+        max = profit;
+      }
+    } else {
+      l = r;
+    }
+    r++;
+  }
+
+  return max;
+}

typescript/125-Valid-Palindrome.ts

@@ -0,0 +1,13 @@
+function isPalindrome(s: string): boolean {
+  const array = s.toLowerCase().replace(/[^A-Za-z0-9]/g, "").replace(/\s/g, "").split("");
+
+  for (let i = 0; i < array.length; i++) {
+    const first = array[i];
+    const second = array[array.length - 1 - i];
+
+    if (first !== second) {
+      return false;
+    }
+  }
+  return true;
+}

typescript/128-Longest-Consecutive-Sequence.ts

@@ -0,0 +1,16 @@
+function longestConsecutive(nums: number[]): number {
+  const number = new Set(nums);
+  let longest = 0;
+
+  for (const n of nums) {
+    if (!number.has(n - 1)) {
+      let length = 0;
+      while (number.has(n + length)) {
+        length += 1;
+      }
+      longest = Math.max(length, longest);
+    }
+  }
+
+  return longest;
+}

typescript/131-Palindrome-Partitioning.ts

@@ -0,0 +1,33 @@
+function partition(s: string): string[][] {
+  let res: string[][] = [];
+  let part: string[] = [];
+
+  function dfs(i: number) {
+    if (i >= s.length) {
+      res.push(part.slice());
+      return;
+    }
+
+    for (let j = i; j < s.length; j++) {
+      if (isPali(s, i, j)) {
+        part.push(s.slice(i, j + 1));
+        dfs(j + 1);
+        part.pop();
+      }
+    }
+  }
+
+  dfs(0);
+  return res;
+
+  function isPali(s: string, l: number, r: number) {
+    while (l < r) {
+      if (s[l] != s[r]) {
+        return false;
+      }
+      l = l + 1;
+      r = r - 1;
+    }
+    return true;
+  }
+}

typescript/136-Single-Number.ts

@@ -0,0 +1,9 @@
+function singleNumber(nums: number[]): number {
+  let res = 0;
+
+  for (let i = 0; i < nums.length; i++) {
+    res = nums[i] ^ res;
+  }
+
+  return res;
+}