Merge pull request #1217 from Jeehay28/main

[Jeehay28] WEEK 02 Solutions

Author: Jeehay28

3sum/Jeehay28.ts

@@ -0,0 +1,101 @@
+// Approach 3
+// 🗓️ 2025-04-12
+// ⏳ Time Complexity: O(n log n) + O(n^2) = O(n^2)
+// 💾 Space Complexity: O(1) (excluding output)
+
+function threeSum(nums: number[]): number[][] {
+
+    nums.sort((a, b) => a - b); // O(n log n)
+    let result: number[][] = [];
+
+    for (let i = 0; i < nums.length; i++) {
+
+        if (i > 0 && nums[i - 1] == nums[i]) continue; // skip duplicate i
+
+        let low = i + 1, high = nums.length - 1;
+        // two-pointer scan (low and high) -> takes up to O(n) time per iteration
+        while (low < high) {
+            const threeSum = nums[i] + nums[low] + nums[high];
+            if (threeSum < 0) {
+                low += 1;
+            } else if (threeSum > 0) {
+                high -= 1;
+            } else {
+                result.push([nums[i], nums[low], nums[high]]);
+
+                while (low < high && nums[low] === nums[low + 1]) low += 1 // skip duplicate low
+                while (low < high && nums[high] === nums[high - 1]) high -= 1 // skip duplicate high
+
+                low += 1;
+                high -= 1;
+
+            }
+        }
+    }
+    return result
+}
+
+
+// Approach 2
+// 🗓️ 2025-04-11
+// ❌ Time Limit Exceeded 313 / 314 testcases passed
+// ⏳ Time Complexity: O(n^2)
+// 💾 Space Complexity: O(n^2)
+
+// function threeSum(nums: number[]): number[][] {
+//   const result: number[][] = [];
+//   const triplets = new Set<string>();
+
+//   for (let i = 0; i < nums.length - 2; i++) {
+//     const seen = new Set<number>();
+//     for (let j = i + 1; j < nums.length; j++) {
+//       const twoSum = nums[i] + nums[j];
+//       if (seen.has(-twoSum)) {
+//         const triplet = [nums[i], nums[j], -twoSum].sort((a, b) => a - b); // O(log 3) = O(1)
+//         const key = triplet.join(",");
+//         if (!triplets.has(key)) {
+//           triplets.add(key);
+//           result.push(triplet);
+//         }
+//       }
+//       seen.add(nums[j]);
+//     }
+//   }
+//   return result;
+// }
+
+
+// Approach 1
+// 🗓️ 2025-04-11
+// ❌ Time Limit Exceeded!
+// ⏳ Time Complexity: O(n^3)
+// 💾 Space Complexity: O(n^2)
+
+// function threeSum(nums: number[]): number[][] {
+
+//     let triplets = new Set<string>();
+//     let result: number[][] = [];
+
+//     // const set = new Set();
+//     // set.add([1, 2, 3]);
+//     // set.add([1, 2, 3]);
+//     // console.log(set); // contains BOTH arrays
+//     // Set(2) { [ 1, 2, 3 ], [ 1, 2, 3 ] }
+
+//     for (let i = 0; i < nums.length - 2; i++) {
+//         for (let j = i + 1; j < nums.length - 1; j++) {
+//             for (let k = j + 1; k < nums.length; k++) {
+//                 if (nums[i] + nums[j] + nums[k] === 0) {
+//                     const triplet = [nums[i], nums[j], nums[k]].sort((a, b) => a - b);
+//                     const key = triplet.join(",");
+//                     if (!triplets.has(key)) {
+//                         triplets.add(key);
+//                         result.push(triplet)
+//                     }
+//                 }
+//             }
+//         }
+//     }
+
+//     return result;
+// };

climbing-stairs/Jeehay28.ts

@@ -0,0 +1,43 @@
+// Approach 2: DFS with Memoization
+// 🗓️ 2025-04-06
+// ⏳ Time Complexity: O(n)
+// 💾 Space Complexity: O(n)
+
+function climbStairs(n: number): number {
+  const memo = new Map<number, number>();
+
+  const dfs = (step: number) => {
+    if (step > n) return 0;
+    if (step === n) return 1;
+    if (memo.has(step)) return memo.get(step);
+
+    const result = dfs(step + 1) + dfs(step + 2);
+    memo.set(step, result);
+    return result;
+  };
+
+  return dfs(0);
+}
+
+
+// Approach 1: DFS (depth-first search)
+// ❌ Time Limit Exceeded (TLE) error!
+// ⏳ Time Complexity: O(2^n)
+// 💾 Space Complexity: O(n)
+// The maximum depth of the recursive call stack is n, because we go from step = 0 to step = n.
+
+// function climbStairs(n: number): number {
+//   // 1 -> 1 -> 1
+//   // 1 -> 2
+//   // 2 -> 1
+
+//   const dfs = (step: number) => {
+//     // reach the top
+//     if (step > n) return 0;
+//     if (step === n) return 1;
+
+//     return dfs(step + 1) + dfs(step + 2);
+//   };
+
+//   return dfs(0);
+// }

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

@@ -0,0 +1,65 @@
+// Approach 2
+// 🗓️ 2025-04-08
+// ⏳ Time Complexity: O(n + n) = O(n)
+// 💾 Space Complexity: O(1)
+// result: required output → not counted
+// before, after: two scalar variables → O(1)
+// So, the total extra space is O(1)
+
+function productExceptSelf(nums: number[]): number[] {
+  const result: number[] = new Array(nums.length).fill(1);
+  let before = 1;
+  let after = 1;
+
+  for (let i = 0; i < nums.length - 1; i++) {
+    before *= nums[i];
+    result[i + 1] *= before;
+  }
+
+  for (let i = nums.length - 1; i > 0; i--) {
+    after *= nums[i];
+    result[i - 1] *= after;
+  }
+  return result;
+}
+
+
+// Approach 1
+// 🗓️ 2025-04-08
+// ⏳ Time Complexity: O(n + n + n) = O(n)
+// 💾 Space Complexity: O(n + n) = O(n)
+
+// When we analyze space complexity,
+// we only count extra space used in addition to the input and required output.
+// ✅ before → O(n) extra
+// ✅ after → O(n) extra
+// 🚫 result is the output, so it’s not counted toward space complexity
+
+// function productExceptSelf(nums: number[]): number[] {
+//   // nums: an array of size n
+//   // before: nums[0], nums[1].., nums[i-2], nums[i-1]
+//   // after: nums[i+1], nums[i+2],..., nums[n-1]
+
+//   // input: [1, 2, 3, 4]
+//   // before: [1, 1, 2, 6]
+//   // after: [24, 12, 4, 1]
+//   // product: [24, 12, 8, 6]
+
+//   const before = new Array(nums.length).fill(1);
+//   const after = new Array(nums.length).fill(1);
+//   const result: number[] = [];
+
+//   for (let i = 0; i < nums.length - 1; i++) {
+//     before[i + 1] = before[i] * nums[i];
+//   }
+
+//   for (let i = nums.length - 1; i > 0; i--) {
+//     after[i - 1] = after[i] * nums[i];
+//   }
+
+//   for (let i = 0; i < nums.length; i++) {
+//     result[i] = before[i] * after[i];
+//   }
+
+//   return result;
+// }

valid-anagram/Jeehay28.ts

@@ -0,0 +1,55 @@
+// Approach 2
+// 🗓️ 2025-04-06
+// ⏳ Time Complexity: O(n)
+// 💾 Space Complexity: O(n)
+
+function isAnagram(s: string, t: string): boolean {
+  const map = new Map<string, number>();
+
+  for (const char of s) {
+    map.set(char, (map.get(char) || 0) + 1);
+  }
+
+  for (const char of t) {
+    if (!map.has(char)) return false;
+    map.set(char, map.get(char)! - 1);
+    if (map.get(char) === 0) {
+      map.delete(char);
+    }
+  }
+
+  return map.size === 0;
+}
+
+
+// Approach 1
+// ⏳ Time Complexity: O(n)
+// 💾 Space Complexity: O(n)
+
+// function isAnagram(s: string, t: string): boolean {
+//   const s_map = new Map<string, number>();
+//   const t_map = new Map<string, number>();
+
+//   for (const char of s) {
+//     s_map.set(char, (s_map.get(char) || 0) + 1);
+//   }
+
+//   for (const char of t) {
+//     t_map.set(char, (t_map.get(char) || 0) + 1);
+//   }
+
+//   // Compare the keys and values of both maps
+//   if ([...s_map.keys()].length !== [...t_map.keys()].length) {
+//     return false;
+//   } else {
+//     for (const char of [...s_map.keys()]) {
+//       if (s_map.get(char) !== t_map.get(char)) {
+//         // Lookup operations in Map are O(1)
+//         return false;
+//       }
+//     }
+//   }
+
+//   return true;
+// }
+

validate-binary-search-tree/Jeehay28.ts

@@ -0,0 +1,65 @@
+// Approach 2
+// 🗓️ 2025-04-11
+// ⏳ Time Complexity: O(n)
+// 💾 Space Complexity: O(h) → O(log n) for balanced, O(n) for skewed trees
+
+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 {
+  // 🟡 중위 순회 (Inorder Traversal)
+  // 방문 순서: 왼쪽 자식 → 현재 노드 → 오른쪽 자식
+
+  let maxVal = -Infinity;
+
+  const dfs = (node: TreeNode | null) => {
+    if (!node) return true;
+
+    if (!dfs(node.left)) return false;
+
+    if (node.val <= maxVal) return false;
+
+    maxVal = node.val;
+
+    if (!dfs(node.right)) return false;
+
+    return true;
+  };
+
+  return dfs(root);
+}
+
+// Approach 1
+// 🗓️ 2025-04-11
+// ⏳ Time Complexity: O(n)
+// 💾 Space Complexity: O(h) → O(log n) for balanced, O(n) for skewed trees
+
+// function isValidBST(root: TreeNode | null): boolean {
+//   // 좌측 서브 트리로 내려갈 때:
+//   // 하한값: 부모 노드 하한값
+//   // 상한값: 부모 노드 값
+//   // 우측 서브 트리로 내려갈 때:
+//   // 우측 하한값: 부모 노드 값
+//   // 우측 상한값: 부모 노드의 상한 값
+//   // 🟢 전위 순회 (Preorder Traversal)
+//   // 방문 순서: 현재 노드 → 왼쪽 자식 → 오른쪽 자식
+
+//   const dfs = (node: TreeNode | null, low: number, high: number) => {
+//     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);
+// }