[soobing] Week 2 solutions

3sum/soobing3.ts

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

climbing-stairs/soobing3.ts

@@ -0,0 +1,14 @@
+function climbStairs(n: number): number {
+  const memo = new Map<number, number>();
+
+  function dp (n: number): number {
+      if(n <= 1) return 1;
+      if(memo.has(n)) return memo.get(n)!;
+
+      const result = dp(n-1) + dp(n-2);
+      memo.set(n, result);
+      return result;
+  }
+
+  return dp(n);
+};

product-of-array-except-self/soobing3.ts

@@ -0,0 +1,20 @@
+function productExceptSelf(nums: number[]): number[] {
+  const n = nums.length;
+  const left = new Array(n).fill(1);
+  const right = new Array(n).fill(1);
+  const result = new Array(n).fill(1);
+
+  for (let i = 1; i < n; i++) {
+      left[i] = nums[i-1] * left[i - 1];
+  }
+
+  for (let i = n - 2; i >= 0; i--) {
+      right[i] = nums[i+1] * right[i + 1];
+  }
+
+  for (let i = 0; i < n; i++) {
+      result[i] = left[i] * right[i];
+  }
+
+  return result;
+};

valid-anagram/soobing3.ts

@@ -0,0 +1,20 @@
+function isAnagram(s: string, t: string): boolean {
+  if(s.length !== t.length) return false;
+
+  const sMap = new Map<string, number>();
+  const tMap = new Map<string, number>();
+
+  for(const s_char of s) {
+      sMap.set(s_char, (sMap.get(s_char) ?? 0) + 1);
+  }
+
+  for(const t_char of t) {
+      tMap.set(t_char, (tMap.get(t_char) ?? 0) + 1);
+  }
+
+  if(sMap.size !== tMap.size) return false;
+  for(const [sKey, sValue] of sMap) {
+      if(sValue !== tMap.get(sKey)) return false;
+  }
+  return true
+};

validate-binary-search-tree/soobing3.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 isValidBST(root: TreeNode | null): boolean {
+  function validate(node: TreeNode | null, min: number, max: number){
+      if(node === null) return true;
+
+      if(node.val <= min || node.val >= max) return false;
+
+      return validate(node.left, min, node.val) && validate(node.right, node.val, max)
+  }
+  return validate(root, -Infinity, Infinity);
+};