Merge pull request #1136 from seungseung88/main

[seungseung88] WEEK 01 solutions

Author: seungseung88

contains-duplicate/seungseung88.js

@@ -0,0 +1,21 @@
+// 시간 복잡도: O(n) => 배열을 한 번만 순회하므로
+// 공간 복잡도: O(n) => 최악의 경우 모든 요소를 객체에 저장하므로
+const containsDuplicate = (nums) => {
+  const indices = {};
+
+  // 배열을 한 번 순회
+  for (let i = 0; i < nums.length; i += 1) {
+    const num = nums[i];
+
+    // 아직 등장하지 않은 숫자라면 객체에 기록
+    if (!indices[num]) {
+      indices[num] = 1;
+    } else {
+      // 이미 등장한 숫자라면 중복이므로 true 반환
+      return true;
+    }
+  }
+
+  // 중복이 없으면 false 반환
+  return false;
+};

house-robber/seungseung88.js

@@ -0,0 +1,18 @@
+// 시간 복잡도: O(n) 한 번의 루프만 돎
+// 공간 복잡도: O(n) nums와 같은 길이의 dp배열 생성
+
+const rob = (nums) => {
+  if (nums.length === 0) return 0;
+  if (nums.length === 1) return nums[0];
+
+  const dp = Array(nums.length - 1).fill(0);
+
+  dp[0] = nums[0];
+  dp[1] = Math.max(nums[0], nums[1]);
+
+  for (let i = 2; i < nums.length; i += 1) {
+    dp[i] = Math.max(nums[i] + dp[i - 2], dp[i - 1]);
+  }
+
+  return dp[nums.length - 1];
+};

longest-consecutive-sequence/seungseung88.js

@@ -0,0 +1,30 @@
+/**
+ * 시간복잡도: O(n)
+ *    - set.has() => O(1)
+ *    - while() => 최악의 경우 O(n)
+ * 공간복잡도: new Set() => O(n)
+ */
+const longestConsecutive = (nums) => {
+  // 빈 배열일 때 0 리턴
+  if (nums.length === 0) return 0;
+
+  // 중복 제거
+  const set = new Set(nums);
+
+  // 연속되는 숫자의 길이를 넣을 변수 설정
+  let longest = 0;
+
+  set.forEach((v) => {
+    // 일단 연속되는 배열에서는 가장 최솟값을 찾음
+    if (!set.has(v - 1)) {
+      let cnt = 1;
+      // 연속되는 배열에서 가장 긴 배열을 저장
+      while (set.has(v + cnt)) {
+        cnt += 1;
+      }
+      longest = Math.max(longest, cnt);
+    }
+  });
+
+  return longest;
+};

top-k-frequent-elements/seungseung88.js

@@ -0,0 +1,46 @@
+/**
+ * 시간 복잡도: O(n)
+ * - nums 순회하며 map 생성 O(n)
+ * - map 순회하며 bucket 생성 O(n)
+ * - bucket 순회하며 결과 찾음 O(n)
+ *
+ * 공간 복잡도: O(n)
+ * - map O(n)
+ * - bucket O(n)
+ * - result k
+ */
+const topKFrequent = (nums, k) => {
+  // nums 요소 : 요소의 갯수
+  const map = {};
+  // 요소의 갯수 : Set{ nums 요소 }
+  const bucket = [];
+
+  const result = [];
+
+  for (let i = 0; i < nums.length; i += 1) {
+    if (map[nums[i]]) {
+      map[nums[i]] += 1;
+    } else {
+      map[nums[i]] = 1;
+    }
+  }
+
+  for (let [num, freq] of Object.entries(map)) {
+    if (bucket[freq]) {
+      bucket[freq] = bucket[freq].add(num);
+    } else {
+      bucket[freq] = new Set().add(num);
+    }
+  }
+
+  for (let i = bucket.length - 1; i >= 0; i -= 1) {
+    if (bucket[i]) {
+      // string을 number로 변환
+      const value = Array.from(bucket[i], Number);
+      result.push(...value);
+    }
+    if (result.length === k) break;
+  }
+
+  return result;
+};

two-sum/seungseung88.js

@@ -0,0 +1,21 @@
+// 배열을 한 번 도니 시간 복잡도 O(n)
+// 최악의 경우 nums의 크기 배열만큼 증가하므로 공간 복잡도는 O(n)
+
+const twoSum = (nums, target) => {
+  // {값: 인덱스} 형태로 저장
+  const indicies = {};
+
+  for (let i = 0; i < nums.length; i += 1) {
+    // 타겟값에서 현재 가리키는 숫자를 뺀 값을 저장
+    const complement = target - nums[i];
+
+    // complement가 indicies안에 존재하면 해당 값을 반환
+    if (complement in indicies) {
+      const j = indicies[complement];
+      return [j, i];
+    }
+    // 존재 하지 않으면 값과 인덱스 형태로 저장 ex> { 11: 0, 15: 1, 2: 2 }
+    indicies[nums[i]] = i;
+    console.log(indicies);
+  }
+};