[togo26] WEEK 01 solutions

contains-duplicate/togo26.js

@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  const numsSet = new Set(nums);
+  return numsSet.size !== nums.length;
+};
+
+/*
+TC: O(n) -> nums 개수 만큼
+SC: O(n) -> 중복 삭제 후 요소 수 만큼 메모리 사용
+*/

house-robber/togo26.js

@@ -0,0 +1,43 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+/*
+TC: O(n)
+SC: O(n)
+*/
+var rob = function (nums) {
+  const pocket = {};
+
+  for (let i = 0; i < nums.length; i++) {
+    if (i === 0) {
+      pocket[i] = nums[i];
+      continue;
+    }
+    if (i === 1) {
+      pocket[i] = Math.max(nums[i - 1], nums[i]);
+      continue;
+    }
+
+    pocket[i] = Math.max(pocket[i - 2] + nums[i], pocket[i - 1]);
+  }
+
+  return Object.values(pocket).reduce((acc, cur) => Math.max(acc, cur), 0);
+};
+
+/*
+TC: O(n)
+SC: O(1) -> variable used
+*/
+var rob = function (nums) {
+  let prev2 = 0;
+  let prev1 = 0;
+
+  for (let i = 0; i < nums.length; i++) {
+    let temp = prev1;
+    prev1 = Math.max(prev2 + nums[i], prev1);
+    prev2 = temp;
+  }
+
+  return prev1;
+};

longest-consecutive-sequence/togo26.js

@@ -0,0 +1,63 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+
+/*
+TC: O(n) -> for의 skip 부분을 while loop 분으로 채워짐
+SC: O(n) => Set 사용
+*/
+var longestConsecutive = function (nums) {
+  const numsSet = new Set(nums);
+  let seq = 0;
+
+  for (num of numsSet) {
+    if (numsSet.has(num - 1)) continue;
+
+    let next = num + 1;
+    let currentSeq = 1;
+
+    while (numsSet.has(next)) {
+      currentSeq++;
+      next++;
+    }
+
+    seq = Math.max(seq, currentSeq);
+  }
+
+  return seq;
+};
+
+/*
+memory out
+*/
+// var longestConsecutive = function(nums) {
+//     if (nums.length <= 1) return nums.length;
+
+//     const dedupeNums = new Set(nums);
+
+//     let maxValue = -Infinity;
+//     let minValue = Infinity;
+//     dedupeNums.forEach((num) => {
+//         maxValue = Math.max(maxValue, num);
+//         minValue = Math.min(minValue, num);
+//     });
+
+//     const markers = Array.from({ length: maxValue - minValue + 1 }, () => false);
+//     let maxSequence = 0;
+//     let currentSequence = 0;
+
+//     dedupeNums.forEach((num) => {
+//         markers[num - minValue] = true;
+//     });
+
+//     for (let i = 0; i < markers.length; i++) {
+//         if (markers[i]) currentSequence++;
+//         else {
+//             maxSequence = Math.max(maxSequence, currentSequence);
+//             currentSequence = 0;
+//         }
+//     }
+
+//     return Math.max(maxSequence, currentSequence);
+// };

top-k-frequent-elements/togo26.js

@@ -0,0 +1,52 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+
+/*
+TC: O(nlogn) -> sort
+SC: O(n) => numsCount 생성
+*/
+var topKFrequent = function (nums, k) {
+  const numsCount = nums.reduce((acc, cur) => {
+    acc[cur] = acc[cur] + 1 || 1;
+    return acc;
+  }, {});
+
+  const frequecyOrder = Object.entries(numsCount)
+    .sort(([, a], [, b]) => b - a)
+    .map(([k, v]) => [Number(k), v]);
+
+  const result = [];
+
+  for (let i = 0; i < k; i++) result.push(frequecyOrder[i][0]);
+
+  return result;
+};
+
+/*
+TC: O(n) -> frequency bucket index로 활용
+SC: O(n)
+*/
+var topKFrequent = function (nums, k) {
+  const numsCount = nums.reduce((acc, cur) => {
+    acc[cur] = acc[cur] + 1 || 1;
+    return acc;
+  }, {});
+
+  const bucket = [];
+  Object.entries(numsCount).forEach(([num, freq]) => {
+    if (!bucket[freq]) bucket[freq] = [];
+    bucket[freq].push(Number(num));
+  });
+
+  const result = [];
+  for (let i = bucket.length - 1; i >= 0 && result.length < k; i--) {
+    if (Array.isArray(bucket[i])) {
+      result.push(...bucket[i]);
+    }
+  }
+
+  return result;
+};

two-sum/togo26.js

@@ -0,0 +1,67 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+
+/*
+TC: O(n)
+SC: O(n) -> Map 사용
+*/
+
+var twoSum = function (nums, target) {
+  const map = new Map();
+  for (let i = 0; i < nums.length; i++) {
+    const complement = target - nums[i];
+    if (map.has(complement)) return [map.get(complement), i];
+    map.set(nums[i], i);
+  }
+};
+
+/*
+With two points
+TC: O(nlogn) -> sort 사용
+SC: O(n) -> origin index 배열 생성
+*/
+
+var twoSum = function (nums, target) {
+  const numsWithOriginIndex = nums.map((num, i) => [num, i]);
+  numsWithOriginIndex.sort(([a], [b]) => a - b);
+
+  let left = 0;
+  let right = nums.length - 1;
+  let result;
+
+  while (left < right) {
+    const [leftValue, leftIndex] = numsWithOriginIndex[left];
+    const [rightValue, rightIndex] = numsWithOriginIndex[right];
+    const sum = leftValue + rightValue;
+
+    if (sum === target) {
+      result = [leftIndex, rightIndex];
+      break;
+    }
+
+    if (sum > target) right--;
+    else left++;
+  }
+
+  return result;
+};
+
+/*
+Brute force
+TC: O(n^2)
+SC: O(1)
+*/
+
+var twoSum = function (nums, target) {
+  for (let i = 0; i < nums.length; i++) {
+    for (let j = i + 1; j < nums.length; j++) {
+      if (nums[i] + nums[j] === target) {
+        return [i, j];
+      }
+    }
+  }
+  return result;
+};