From 1912b258de10e952cf7601060398ecb0c245b023 Mon Sep 17 00:00:00 2001
From: seongmin36 <whtjdals3625@gmail.com>
Date: Tue, 23 Jun 2026 17:33:01 +0900
Subject: [PATCH 1/9] contains duplicate solution

---
 contains-duplicate/seongmin36.js | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 contains-duplicate/seongmin36.js

diff --git a/contains-duplicate/seongmin36.js b/contains-duplicate/seongmin36.js
new file mode 100644
index 0000000000..83ec7d55ea
--- /dev/null
+++ b/contains-duplicate/seongmin36.js
@@ -0,0 +1,10 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+function containsDuplicate(nums) {
+  let set_nums = new Set(nums);
+
+  if (set_nums.size !== nums.length) return true;
+  else return false;
+}

From b9fcfd46c148270f1bf31e49016d1d7e24617be7 Mon Sep 17 00:00:00 2001
From: seongmin36 <whtjdals3625@gmail.com>
Date: Wed, 24 Jun 2026 03:45:12 +0900
Subject: [PATCH 2/9] two sum solution

---
 two-sum/seongmin36.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 two-sum/seongmin36.js

diff --git a/two-sum/seongmin36.js b/two-sum/seongmin36.js
new file mode 100644
index 0000000000..899d41380e
--- /dev/null
+++ b/two-sum/seongmin36.js
@@ -0,0 +1,25 @@
+/**
+map을 사용해서 구하려고 하는 값(인덱스)을 value로 둔다. → {value: index} 역전
+map에 {value: index}를 반복하여 저장한다.
+in 연산자로 find_num이 map의 key와 일치하는지 비교한다.
+ */
+
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+function twoSum(nums, target) {
+  let map = {};
+  let find_num = 0;
+
+  for (let i = 0; i < nums.length; i++) {
+    find_num = target - nums[i];
+
+    if (find_num in map) {
+      return [map[find_num], i];
+    }
+
+    map[nums[i]] = i;
+  }
+}

From 10ff2eea4e83bdc8425fcc84197b4ca0d5b34361 Mon Sep 17 00:00:00 2001
From: seongmin36 <whtjdals3625@gmail.com>
Date: Wed, 24 Jun 2026 20:42:47 +0900
Subject: [PATCH 3/9] Top K Frequent Elements solution

---
 top-k-frequent-elements/seongmin36.js | 44 +++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 top-k-frequent-elements/seongmin36.js

diff --git a/top-k-frequent-elements/seongmin36.js b/top-k-frequent-elements/seongmin36.js
new file mode 100644
index 0000000000..5c07d934f9
--- /dev/null
+++ b/top-k-frequent-elements/seongmin36.js
@@ -0,0 +1,44 @@
+/**
+reduce()를 사용하여 배열에서 각 원소의 빈도수를 구한다.
+"버킷 정렬"을 사용한 풀이: 원본 배열의 N+1개의 빈 배열을 생성해서 오름차순으로 원소의 빈도수를 넣는다.
+- 장점: 시간복잡도가 빠름 O(N)
+- 단점: 케이스에 따라 빈 메모리가 많이 소모됨
+버킷에서 뒤 원소(빈도수가 많은)부터 하나씩 배열에 넣는다.
+
+문제: Example 3 빈도수가 동일한 경우는 bucket의 원소가 "[1, 2]"로 출력됨.
+원인: 이를 1개의 원소로 보았고, length === k 조건에 맞지 않음 → undefined
++ 기존 bucket[i] > 0의 비교는 number일때만 가능하기 때문에 push도 되지않음.
+
+해결: bucket[i].length > 0 길이로 비교, slice + map처리로 [1, 2] 예외 케이스 해결
+ */
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+function topKFrequent(nums, k) {
+  let result = [];
+
+  let frequency = nums.reduce((acc, count) => {
+    acc[count] = (acc[count] || 0) + 1;
+    return acc;
+  }, {});
+
+  let bucket = Array.from({ length: nums.length + 1 }, () => []);
+
+  for (const [num, count] of Object.entries(frequency)) {
+    bucket[count].push(Number(num));
+  }
+
+  for (let i = bucket.length - 1; i >= 0; i--) {
+    if (bucket[i].length > 0) {
+      result.push(...bucket[i]);
+    }
+
+    if (result.length === k) {
+      return result.slice(0, k).map(Number);
+    }
+    result.slice(0, k);
+  }
+}

From 2aa8722993fee29a60ec6e7e978ff7ae41c39d0e Mon Sep 17 00:00:00 2001
From: seongmin36 <whtjdals3625@gmail.com>
Date: Fri, 26 Jun 2026 02:48:58 +0900
Subject: [PATCH 4/9] longest consecutive sequence solution

---
 longest-consecutive-sequence/seongmin36.js | 25 ++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 longest-consecutive-sequence/seongmin36.js

diff --git a/longest-consecutive-sequence/seongmin36.js b/longest-consecutive-sequence/seongmin36.js
new file mode 100644
index 0000000000..45d716e8d1
--- /dev/null
+++ b/longest-consecutive-sequence/seongmin36.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+function longestConsecutive(nums) {
+  let set_nums = new Set(nums);
+  let max_seq = 0;
+
+  if (set_nums.size === 0) return 0;
+
+  for (let num of set_nums) {
+    // num-1이 없는 경우 num이 시작 수
+    if (!set_nums.has(num - 1)) {
+      let curNum = num;
+      let seq = 1; // 시작점이 된 순간 seq=1
+
+      while (set_nums.has(curNum + 1)) {
+        curNum += 1;
+        seq += 1;
+      }
+      max_seq = Math.max(max_seq, seq);
+    }
+  }
+  return max_seq;
+}

From 40d849647b4922fe00fe76220b9e0b0ec1042c7c Mon Sep 17 00:00:00 2001
From: seongmin36 <whtjdals3625@gmail.com>
Date: Fri, 26 Jun 2026 16:14:53 +0900
Subject: [PATCH 5/9] house robber solution

---
 house-robber/seongmin36.js | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 house-robber/seongmin36.js

diff --git a/house-robber/seongmin36.js b/house-robber/seongmin36.js
new file mode 100644
index 0000000000..c86851cee0
--- /dev/null
+++ b/house-robber/seongmin36.js
@@ -0,0 +1,35 @@
+/**
+문제에서 중요한 것은 '비교를 어디서 어떻게 두나'였다.
+[0]번 인덱스에서 시작하거나 [1]번에서 시작하는 두 가지 방식이 있다.
+[0]번과 [1]번 각각의 케이스에서 누적된 합을 저장하고 비교한다.
+이 값들은 전부 arr 배열의 인덱스에 저장된다.
+배열의 원소들이 갖는 의미는 원본 배열 nums의 원소들과 arr 배열의 누적된 값의 합 중 큰 값이다.
+이렇게 설계한 경우에 마지막 인덱스 or 마지막 인덱스 -1의 값 중 큰 수인 max number가 반환된다.
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+
+function rob(nums) {
+  switch (nums.length) {
+    case 0:
+      return 0;
+    case 1:
+      return nums[0];
+    case 2:
+      return Math.max(nums[0], nums[1]);
+  }
+
+  let arr = [];
+  arr[0] = nums[0];
+  arr[1] = nums[1];
+  arr[2] = nums[0] + nums[2];
+
+  for (let i = 3; i < nums.length; i++) {
+    arr[i] = nums[i] + Math.max(arr[i - 2], arr[i - 3]);
+  }
+
+  return Math.max(arr[arr.length - 1], arr[arr.length - 2]);
+}

From 29dfd9178853938f1662864d1e1fc222eee0bf14 Mon Sep 17 00:00:00 2001
From: seongmin36 <whtjdals3625@gmail.com>
Date: Fri, 26 Jun 2026 21:10:04 +0900
Subject: [PATCH 6/9] apply feedback from code review

---
 contains-duplicate/seongmin36.js      | 3 +--
 house-robber/seongmin36.js            | 2 --
 top-k-frequent-elements/seongmin36.js | 6 +-----
 3 files changed, 2 insertions(+), 9 deletions(-)

diff --git a/contains-duplicate/seongmin36.js b/contains-duplicate/seongmin36.js
index 83ec7d55ea..ca15173897 100644
--- a/contains-duplicate/seongmin36.js
+++ b/contains-duplicate/seongmin36.js
@@ -5,6 +5,5 @@
 function containsDuplicate(nums) {
   let set_nums = new Set(nums);
 
-  if (set_nums.size !== nums.length) return true;
-  else return false;
+  return set_nums.size !== nums.length;
 }
diff --git a/house-robber/seongmin36.js b/house-robber/seongmin36.js
index c86851cee0..2ad2d4ae45 100644
--- a/house-robber/seongmin36.js
+++ b/house-robber/seongmin36.js
@@ -14,8 +14,6 @@
 
 function rob(nums) {
   switch (nums.length) {
-    case 0:
-      return 0;
     case 1:
       return nums[0];
     case 2:
diff --git a/top-k-frequent-elements/seongmin36.js b/top-k-frequent-elements/seongmin36.js
index 5c07d934f9..843ebda4b7 100644
--- a/top-k-frequent-elements/seongmin36.js
+++ b/top-k-frequent-elements/seongmin36.js
@@ -35,10 +35,6 @@ function topKFrequent(nums, k) {
     if (bucket[i].length > 0) {
       result.push(...bucket[i]);
     }
-
-    if (result.length === k) {
-      return result.slice(0, k).map(Number);
-    }
-    result.slice(0, k);
   }
+  return result.slice(0, k);
 }

From 96f2e5f854849cf73ee7a8899a81fcf8df457bfe Mon Sep 17 00:00:00 2001
From: seongmin36 <whtjdals3625@gmail.com>
Date: Mon, 29 Jun 2026 23:51:36 +0900
Subject: [PATCH 7/9] valid anagram solution

---
 valid-anagram/seongmin36.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 valid-anagram/seongmin36.js

diff --git a/valid-anagram/seongmin36.js b/valid-anagram/seongmin36.js
new file mode 100644
index 0000000000..df5a413865
--- /dev/null
+++ b/valid-anagram/seongmin36.js
@@ -0,0 +1,31 @@
+/**
+결국 같아야 것은 string의 길이와 안에 들어간 각 character의 갯수다.
+즉, s와 t의 문자의 갯수와 같으면 된다.
+map을 사용하여 key와 value자리에 각각 문자, 갯수를 받는다.
+s와 t를 비교하며 해당하는 문자 갯수-1을 한다.
+각 key의 value를 문제없이 차감했다면 true를 반환. 그 외 false를 반환
+ */
+
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+function isAnagram(s, t) {
+  if (s.length !== t.length) return false;
+
+  let map_s = new Map();
+
+  for (let char of s) {
+    map_s.set(char, (map_s.get(char) || 0) + 1);
+  }
+
+  for (let char of t) {
+    if (!map_s.has(char) || map_s.get(char) === 0) {
+      return false;
+    }
+    map_s.set(char, map_s.get(char) - 1);
+  }
+
+  return true;
+}

From 508b33da1f2780570d8bd8bdb4d37b762b419e1a Mon Sep 17 00:00:00 2001
From: seongmin36 <whtjdals3625@gmail.com>
Date: Tue, 30 Jun 2026 00:26:30 +0900
Subject: [PATCH 8/9] climbing stairs solution

---
 climbing-stairs/seongmin36.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 climbing-stairs/seongmin36.js

diff --git a/climbing-stairs/seongmin36.js b/climbing-stairs/seongmin36.js
new file mode 100644
index 0000000000..f103769dec
--- /dev/null
+++ b/climbing-stairs/seongmin36.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+function climbStairs(n) {
+  if (n <= 2) return n;
+
+  let arr = new Array(n + 1);
+
+  arr[0] = 1;
+  arr[1] = 2;
+
+  for (let i = 2; i < arr.length; i++) {
+    arr[i] = arr[i - 2] + arr[i - 1];
+  }
+
+  return arr[n - 1];
+}

From c02aae17bf459fe219d7ce54c0338008c6d2a4fb Mon Sep 17 00:00:00 2001
From: seongmin36 <whtjdals3625@gmail.com>
Date: Tue, 30 Jun 2026 02:17:28 +0900
Subject: [PATCH 9/9] product of array except self solution

---
 product-of-array-except-self/seongmin36.js | 34 ++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 product-of-array-except-self/seongmin36.js

diff --git a/product-of-array-except-self/seongmin36.js b/product-of-array-except-self/seongmin36.js
new file mode 100644
index 0000000000..0f14d69033
--- /dev/null
+++ b/product-of-array-except-self/seongmin36.js
@@ -0,0 +1,34 @@
+/**
+문제의 핵심은 '어떻게 인덱스와 곱을 이중 반복문을 쓰지 않고 해결하느냐'다. 'Goal' → 시간 복잡도 : O(N)
+여기서 사용된 개념: 'Two Pointer'
+Two Pointer? → '배열에서 순차적으로 접근해야 할 때 두 개의 점의 위치를 기록하면서 처리하는 알고리즘'
+이중 반복을 사용하지 않고, 각 인덱스를 순회하면서 answer[index]에 본인을 제외한 곱셈을 중첩시킨다.
+본인을 제외한 나머지 원소의 곱이기 때문에 left와 right로 나눠서 중첩된 곱셈을 다시 곱한다.
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+function productExceptSelf(nums) {
+  let answer = new Array(nums.length).fill(1);
+
+  let left = 0;
+  let right = nums.length - 1;
+
+  let mul_left = 1;
+  let mul_right = 1;
+
+  while (left < nums.length && right >= 0) {
+    answer[left] *= mul_left;
+    mul_left *= nums[left]; // 자기 자신 제외 곱
+
+    answer[right] *= mul_right;
+    mul_right *= nums[right];
+
+    left++;
+    right--;
+  }
+
+  return answer;
+}