[junzero741] WEEK 02 solutions

3sum/junzero741.ts

@@ -0,0 +1,45 @@
+// TC: O(n^2)
+// SC: O(logn)
+function threeSum(nums: number[]): number[][] {
+
+    nums.sort((a,b) => a-b);
+    const result: number[][] = []
+
+    for(let i = 0 ; i < nums.length; i++) {
+        let left = i+1;
+        let right = nums.length-1;
+
+        while(left < right) {
+           if(i > 0 && nums[i] === nums[i-1]) {
+                break;
+           }
+
+           const sum = nums[i] + nums[left] + nums[right];
+           if(sum > 0) {
+                right--;
+                continue;
+           }
+           if(sum < 0) {
+                left++;
+                continue;
+           }
+           if(sum === 0) {
+                const triplet: number[] = [nums[i], nums[left], nums[right]];
+                result.push(triplet);
+
+                while(left < right && nums[left] === nums[left+1]) {
+                    left++;
+                }
+                while(left < right && nums[right] === nums[right-1]) {
+                    right--;
+                }
+
+                left++;
+                right--;
+           }
+        }
+
+    }
+
+    return result;
+};

climbing-stairs/junzero741.ts

@@ -0,0 +1,17 @@
+// TC: O(n)
+// SC: O(n)
+function climbStairs(n: number): number {
+    if(n <= 3) {
+        return n;
+    }
+    const memo = new Array(n+1);
+    memo[1] = 1
+    memo[2] = 2
+    memo[3] = 3
+
+    for(let i = 4; i <= n; i++) {
+        memo[i] = memo[i-1] + memo[i-2];
+    }
+
+    return memo[n];
+};

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

@@ -0,0 +1,19 @@
+// TC: O(n)
+// SC: O(1) 
+function productExceptSelf(nums: number[]): number[] {
+    const answer = new Array(nums.length).fill(1);
+
+    let before = 1;
+    for(let i = 0; i < nums.length-1; i++) {
+        before *= nums[i];
+        answer[i+1] *= before;
+    }   
+
+    before = 1;
+    for(let i = nums.length-1; i > 0; i--) {
+        before *= nums[i];
+        answer[i-1] *= before;
+    }
+
+    return answer;  
+};

valid-anagram/junzero741.ts

@@ -0,0 +1,30 @@
+// TC: O(n)
+// SC: O(n)
+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(let i = 0; i < s.length; i++) { // TC: O(N), SC: O(N)
+        const sChar = s[i];
+        const tChar = t[i];
+        const sCharCount = sMap.get(sChar) || 0;
+        const tCharCount = tMap.get(tChar) || 0;
+
+        sMap.set(sChar, sCharCount + 1);
+        tMap.set(tChar, tCharCount + 1);
+     }
+
+     for(let i = 0; i < s.length; i++) { // TC: O(N), SC: O(1)
+        const char = s[i];
+
+        if(sMap.get(char) !== tMap.get(char)) {
+            return false;
+        }
+     }
+
+     return true;
+};

validate-binary-search-tree/junzero741.ts

@@ -0,0 +1,23 @@
+// TC: O(n)
+// SC: O(n)
+type TreeNode = {
+    val: number
+    left: TreeNode | null
+    right: TreeNode | null
+}
+function isValidBST(root: TreeNode | null): boolean {
+
+    function dfs(node: TreeNode | null, low: number, high: number): boolean {
+        if(!node) {
+            return true;
+        }
+
+        if(node.val <= low || node.val >= high) {
+            return false;
+        }
+
+        return dfs(node.left, low, node.val) && dfs(node.right, node.val, high)
+    }
+
+    return dfs(root, -Infinity, Infinity);
+};