[Joo kangsan] 24.11.26

JooKangsan/10주차/139_Word_Break.js

@@ -0,0 +1,32 @@
+
+
+/**
+ * @param {string} s
+ * @param {string[]} wordDict
+ * @return {boolean}
+ */
+var wordBreak = function(s, wordDict) {
+    const memo = new Map();
+
+    function dp(str, i = 0) {
+        if (str.length === 0) return true;
+        if (i >= wordDict.length) return false;
+
+        const key = str + ',' + i;
+        if (memo.has(key)) return memo.get(key);
+
+        let word = wordDict[i];
+        if (str.slice(0, word.length) === word) {
+            if (dp(str.slice(word.length), 0)) {
+                memo.set(key, true);
+                return true;
+            }
+        }
+
+        const result = dp(str, i + 1);
+        memo.set(key, result);
+        return result;
+    }
+
+    return dp(s);
+};

JooKangsan/10주차/1584_Min_Cost_to_Connect_All_Points.js

@@ -0,0 +1,34 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+var minCostConnectPoints = function (points) {
+  const n = points.length;
+  const visited = new Array(n).fill(false);
+  const minDist = new Array(n).fill(Infinity);
+  minDist[0] = 0;
+  let result = 0;
+
+  for (let i = 0; i < n; i++) {
+    let x = -1;
+    for (let j = 0; j < n; j++) {
+      if (!visited[j] && (x === -1 || minDist[j] < minDist[x])) {
+        x = j;
+      }
+    }
+
+    visited[x] = true;
+    result += minDist[x];
+
+    for (let k = 0; k < n; k++) {
+      if (!visited[k]) {
+        const dist =
+          Math.abs(points[x][0] - points[k][0]) +
+          Math.abs(points[x][1] - points[k][1]);
+        minDist[k] = Math.min(minDist[k], dist);
+      }
+    }
+  }
+
+  return result;
+};

JooKangsan/10주차/215_Kth_Largest_Element_in_an_Array.js

@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var findKthLargest = function(nums, k) {
+  let [min, max] = nums.reduce(([min, max], num) => 
+      [Math.min(min, num), Math.max(max, num)], 
+      [Infinity, -Infinity]
+  );
+
+  const offset = min >= 0 ? 0 : -min;
+  const count = new Array(max + 1 + offset).fill(0);
+
+  for(let num of nums) {
+      count[num + offset]++;
+  }
+
+  let kthLargest;
+  for(let i = count.length - 1; i >= 0; i--) {
+      k -= count[i];
+      if(k <= 0) {
+          kthLargest = i - offset;
+          break;
+      }
+  }
+
+  return kthLargest;
+};

JooKangsan/10주차/235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree.js

@@ -0,0 +1,27 @@
+/**
+ * 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) {
+  let min = Math.min(p.val, q.val)
+  let max = Math.max(p.val, q.val)
+
+  if(min > root.val) {
+      return lowestCommonAncestor(root.right, p, q)
+  } else if(max < root.val) {
+      return lowestCommonAncestor(root.left, p, q)
+  } else {
+      return root
+  }
+};

JooKangsan/10주차/56_Merge_Intervals.js

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

JooKangsan/5주차/1046_Last_Stone_Weight.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} stones
+ * @return {number}
+ */
+var lastStoneWeight = function (stones) {
+  while (stones.length > 1) {
+    stones.sort((a, b) => b - a);
+    const first = stones.shift();
+    const second = stones.shift();
+    if (first !== second) {
+      stones.push(first - second);
+    }
+  }
+  return stones.length === 0 ? 0 : stones[0];
+};

JooKangsan/5주차/21_Merge_Two_Sorted_Lists.js

@@ -0,0 +1,23 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} list1
+ * @param {ListNode} list2
+ * @return {ListNode}
+ */
+var mergeTwoLists = function (list1, list2) {
+  if (list1 == null) return list2;
+  if (list2 == null) return list1;
+  if (list1.val <= list2.val) {
+    list1.next = mergeTwoLists(list1.next, list2);
+    return list1;
+  } else {
+    list2.next = mergeTwoLists(list1, list2.next);
+    return list2;
+  }
+};

JooKangsan/5주차/338_Counting_Bits.js

@@ -0,0 +1,13 @@
+/**
+ * @param {number} n
+ * @return {number[]}
+ */
+var countBits = function (n) {
+  const ans = new Array(n + 1).fill(0);
+
+  for (let i = 1; i <= n; i++) {
+    ans[i] = ans[Math.floor(i / 2)] + (i % 2);
+  }
+
+  return ans;
+};

JooKangsan/5주차/48_Rotate_Image.js

@@ -0,0 +1,14 @@
+/**
+ * @param {number[][]} matrix
+ * @return {void} Do not return anything, modify matrix in-place instead.
+ */
+var rotate = function (matrix) {
+  for (let i = 0; i < matrix.length; i++) {
+    for (let j = i + 1; j < matrix.length; j++) {
+      [matrix[i][j], matrix[j][i]] = [matrix[j][i], matrix[i][j]];
+    }
+  }
+  for (let i = 0; i < matrix.length; i++) {
+    matrix[i].reverse();
+  }
+};

JooKangsan/5주차/70_Climbing_Stairs.js

@@ -0,0 +1,14 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function (n) {
+  if (n <= 2) return n;
+  const step = new Array(n + 1).fill(0);
+  step[1] = 1;
+  step[2] = 2;
+  for (let i = 3; i <= n; i++) {
+    step[i] = step[i - 1] + step[i - 2];
+  }
+  return step[n];
+};

JooKangsan/6주차/ 703_Kth_Largest_Element_in_a_Stream.js

@@ -0,0 +1,63 @@
+/**
+ * @param {number} k
+ * @param {number[]} nums
+ */
+var KthLargest = function(k, nums) {
+  this.k = k;
+  this.h = [];
+
+  // populate the array
+  const limit = Math.min(this.k, nums.length);
+  for(let i = 0; i < limit; i++) {
+      this.h.push(nums[i]);
+  }
+  this.heapifyBottomUp();
+  // add remaining elements
+  for(let i = k; i < nums.length; i++) {
+      this.add(nums[i]);
+  }
+};
+
+KthLargest.prototype.heapifyBottomUp = function() {
+  const firstLeafAt = Math.floor(this.h.length/2);
+  for(let i = firstLeafAt - 1; i >= 0; i--) {
+      this.heapify(i);
+  }
+}
+
+KthLargest.prototype.heapify = function(i) {
+  const l = 2*i + 1;
+  const r = 2*i + 2;
+
+  let min = i;
+
+  if(l < this.h.length && this.h[l] < this.h[min]) {
+      min = l
+  }
+
+  if(r < this.h.length && this.h[r] < this.h[min]) {
+      min = r;
+  }
+
+  if(min != i) {
+      [this.h[i], this.h[min]] = [this.h[min], this.h[i]];
+      this.heapify(min)
+  }
+};
+
+/** 
+* @param {number} val
+* @return {number}
+*/
+KthLargest.prototype.add = function(val) {
+  if(this.h.length < this.k) { // heap is not full
+      this.h.push(val);
+      this.heapifyBottomUp();
+  } else {
+      if(val > this.h[0]) {
+          this.h[0] = val;
+          this.heapify(0)
+      }
+  }
+  return this.h[0];
+};

JooKangsan/6주차/198_House_Robber.js

@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function (nums) {
+  let n = nums.length;
+  if (n === 0) return 0;
+  if (n === 1) return nums[0];
+
+  let dp = new Array(n + 1).fill(0);
+  dp[1] = nums[0];
+
+  for (let i = 2; i <= n; i++) {
+    dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i - 1]);
+  }
+
+  return dp[n];
+};

JooKangsan/6주차/271_Encode_and_Decode_Strings.js

@@ -0,0 +1,27 @@
+class Solution {
+  /**
+   * @param {string[]} strs
+   * @returns {string}
+   */
+  encode(strs) {
+    return strs.map((s) => `${s.length}#${s}`).join("");
+  }
+
+  /**
+   * @param {string} str
+   * @returns {string[]}
+   */
+  decode(str) {
+    let i = 0;
+    const result = [];
+
+    while (i < str.length) {
+      let j = str.indexOf("#", i);
+      let length = parseInt(str.slice(i, j), 10);
+      result.push(str.slice(j + 1, j + 1 + length));
+      i = j + 1 + length;
+    }
+
+    return result;
+  }
+}

JooKangsan/6주차/66_Plus_One.js

@@ -0,0 +1,8 @@
+/**
+ * @param {number[]} digits
+ * @return {number[]}
+ */
+var plusOne = function (digits) {
+  const join = BigInt(digits.join("")) + 1n;
+  return join.toString().split("").map(Number);
+};

JooKangsan/6주차/704_Binary_Search.js

@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var search = function(nums, target) {
+  let left = 0;
+  let right = nums.length - 1;
+  while (left <= right) {
+      const center = Math.floor((left + right) / 2);
+
+      if (nums[center] === target) {
+          return center;
+      } else if (nums[center] < target) {
+          left = center + 1;
+      } else {
+          right = center - 1;
+      }
+  }
+
+  return -1;
+}