[j2h30728] WEEK 02 Solutions

3sum/j2h30728.ts

@@ -0,0 +1,46 @@
+/**
+ * 시간 복잡도 : O(n^2)
+ * 공간 복잡도 : O(1)
+ */
+function threeSum(nums: number[]): number[][] {
+  const result: number[][] = [];
+  nums.sort((a, b) => a - b);
+
+  for (let i = 0; i < nums.length - 2; i++) {
+    if (i > 0 && nums[i] === nums[i - 1]) {
+      continue;
+    }
+
+    if (nums[i] > 0) {
+      break;
+    }
+
+    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]]);
+
+        left++;
+        right--;
+
+        while (left < right && nums[left] === nums[left - 1]) {
+          left++;
+        }
+
+        while (left < right && nums[right] === nums[right + 1]) {
+          right--;
+        }
+      } else if (sum < 0) {
+        left++;
+      } else {
+        right--;
+      }
+    }
+  }
+
+  return result;
+}

climbing-stairs/j2h30728.ts

@@ -1,14 +1,18 @@
+/**
+ * 시간 복잡도 : O(n)
+ * 공간 복잡도 : O(1)
+ */
 function climbStairs(n: number): number {
-  if (n === 0 || n === 1) {
-    return 1;
-  }
+  if (n <= 2) return n;
 
-  const memo: number[] = [];
-  memo[0] = memo[1] = 1;
+  let prev2 = 1;
+  let prev1 = 2;
+  let current = 0;
 
-  for (let i = 2; i <= n; i++) {
-    memo[i] = memo[i - 1] + memo[i - 2];
+  for (let i = 3; i <= n; i++) {
+    current = prev2 + prev1;
+    prev2 = prev1;
+    prev1 = current;
   }
-
-  return memo[n];
+  return current;
 }

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

@@ -1,18 +1,21 @@
+/**
+ * 시간 복잡도 : O(n)
+ * 공간 복잡도 : O(1) (출력 배열 제외, left/right 변수만 사용)
+ */
 function productExceptSelf(nums: number[]): number[] {
-  const length = nums.length;
-  const result = new Array(nums.length).fill(1);
+  const arr = new Array(nums.length).fill(1);
 
-  let leftTemp = 1;
-  for (let i = 0; i < length; i++) {
-    result[i] = leftTemp;
-    leftTemp *= nums[i];
+  let left = 1;
+  for (let i = 0; i < nums.length; i++) {
+    arr[i] = left;
+    left *= nums[i];
   }
 
-  let rightTemp = 1;
-  for (let i = length - 1; i >= 0; i--) {
-    result[i] *= rightTemp;
-    rightTemp *= nums[i];
+  let right = 1;
+  for (let i = nums.length - 1; i >= 0; i--) {
+    arr[i] *= right;
+    right *= nums[i];
   }
 
-  return result;
+  return arr;
 }

valid-anagram/j2h30728.ts

@@ -1,12 +1,26 @@
+/**
+ *
+ * @param s
+ * @param t
+ * @returns
+ * 시간 복잡도 : O(n)
+ * 공간 복잡도 : O(n)
+ */
 function isAnagram(s: string, t: string): boolean {
-  const obj = {};
+  if (s.length !== t.length) return false;
+
+  const map = new Map<string, number>();
+
   for (let i = 0; i < s.length; i++) {
-    obj[s[i]] = (obj[s[i]] || 0) + 1;
+    map.set(s[i], (map.get(s[i]) ?? 0) + 1);
+    map.set(t[i], (map.get(t[i]) ?? 0) - 1);
   }
 
-  for (let i = 0; i < t.length; i++) {
-    obj[t[i]] -= 1;
+  for (let ch of map.values()) {
+    if (ch !== 0) {
+      return false;
+    }
   }
 
-  return Object.values(obj).filter((value) => value !== 0).length === 0;
+  return true;
 }

validate-binary-search-tree/j2h30728.ts

@@ -9,14 +9,19 @@ class TreeNode {
   }
 }
 
+/**
+ * 시간 복잡도 : O(n) - 모든 노드를 한 번씩 방문
+ * 공간 복잡도 : O(h) - 재귀 호출 스택 깊이 (h는 트리 높이, 최악의 경우 O(n))
+ */
 function isValidBST(root: TreeNode | null): boolean {
-  function valid(node, min, max) {
-    if (!node) return true;
+  function validate(node: TreeNode | null, min: number, max: number): boolean {
+    if (node === null) return true;
 
     if (node.val <= min || node.val >= max) return false;
 
-    return valid(node.left, min, node.val) && valid(node.right, node.val, max);
+    return (
+      validate(node.left, min, node.val) && validate(node.right, node.val, max)
+    );
   }
-
-  return valid(root, -Infinity, Infinity);
+  return validate(root, -Infinity, Infinity);
 }