Added 62 solutions for typescript

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;
+}

typescript/139-Word-Break.ts

@@ -0,0 +1,18 @@
+function wordBreak(s: string, wordDict: string[]): boolean {
+  const dp = Array(s.length + 1).fill(false);
+
+  dp[s.length] = true;
+
+  for (let i = s.length - 1; i > -1; i--) {
+    for (const w of wordDict) {
+      if (i + w.length <= s.length && s.slice(i, i + w.length) == w) {
+        dp[i] = dp[i + w.length];
+      }
+      if (dp[i]) {
+        break;
+      }
+    }
+  }
+
+  return dp[0];
+}

typescript/141-Linked-List-Cycle.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 {
+  let slow = head;
+  let fast = head;
+
+  while (fast && fast.next) {
+    if (slow) {
+      slow = slow.next;
+    }
+    fast = fast.next.next;
+    if (slow == fast) {
+      return true;
+    }
+  }
+
+  return false;
+}

typescript/143-Reorder-List.ts

@@ -0,0 +1,48 @@
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+/**
+ Do not return anything, modify head in-place instead.
+ */
+function reorderList(head: ListNode | null): void {
+  let slow: ListNode | null | undefined = head;
+  let fast: ListNode | null | undefined = head?.next;
+
+  while (fast && fast.next) {
+    slow = slow?.next;
+    fast = fast?.next?.next;
+  }
+
+  // reverse second half
+  if (!(slow && slow.next)) return;
+  let second: ListNode | null = slow.next;
+  slow.next = null;
+  let prev: ListNode | null = null;
+  while (second) {
+    let temp = second.next;
+    second.next = prev;
+    prev = second;
+    second = temp;
+  }
+
+  // merge two halfs
+  let first: any = head;
+  second = prev;
+  while (second) {
+    let temp1 = first.next;
+    let temp2 = second.next;
+    first.next = second;
+    second.next = temp1;
+    first = temp1;
+    second = temp2;
+  }
+}

typescript/15-3Sum.ts

@@ -0,0 +1,29 @@
+function threeSum(nums: number[]): number[][] {
+  const res: number[][] = [];
+  nums = nums.sort((a, b) => a - b);
+
+  for (let i = 0; i < nums.length; i++) {
+    if (i > 0 && nums[i] == nums[i - 1]) {
+      continue;
+    }
+
+    let l = i + 1;
+    let r = nums.length - 1;
+    while (l < r) {
+      let sum = nums[i] + nums[l] + nums[r];
+
+      if (sum > 0) {
+        r -= 1;
+      } else if (sum < 0) {
+        l += 1;
+      } else {
+        res.push([nums[i], nums[l], nums[r]]);
+        l += 1;
+        while (nums[l] == nums[l - 1] && l < r) {
+          l += 1;
+        }
+      }
+    }
+  }
+  return res;
+}

typescript/150-Evaluate-Reverse-Polish-Notation.ts

@@ -0,0 +1,23 @@
+function evalRPN(tokens: string[]): number {
+  const stack: number[] = [];
+
+  tokens.forEach((token) => {
+    if (token === "+") {
+      stack.push(Number(stack.pop()) + Number(stack.pop()));
+    } else if (token === "-") {
+      const a = Number(stack.pop());
+      const b = Number(stack.pop());
+      stack.push(b - a);
+    } else if (token === "/") {
+      const a = Number(stack.pop());
+      const b = Number(stack.pop());
+      stack.push(Math.trunc(b / a));
+    } else if (token === "*") {
+      stack.push(Number(stack.pop()) * Number(stack.pop()));
+    } else {
+      stack.push(Number(token));
+    }
+  });
+
+  return stack[0];
+}