[byol-han] WEEK 02 solutions

3sum/byol-han.js

@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function (nums) {
+  // 오름차순 정렬
+  nums.sort((a, b) => a - b);
+  const result = [];
+
+  for (let i = 0; i < nums.length - 2; 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) {
+        left++;
+      } else if (sum > 0) {
+        right--;
+      } else {
+        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--;
+
+        left++;
+        right--;
+      }
+    }
+  }
+  return result;
+};

climbing-stairs/byol-han.js

@@ -0,0 +1,17 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function (n) {
+  if (n <= 2) return n;
+
+  let first = 1;
+  let second = 2;
+
+  for (let i = 3; i <= n; i++) {
+    let count = first + second;
+    first = second;
+    second = count;
+  }
+  return second;
+};

product-of-array-except-self/byol-han.js

@@ -0,0 +1,41 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var productExceptSelf = function (nums) {
+  // 1.
+  // 각 인덱스에서 자기 자신 제외한 배열 만든 뒤 곱셈 수행 → 시간복잡도 O(n²)
+  // (중첩 루프로 인해 시간복잡도 O(n²), 큰 입력에서는 시간 초과 발생)
+  let result = [];
+  for (let i = 0; i < nums.length; i++) {
+    const productNums = [...nums.slice(0, i), ...nums.slice(i + 1)];
+
+    let product = 1;
+    for (let j = 0; j < productNums.length; j++) {
+      product *= productNums[j];
+    }
+    result.push(product);
+  }
+  return result;
+
+  // 2.
+  const n = nums.length;
+  // 정답 배열을 1로 초기화 (곱셈에 영향을 주지 않도록)
+  const answer = new Array(n).fill(1);
+
+  // 왼쪽 누적 곱 계산
+  let left = 1;
+  for (let i = 0; i < n; i++) {
+    answer[i] = left;
+    left *= nums[i];
+  }
+
+  // 오른쪽 누적 곱 계산
+  let right = 1;
+  for (let i = n - 1; i >= 0; i--) {
+    answer[i] *= right;
+    right *= nums[i];
+  }
+
+  return answer;
+};

valid-anagram/byol-han.js

@@ -0,0 +1,20 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var isAnagram = function (s, t) {
+  if (s.length !== t.length) return false;
+
+  // 문자열 t를 배열로 변환해서 문자 제거할 수 있게 함
+  let tArr = t.split("");
+
+  for (let i = 0; i < s.length; i++) {
+    let index = tArr.indexOf(s[i]); // s[i]가 tArr에 있는지 확인
+    if (index === -1) {
+      return false;
+    }
+    tArr.splice(index, 1);
+  }
+  return true;
+};

validate-binary-search-tree/byol-han.js

@@ -0,0 +1,38 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+var isValidBST = function (root) {
+  function helper(node, lower = -Infinity, upper = Infinity) {
+    if (!node) return true;
+
+    const val = node.val;
+
+    // 현재 노드가 범위를 벗어나면 false
+    if (val <= lower || val >= upper) {
+      return false;
+    }
+
+    // 오른쪽 서브트리: 최소값은 현재 노드 값
+    if (!helper(node.right, val, upper)) {
+      return false;
+    }
+
+    // 왼쪽 서브트리: 최대값은 현재 노드 값
+    if (!helper(node.left, lower, val)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  return helper(root);
+};