[sukyoungshin] WEEK 01

contains-duplicate/sukyoungshin.ts

@@ -0,0 +1,26 @@
+// 1번째 풀이 (hashMap)
+function containsDuplicate1(nums: number[]): boolean {
+  const seen: Record<number, boolean> = {};
+
+  const isDuplicate = nums.some((num) => {
+    if (seen[num]) return true;
+    seen[num] = true;
+    return false;
+  });
+
+  return isDuplicate;
+};
+
+// 2번째 풀이(Set)
+function containsDuplicate2(nums: number[]): boolean {
+  const set = new Set();
+
+  for (const num of nums) {
+    if (set.has(num)) {
+      return true;
+    }
+    set.add(num);
+  }
+
+  return false;
+};

house-robber/sukyoungshin.ts

@@ -0,0 +1,31 @@
+// 1번풀이 (brute force)
+// function rob(nums: number[]): number {
+//   const n = nums.length;
+//   if (n === 1) return nums[0];
+//   if (n === 2) return Math.max(nums[0], nums[1]);
+
+//   const dp: number[] = [];
+//   dp[0] = nums[0];
+//   dp[1] = Math.max(nums[0], nums[1]);
+
+//   for (let i = 2; i < n; i++) {
+//     dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
+//   }
+
+//   return dp[n - 1];
+// }
+
+// 2번풀이 (dp)
+function rob(nums: number[]): number {
+  if (nums.length <= 1) return nums[0] ?? 0;
+
+  const dp: number[] = [];
+  dp[0] = nums[0];
+  dp[1] = Math.max(nums[0], nums[1]);
+
+  for (let i = 2; i < nums.length; i++) {
+    dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
+  }
+
+  return dp[nums.length - 1];
+};

longest-consecutive-sequence/sukyoungshin.ts

@@ -0,0 +1,46 @@
+// 1번풀이
+function longestConsecutive2(nums: number[]): number {
+  if (nums.length === 0) return 0;
+
+  const copiedNums = [...new Set(nums)].sort((a, b) => a - b);
+
+  let max = 1; // 지금까지 나왔던 가장 긴 연속 수열의 길이
+  let count = 1; // 현재 연속 수열의 길이
+
+  for (let i = 1; i < copiedNums.length; i++) {
+    const prev = copiedNums[i - 1];
+    const current = copiedNums[i];
+
+    if (current === prev + 1) {
+      count++;
+      max = Math.max(max, count);
+    } else {
+      count = 1;
+    }
+  }
+
+  return max;
+};
+
+// 2번풀이 (hashSet)
+function longestConsecutive(nums: number[]): number {
+  const numSet = new Set(nums);
+  let max = 0;
+
+  for (const num of numSet) {
+    // 수열의 시작점인 경우만 탐색
+    if (!numSet.has(num - 1)) {
+      let current = num;
+      let count = 1;
+
+      while (numSet.has(current + 1)) {
+        current++;
+        count++;
+      }
+
+      max = Math.max(max, count);
+    }
+  }
+
+  return max;
+};

top-k-frequent-elements/sukyoungshin.ts

@@ -0,0 +1,104 @@
+// 1번풀이 (brute force)
+type FrequencyMap = Record<number, number>;
+
+function topKFrequentCountDown(nums: number[], k: number): number[] {
+  const freqMap = buildFrequencyMap1(nums);
+  return pickTopKDescending(freqMap, k);
+};
+
+function buildFrequencyMap1(nums: number[]): FrequencyMap {
+  const map: FrequencyMap = {};
+  for (const num of nums) {
+    map[num] = (map[num] || 0) + 1;
+  }
+  return map;
+};
+
+function pickTopKDescending(freqMap: FrequencyMap, k: number): number[] {
+  const result: number[] = [];
+  const entries = Object.entries(freqMap).map(([key, value]) => [
+    Number(key),
+    value,
+  ]);
+  let currentFrequent = Math.max(...entries.map(([_, freq]) => freq));
+
+  while (result.length < k && currentFrequent > 0) {
+    for (const [num, freq] of entries) {
+      if (freq === currentFrequent) {
+        result.push(num);
+        if (result.length === k) break;
+      }
+    }
+    currentFrequent--;
+  }
+
+  return result;
+};
+
+// 2번풀이(Bucket Sort)
+function topKFrequent(nums: number[], k: number): number[] {
+  const frequencyMap = buildFrequencyMap2(nums);
+  const frequencyBuckets = buildFrequencyBuckets(nums.length, frequencyMap);
+
+  return collectTopKFrequent(frequencyBuckets, k);
+};
+
+function buildFrequencyMap2(nums: number[]): FrequencyMap {
+  const freqMap: FrequencyMap = {};
+  for (const num of nums) {
+    freqMap[num] = (freqMap[num] || 0) + 1;
+  }
+  return freqMap;
+};
+
+function buildFrequencyBuckets(
+  size: number,
+  freqMap: FrequencyMap
+): number[][] {
+  const buckets: number[][] = Array(size + 1)
+    .fill(null)
+    .map(() => []);
+
+  for (const [numStr, frequent] of Object.entries(freqMap)) {
+    const num = Number(numStr);
+    buckets[frequent].push(num);
+  }
+
+  return buckets;
+};
+
+function collectTopKFrequent(buckets: number[][], k: number): number[] {
+  const result: number[] = [];
+
+  for (let i = buckets.length - 1; i >= 0 && result.length < k; i--) {
+    for (const num of buckets[i]) {
+      result.push(num);
+      if (result.length === k) break;
+    }
+  }
+
+  return result;
+};
+
+// 3번풀이 (MinHeap)
+function topKFrequentHeap(nums: number[], k: number): number[] {
+  const freqMap: Record<number, number> = {};
+
+  for (const num of nums) {
+    freqMap[num] = (freqMap[num] || 0) + 1;
+  }
+
+  const heap: [number, number][] = [];
+  for (const [numStr, frequent] of Object.entries(freqMap)) {
+    const num = Number(numStr);
+
+    heap.push([num, frequent]);
+    heap.sort((a, b) => b[1] - a[1]);
+
+    if (heap.length > k) {
+      heap.pop();
+    }
+  }
+
+  return heap.map(([num]) => num);
+};

two-sum/sukyoungshin.ts

@@ -0,0 +1,45 @@
+// 1번째 풀이 (brute force)
+function twoSum1(nums: number[], target: number): number[] {
+  for (let i = 0; i < nums.length; i++) {
+    for (let j = 1; j < nums.length; j++) {
+      const a = nums[i];
+      const b = nums[j];
+
+      if (a + b === target && i !== j) {
+        return [i, j];
+      }
+    }
+  }
+  return [];
+};
+
+// 2번째 풀이 (indexOf)
+function twoSum2(nums: number[], target: number): number[] {
+  for (let i = 0; i < nums.length; i++) {
+    const j = target - nums[i];
+    const index = nums.indexOf(j);
+
+    if (index !== -1 && i !== index) {
+      return [i, index];
+    }
+  }
+  return [];
+};
+
+// 3번째 풀이 (HashMap)
+function twoSum3(nums: number[], target: number): number[] {
+  const map: Record<number, number> = {};
+
+  for (let i = 0; i < nums.length; i++) {
+    const complement = target - nums[i];
+
+    if (complement in map) {
+      const j = map[complement];
+      return [i, j];
+    } else {
+      map[nums[i]] = i;
+    }
+  }
+
+  return [];
+};