[citrussoda] 24.11.26

citrussoda/10week/139_word-break.js

@@ -0,0 +1,23 @@
+/**
+ * @param {string} s
+ * @param {string[]} wordDict
+ * @return {boolean}
+ */
+var wordBreak = function (s, wordDict) {
+  const dp = new Array(s.length + 1).fill(false);
+  dp[0] = true;
+
+  for (let i = 1; i <= s.length; i++) {
+    for (let word of wordDict) {
+      if (i >= word.length && dp[i - word.length]) {
+        const sub = s.slice(i - word.length, i);
+        if (sub === word) {
+          dp[i] = true;
+          break;
+        }
+      }
+    }
+  }
+
+  return dp[s.length];
+};

citrussoda/10week/1584_min-cost-to-connect-all-points.js

@@ -0,0 +1,45 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+// Prim's Algorithm
+var minCostConnectPoints = function (points) {
+  const n = points.length;
+
+  // 방문 여부를 체크하는 배열
+  const visited = new Set();
+
+  // 각 점까지의 최소 거리를 저장하는 배열
+  const distances = new Array(n).fill(Infinity);
+  distances[0] = 0;
+
+  let totalCost = 0;
+
+  for (let i = 0; i < n; i++) {
+    let minDist = Infinity;
+    let minIndex = -1;
+
+    // 아직 방문하지 않은 점들 중에서 최소 거리를 가진 점을 찾음
+    for (let j = 0; j < n; j++) {
+      if (!visited.has(j) && distances[j] < minDist) {
+        minDist = distances[j];
+        minIndex = j;
+      }
+    }
+
+    visited.add(minIndex);
+    totalCost += minDist;
+
+    // 선택된 점에서 다른 모든 점까지의 거리를 업데이트
+    for (let j = 0; j < n; j++) {
+      if (!visited.has(j)) {
+        const distance =
+          Math.abs(points[minIndex][0] - points[j][0]) +
+          Math.abs(points[minIndex][1] - points[j][1]);
+        distances[j] = Math.min(distances[j], distance);
+      }
+    }
+  }
+
+  return totalCost;
+};

citrussoda/10week/215_kth-largest-element-in-an-array.js

@@ -0,0 +1,10 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var findKthLargest = function (nums, k) {
+  nums.sort((a, b) => b - a);
+
+  return nums[k - 1];
+};

citrussoda/10week/235_lowest-common-ancestor-of-a-binary-search-tree.js

@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {TreeNode}
+ */
+var lowestCommonAncestor = function (root, p, q) {
+  if (root.val > p.val && root.val < q.val) {
+    return root;
+  }
+
+  if (root.val > p.val && root.val > q.val) {
+    return lowestCommonAncestor(root.left, p, q);
+  }
+
+  if (root.val < p.val && root.val < q.val) {
+    return lowestCommonAncestor(root.right, p, q);
+  }
+
+  return root;
+};

citrussoda/10week/56_merge-intervals.js

@@ -0,0 +1,24 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number[][]}
+ */
+var merge = function (intervals) {
+  intervals.sort((a, b) => a[0] - b[0]);
+
+  const ans = [];
+  let prev = intervals[0];
+
+  for (let i = 1; i < intervals.length; i++) {
+    let interval = intervals[i];
+
+    if (interval[0] <= prev[1]) {
+      prev[1] = Math.max(prev[1], interval[1]);
+    } else {
+      ans.push(prev);
+      prev = interval;
+    }
+  }
+
+  ans.push(prev);
+  return ans;
+};

citrussoda/1week/121.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function (prices) {
+  let maxCurrent = 0;
+  let maxSoFar = 0;
+
+  for (let i = 1; i < prices.length; i++) {
+    maxCurrent = Math.max(0, maxCurrent + prices[i] - prices[i - 1]);
+    maxSoFar = Math.max(maxSoFar, maxCurrent);
+  }
+
+  return maxSoFar;
+};

citrussoda/1week/15.js

@@ -0,0 +1,42 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function (nums) {
+  let answer = [];
+
+  nums.sort((a, b) => a - b);
+
+  for (let i = 0; i < nums.length - 2; i++) {
+    if (nums[i] === nums[i - 1]) continue;
+
+    let target = nums[i];
+    let startIndex = i + 1;
+    let lastIndex = nums.length - 1;
+
+    while (startIndex < lastIndex) {
+      let sum = target + nums[startIndex] + nums[lastIndex];
+      if (sum > 0) {
+        lastIndex -= 1;
+      } else if (sum < 0) {
+        startIndex += 1;
+      } else {
+        answer.push([target, nums[startIndex], nums[lastIndex]]);
+        while (
+          startIndex < lastIndex &&
+          nums[startIndex] === nums[startIndex + 1]
+        )
+          startIndex += 1;
+        while (
+          startIndex < lastIndex &&
+          nums[lastIndex] === nums[lastIndex - 1]
+        )
+          lastIndex -= 1;
+        startIndex += 1;
+        lastIndex -= 1;
+      }
+    }
+  }
+
+  return answer;
+};

citrussoda/1week/217.js

@@ -0,0 +1,9 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  const setNums = new Set(nums);
+
+  return setNums.size !== nums.length;
+};

citrussoda/1week/268.js

@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var missingNumber = function (nums) {
+  nums.sort((a, b) => a - b);
+
+  for (let i = 0; i <= nums.length; i++) {
+    if (nums[i] !== i) return i;
+  }
+};

citrussoda/1week/meetingSchedule.js

@@ -0,0 +1,27 @@
+/**
+ * Definition of Interval:
+ * class Interval {
+ *   constructor(start, end) {
+ *     this.start = start;
+ *     this.end = end;
+ *   }
+ * }
+ */
+
+class Solution {
+  /**
+   * @param {Interval[]} intervals
+   * @returns {boolean}
+   */
+  canAttendMeetings(intervals) {
+    intervals.sort((a, b) => a.start - b.start);
+
+    for (let i = 1; i < intervals.length; i++) {
+      if (intervals[i - 1].end > intervals[i].start) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+}

citrussoda/2week/100_same-tree.js

@@ -0,0 +1,48 @@
+/**
+ * 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} p
+ * @param {TreeNode} q
+ * @return {boolean}
+ */
+var isSameTree = function (p, q) {
+  let firstTree = [];
+  let secondTree = [];
+
+  iter(p, firstTree);
+  iter(q, secondTree);
+
+  if (firstTree.length !== secondTree.length) return false;
+
+  for (let i = 0; i < firstTree.length - 1; i++) {
+    if (firstTree[i] !== secondTree[i]) return false;
+  }
+
+  return true;
+};
+
+const iter = (target, tree) => {
+  if (!target) return tree;
+
+  tree.push(target.val);
+
+  if (target.left) {
+    iter(target.left, tree);
+  } else if (target.left === null) {
+    tree.push(null);
+  }
+
+  if (target.right) {
+    iter(target.right, tree);
+  } else if (target.right === null) {
+    tree.push(null);
+  }
+
+  return tree;
+};

citrussoda/2week/191_number-of-1-bits.js

@@ -0,0 +1,19 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var hammingWeight = function (n) {
+  return findBit(n, 0);
+};
+
+const findBit = (n, count) => {
+  if (n < 1) return count;
+
+  let i = 1;
+  while (i <= n / 2) {
+    i *= 2;
+  }
+  count++;
+
+  return findBit(n - i, count);
+};

citrussoda/2week/238_product-of-array-except-self.js

@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var productExceptSelf = function (nums) {
+  let answer = Array.from({ length: nums.length }).fill(1);
+
+  let left = 1;
+
+  for (let i = 0; i < nums.length; i++) {
+    answer[i] *= left;
+    left *= nums[i];
+  }
+
+  let right = 1;
+
+  for (let i = nums.length - 1; i >= 0; i--) {
+    answer[i] *= right;
+    right *= nums[i];
+  }
+
+  return answer;
+};

citrussoda/2week/242_valid-anagram.js

@@ -0,0 +1,22 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var isAnagram = function (s, t) {
+  if (s.length !== t.length) return false;
+
+  let firstStr = {};
+  [...s].forEach((char) => (firstStr[char] = (firstStr[char] || 0) + 1));
+
+  let secondStr = {};
+  [...t].forEach((char) => (secondStr[char] = (secondStr[char] || 0) + 1));
+
+  for (let char in firstStr) {
+    if (firstStr[char] !== secondStr[char]) {
+      return false;
+    }
+  }
+
+  return true;
+};

citrussoda/2week/746_min-cost-climbing-stairs.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} cost
+ * @return {number}
+ */
+var minCostClimbingStairs = function (cost) {
+  let dp = Array.from({ length: cost.length + 1 }, () => 0);
+
+  for (let i = 2; i <= cost.length; i++) {
+    dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
+  }
+
+  console.log(dp);
+
+  return dp[dp.length - 1];
+};