[sukyoungshin] WEEK 01

contains-duplicate/suKyoung.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;
+}

longest-consecutive-sequence/suKyoung.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/suKyoung.ts

@@ -0,0 +1,105 @@
+// 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) => a[1] - b[1]);
+
+      if (heap.length > k) {
+        heap.shift();
+      }
+    }
+
+    return heap.map(([num]) => num);
+  }
+

two-sum/suKyoung.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 (nums.includes(j) && i !== index) {
+            return [i, index];
+        }
+    }
+    return [];
+};
+
+// 3번째 풀이 (HashMap)
+function twoSum(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 [];
+};