Merge pull request #1230 from jeongwoo903/main

[jeongwoo903] Week 02 Solutions

Author: jeongwoo903

3sum/jeongwoo903.js

@@ -0,0 +1,42 @@
+/*
+* 투 포인터 방식 사용
+* 시간 복잡도: O(n^2)
+* 공간 복잡도; O(n^2)
+*/
+
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+const threeSum = (nums) => {
+  const sorted = [...nums].sort((a, b) => a - b);
+  const results = [];
+
+  sorted.forEach((val, i) => {
+    if (i > 0 && val === sorted[i - 1]) return;
+
+    let left = i + 1;
+    let right = sorted.length - 1;
+
+    while (left < right) {
+      const sum = val + sorted[left] + sorted[right];
+
+      if (sum === 0) {
+        results.push([val, sorted[left], sorted[right]]);
+
+        // 중복된 left/right 스킵
+        const currentLeft = sorted[left];
+        const currentRight = sorted[right];
+
+        while (left < right && sorted[left] === currentLeft) left++;
+        while (left < right && sorted[right] === currentRight) right--;
+      } else if (sum < 0) {
+        left++;
+      } else {
+        right--;
+      }
+    }
+  });
+
+  return results;
+};

climbing-stairs/jeongwoo903.js

@@ -0,0 +1,20 @@
+/*
+ * 시간 복잡도: O(n)
+ * 공간 복잡도: O(n)
+ */
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function(n) {
+  if (n === 1) return 1;
+
+  const dp = [1, 2]
+
+  for (let i = 2; i < n; i++) {
+    dp[i] = dp[i-1] + dp[i-2]
+  }
+
+  return dp[n-1]
+};

product-of-array-except-self/jeongwoo903.js

@@ -0,0 +1,25 @@
+/*
+ * 시간 복잡도: O(n)
+ * 공간 복잡도: O(n)
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+
+var productExceptSelf = function(nums) {
+  const lefts = nums.reduce((products, num, i) => {
+      products.push(i === 0 ? 1 : products[i - 1] * nums[i - 1]);
+      return products;
+    }, []
+  );
+
+  return nums.reduceRight((result, num, i) => {
+      const rights = i === nums.length - 1 ? 1 : result.rightProduct * nums[i + 1];
+      result.products[i] *= rights;
+      result.rightProduct = rights;
+      return result;
+    }, { products: lefts, rights: 1 }
+  ).products;
+};

valid-anagram/jeongwoo903.js

@@ -0,0 +1,18 @@
+/*
+ * 시간 복잡도: O(n log n)
+ * 공간 복잡도: O(n)
+ */
+
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var isAnagram = function(s, t) {
+  if(s.length !== t.length) return false;
+
+  const strA = [...s].sort().join('');
+  const strB = [...t].sort().join('');
+
+  return strA === strB;
+};

validate-binary-search-tree/jeongwoo903.js

@@ -0,0 +1,31 @@
+/*
+* 시간 복잡도: O(n)
+* 공간 복잡도; O(h)
+* -> h는 트리의 높이
+*/
+
+/**
+ * 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 bst(node , min, max) {
+    if (!node) return true;
+
+    if (node.val <= min || node.val >= max) return false;
+
+    return (
+      bst(node.left, min, node.val) && helper(node.right, node.val, max)
+    );
+  }
+
+  return bst(root, -Infinity, Infinity);
+};