Merge pull request #2398 from Cyjin-jani/main

[Cyjin-jani] WEEK 02 solutions

Author: Cyjin-jani

3sum/Cyjin-jani.js

@@ -0,0 +1,45 @@
+// ! 풀다가 막혀서 AI의 도움(힌트)을 받아 완성한 코드입니다..
+
+// tc: o(n^2)
+// sc: o(n)
+const threeSum = function (nums) {
+  const answer = [];
+
+  // 먼저 오름차순 정렬하기
+  const sortedArr = nums.sort((a, b) => a - b);
+
+  for (let i = 0; i < sortedArr.length; i++) {
+    if (i > 0 && sortedArr[i] === sortedArr[i - 1]) continue;
+
+    let left = i + 1;
+    let right = sortedArr.length - 1;
+
+    while (left < right) {
+      const sum = sortedArr[i] + sortedArr[left] + sortedArr[right];
+
+      if (sum === 0) {
+        answer.push([sortedArr[i], sortedArr[left], sortedArr[right]]);
+
+        // 중복 처리
+        // left가 가리키는 숫자가 이전 숫자와 똑같다면 계속 패스
+        while (left < right && sortedArr[left] === sortedArr[left + 1]) {
+          left++;
+        }
+        // right가 가리키는 숫자가 이전 숫자와 똑같다면 계속 패스
+        while (left < right && sortedArr[right] === sortedArr[right - 1]) {
+          right--;
+        }
+        // 똑같은 숫자들을 다 건너뛰었으니, 새로운 숫자로 넘어감
+        left++;
+        right--;
+      } else if (sum < 0) {
+        // 0보다 작으면 left를 키움 (오름차순 정렬이기 때문)
+        left++;
+      } else {
+        right--;
+      }
+    }
+  }
+
+  return answer;
+};

climbing-stairs/Cyjin-jani.js

@@ -0,0 +1,37 @@
+// 1트
+// tc: O(n)
+// sc: O(n)
+const climbStairs_before = function (n) {
+  // 1걸음 혹은 2걸음만 이동 가능하니까 전 step까지의 결과 + 전전 step까지의 결과
+  // D(n-1) + D(n-2)
+  const data = [0, 1, 2];
+
+  for (let i = 1; i <= n; i++) {
+    if (!data[i]) {
+      data[i] = data[i - 1] + data[i - 2];
+    }
+  }
+
+  return data[n];
+
+  // 이렇게 풀면 sc가 O(n)...
+  // 더 나은 방법을 고민하는 것이 필요..
+};
+
+// 2트
+// tc: O(n)
+// sc: O(1)
+const climbStairs = function (n) {
+  if (n < 3) return n;
+
+  let d1 = 1;
+  let d2 = 2;
+
+  for (let i = 3; i <= n; i++) {
+    let sum = d1 + d2;
+    d1 = d2;
+    d2 = sum;
+  }
+
+  return d2;
+};

product-of-array-except-self/Cyjin-jani.js

@@ -0,0 +1,21 @@
+// tc : O(n).
+// sc : O(n)이지만 출력 배열(result)은 카운트 되지 않는다고 했으므로 O(1).
+const productExceptSelf = function (nums) {
+  const length = nums.length;
+  const result = Array.from({ length }).fill(1);
+
+  let leftSide = 1;
+  let rightSide = 1;
+
+  for (let i = 0; i < length; i++) {
+    result[i] = leftSide;
+    leftSide *= nums[i];
+  }
+
+  for (let i = length - 1; i >= 0; i--) {
+    result[i] *= rightSide;
+    rightSide *= nums[i];
+  }
+
+  return result;
+};

valid-anagram/Cyjin-jani.js

@@ -0,0 +1,19 @@
+// tc: O(n)
+// sc: 제약조건에 따르면 O(1). 그러나 모든 유니코드 포함될 경우 O(n)
+const isAnagram = function (s, t) {
+  // 글자수가 다르면 anangram이 성립될 수 없으므로 빠른 return;
+  if (s.length !== t.length) return false;
+
+  const data = new Map();
+
+  for (char of s) {
+    data.set(char, (data.get(char) || 0) + 1);
+  }
+
+  for (let char of t) {
+    if (!data.get(char)) return false;
+    data.set(char, data.get(char) - 1);
+  }
+
+  return true;
+};

validate-binary-search-tree/Cyjin-jani.js

@@ -0,0 +1,23 @@
+const isValidBST = function (root) {
+  let answer = true;
+
+  function validateRecursion(node, min, max) {
+    if (!node) return;
+
+    if (node.val >= max || node.val <= min) {
+      answer = false;
+      return;
+    }
+    if (node.val <= min || node.val >= max) {
+      answer = false;
+      return;
+    }
+
+    validateRecursion(node.left, min, node.val);
+    validateRecursion(node.right, node.val, max);
+  }
+
+  validateRecursion(root, -Infinity, Infinity);
+
+  return answer;
+};