[Berrnuda] 24.12.03

berrnuda/10week/139_Word_Break.js

@@ -0,0 +1,26 @@
+/**
+ * @param {string} s
+ * @param {string[]} wordDict
+ * @return {boolean}
+ */
+var wordBreak = function (s, wordDict) {
+  const wordSet = new Set(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 wordSet) {
+      if (
+        i >= word.length &&
+        dp[i - word.length] &&
+        s.slice(i - word.length, i) === word
+      ) {
+        dp[i] = true;
+        break;
+      }
+    }
+  }
+
+  return dp[s.length];
+};

berrnuda/10week/215_Kth_Largest_Element_in_an_Array.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var findKthLargest = function (nums, k) {
+  const minPriQue = new MinPriorityQueue();
+  for (let i = 0; i < nums.length; i++) {
+    minPriQue.enqueue(nums[i]);
+    if (minPriQue.size() > k) {
+      minPriQue.dequeue();
+    }
+  }
+  return minPriQue.front().element;
+};

berrnuda/10week/235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree.js

@@ -0,0 +1,26 @@
+/**
+ * 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) {
+  while (root) {
+    if (p.val < root.val && q.val < root.val) {
+      root = root.left;
+    } else if (p.val > root.val && q.val > root.val) {
+      root = root.right;
+    } else {
+      return root;
+    }
+  }
+  return null;
+};

berrnuda/10week/56_Merge_Intervals.js

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

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/1week/121_Best_Time_to_Buy_and_Sell_Stock.js

@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function (prices) {
+  const { length } = prices;
+  let minPrice = Math.max(...prices);
+  let maxProfit = 0;
+
+  for (let i = 0; i < length; i++) {
+    if (prices[i] < minPrice) {
+      minPrice = prices[i];
+    } else {
+      let profit = prices[i] - minPrice;
+      maxProfit = profit > maxProfit ? profit : maxProfit;
+    }
+  }
+  return maxProfit;
+};

berrnuda/1week/15_3Sum.js

@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function (nums) {
+  const { length } = nums;
+  const result = [];
+  const sortedNums = nums.sort((a, b) => a - b);
+
+  for (let i = 0; i < length - 2; i++) {
+    if (i != 0 && sortedNums[i] === sortedNums[i - 1]) continue;
+
+    for (let j = i + 1, k = length - 1; j < k; ) {
+      const sum = sortedNums[i] + sortedNums[j] + sortedNums[k];
+
+      if (sum === 0) {
+        result.push([sortedNums[i], sortedNums[j], sortedNums[k]]);
+
+        while (j < k && sortedNums[j] === sortedNums[j + 1]) j++;
+        while (j < k && sortedNums[k] === sortedNums[k - 1]) k--;
+
+        j++;
+        k--;
+      } else if (sum < 0) {
+        j++;
+      } else {
+        k--;
+      }
+    }
+  }
+
+  return result;
+};

berrnuda/1week/217_Contains_Duplicate.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  const { length } = nums;
+  const num = {};
+
+  for (let i = 0; i < length; i++) {
+    if (num[nums[i]]) return true;
+    num[nums[i]] = true;
+  }
+
+  return false;
+};

berrnuda/1week/252_Meeting_Rooms.js

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

berrnuda/1week/268_Missing_Number.js

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

berrnuda/2week/100_Same_Tree.js

@@ -0,0 +1,26 @@
+/**
+ * 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) {
+  if (p === null && q === null) return true;
+  if (p === null || q === null) return false;
+
+  if (p.val !== q.val) return false;
+
+  return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+};
+
+// Runtime:  53 ms    Beats 54.81%
+// Memory:   49.98 MB Beats 5.64%
+
+// 22m 38s