[Berrnuda] 24.12.03 (#112)

* 217 / Contains Duplicate / Easy / 5m

* 267 / Missing Number / Easy / 1m

* 121 / Best Time to Buy and Sell Stock / Easy / 8m

* 252 / Meeting Rooms / Easy / 10m

* 15 / 3Sum / Medium / 11m 28s

* 기존 파일들 1wwek 폴더로 이동

* 242 / Valid Anagram / Easy / 2m 50s

* 238 / Product of Arrays Except Self / Medium / 21m 22s

* 191 / Number of 1 Bits / Easy / 13m 27s

* 100 / Same Tree / Easy / 22m 38s

* 746 / Min Cost Climbing Stairs / Easy / 41m 1s

* 49 / Group Anagrams / Medium / 13m 48s

* 190 / Reverse Bits / Easy / 7m 36s"

* 125 / Valid Palindrome / Easy / 4m 11s

* 322 / Coin Change / Medium / 10m 52s

* 206 / Reverse Linked list / Easy / 12m 25s

* 338 / Counting Bits / Easy / 14m 28s

* 70 / Climbing Stairs / Easy / 3m 11s

* 21 / Merge Two Sorted Lists / Easy / 5m 28s

* 48 / Rotate Image / Medium / 15m 42s

* 1046 / Last Stone Weight / Easy / 8m 2s

* 271 / Encode and Decode Strings / Medium / 28m

* 198 / House Robber / Medium / 7m 31s

* 66 / Plus Onde / Easy / 7m 48s

* 704 / Binary Search / Easy / 3m 58s

* 703 / Kth Largest Element in a Stream / Easy / 41m 16s"

* 102 / Binary Tree Level Order Traversal / Medium / 13m

* 572 / Subtree of Another Tree / Easy / 08m 59s

* 213 / House Robber II / Medium / 11m 23s

* 150 / Evaluate Reverse Polish Notation / Meium / 12m 01s

* 56 / Merge Intervals / Medium / 12m 58s

* 235 / Lowest Common Ancestor of a Binary Search Tree / Medium / 14m 45s

* 139 / Word Break / Medium / 18m 22s

* 215 / Kth Largest Element in an Array / Medium / 20m 19s

* 오타수정

* 7 / Reverse Interger / Medium / 5m 57s

* 743 / Network Delay Time / Medium / 35m 36s

* 39 / Combination Sum / Medium / 21m 41s

* 2013 / Detect Squares / Medium / 31m 15s

* 57 / Insert Interval / Medium / 20m 29s

Author: Berrnuda

berrnuda/11week/2013_Detect_Squares.js

@@ -0,0 +1,43 @@
+var DetectSquares = function () {
+  this.ptsCount = new Map();
+};
+
+/**
+ * @param {number[]} point
+ * @return {void}
+ */
+DetectSquares.prototype.add = function (point) {
+  const key = `${point[0]}/${point[1]}`;
+  this.ptsCount.set(key, (this.ptsCount.get(key) || 0) + 1);
+};
+
+/**
+ * @param {number[]} point
+ * @return {number}
+ */
+DetectSquares.prototype.count = function (point) {
+  const [qx, qy] = point;
+  let result = 0;
+
+  for (const key of this.ptsCount.keys()) {
+    const [px, py] = key.split("/").map(Number);
+
+    if (Math.abs(px - qx) === Math.abs(py - qy) && px !== qx && py !== qy) {
+      const key1 = `${px}/${qy}`;
+      const key2 = `${qx}/${py}`;
+      result +=
+        (this.ptsCount.get(key) || 0) *
+        (this.ptsCount.get(key1) || 0) *
+        (this.ptsCount.get(key2) || 0);
+    }
+  }
+
+  return result;
+};
+
+/**
+ * Your DetectSquares object will be instantiated and called as such:
+ * var obj = new DetectSquares()
+ * obj.add(point)
+ * var param_2 = obj.count(point)
+ */

berrnuda/11week/39_Combination_Sum.js

@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+var combinationSum = function (candidates, target) {
+  const result = [];
+  const stack = [[[], 0, 0]];
+
+  while (stack.length > 0) {
+    const [currentCombination, currentSum, startIndex] = stack.pop();
+
+    if (currentSum === target) {
+      result.push(currentCombination);
+      continue;
+    }
+
+    if (currentSum > target) continue;
+
+    for (let i = startIndex; i < candidates.length; i++) {
+      stack.push([
+        [...currentCombination, candidates[i]],
+        currentSum + candidates[i],
+        i,
+      ]);
+    }
+  }
+
+  return result;
+};

berrnuda/11week/57_Insert_Interval.js

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

berrnuda/11week/743_Network_Delay_Time.js

@@ -0,0 +1,35 @@
+/**
+ * @param {number[][]} times
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+var networkDelayTime = function (times, n, k) {
+  const node = Array.from({ length: n + 1 }, () => []);
+  for (const [u, v, w] of times) node[u].push([v, w]);
+
+  const dist = new Array(n + 1).fill(Infinity);
+  dist[k] = 0;
+
+  const visited = new Array(n + 1).fill(false);
+
+  for (let i = 1; i <= n; i++) {
+    let minNode = -1;
+    for (let j = 1; j <= n; j++) {
+      if (!visited[j] && (minNode === -1 || dist[j] < dist[minNode]))
+        minNode = j;
+    }
+
+    if (dist[minNode] === Infinity) break;
+
+    visited[minNode] = true;
+
+    for (const [neighbor, weight] of node[minNode]) {
+      const newDist = dist[minNode] + weight;
+      if (newDist < dist[neighbor]) dist[neighbor] = newDist;
+    }
+  }
+
+  const maxDist = Math.max(...dist.slice(1));
+  return maxDist === Infinity ? -1 : maxDist;
+};

berrnuda/11week/7_Reverse_Integer.js

@@ -0,0 +1,12 @@
+/**
+ * @param {number} x
+ * @return {number}
+ */
+var reverse = function (x) {
+  const sign = x < 0;
+  const rev = parseInt(String(Math.abs(x)).split("").reverse().join(""));
+
+  if (rev < -Math.pow(2, 31) || rev > Math.pow(2, 31) - 1) return 0;
+
+  return sign ? -rev : rev;
+};

berrnuda/6week/198_House_Robber.js

@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function (nums) {
+  let rob1 = 0;
+  let rob2 = 0;
+
+  for (let i = 0; i < nums.length; i++) {
+    let rob = Math.max(rob2 + nums[i], rob1);
+    rob2 = rob1;
+    rob1 = rob;
+  }
+
+  return rob1;
+};

berrnuda/6week/66_Plus_One.js

@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} digits
+ * @return {number[]}
+ */
+var plusOne = function (digits) {
+  let l = digits.length;
+
+  for (let i = l - 1; i >= 0; i--) {
+    digits[i]++;
+    if (digits[i] == 10) digits[i] = 0;
+    else return digits;
+  }
+
+  digits.unshift(1);
+
+  return digits;
+};

berrnuda/6week/703_Kth_Largest_Element_in_a_Stream.js

@@ -0,0 +1,29 @@
+/**
+ * @param {number} k
+ * @param {number[]} nums
+ */
+var KthLargest = function (k, nums) {
+  this.k = k;
+  this.score = [];
+
+  for (let num of nums) this.add(num);
+};
+
+/**
+ * @param {number} val
+ * @return {number}
+ */
+KthLargest.prototype.add = function (val) {
+  if (this.score.length < this.k) this.score.push(val);
+  else if (val > this.score[this.k - 1]) this.score[this.k - 1] = val;
+
+  this.score.sort((a, b) => b - a);
+
+  return this.score[this.k - 1];
+};
+
+/**
+ * Your KthLargest object will be instantiated and called as such:
+ * var obj = new KthLargest(k, nums)
+ * var param_1 = obj.add(val)
+ */

berrnuda/6week/704_Binary_Search.js

@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var search = function (nums, target) {
+  let first = 0;
+  let last = nums.length - 1;
+
+  for (; first <= last; ) {
+    let curr = Math.floor((first + last) / 2);
+
+    if (nums[curr] === target) return curr;
+    else if (nums[curr] < target) first = curr + 1;
+    else last = curr - 1;
+  }
+
+  return -1;
+};