From f3b1606f997dbd9c921fb67baa756fb3e353b262 Mon Sep 17 00:00:00 2001
From: grapefruitgreentealoe
 <76976331+grapefruitgreentealoe@users.noreply.github.com>
Date: Sun, 6 Apr 2025 12:53:20 +0900
Subject: [PATCH 01/15] chore: 2week start

---
 valid-anagram/grapefruitgreentealoe.js | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 valid-anagram/grapefruitgreentealoe.js

diff --git a/valid-anagram/grapefruitgreentealoe.js b/valid-anagram/grapefruitgreentealoe.js
new file mode 100644
index 000000000..e69de29bb

From 905230d6857ccef27dbc772613f4fb82713a1bde Mon Sep 17 00:00:00 2001
From: grapefruitgreentealoe
 <76976331+grapefruitgreentealoe@users.noreply.github.com>
Date: Sun, 20 Jul 2025 16:21:52 +0900
Subject: [PATCH 02/15] feat: longest-consecutive-sequence

---
 .../grapefruitgreentealoe.js                  | 103 +++++++++++++++---
 1 file changed, 86 insertions(+), 17 deletions(-)

diff --git a/longest-consecutive-sequence/grapefruitgreentealoe.js b/longest-consecutive-sequence/grapefruitgreentealoe.js
index 7b142a0ee..cc851993b 100644
--- a/longest-consecutive-sequence/grapefruitgreentealoe.js
+++ b/longest-consecutive-sequence/grapefruitgreentealoe.js
@@ -1,30 +1,99 @@
+
 /**
  * 정수 배열 nums
  * 가장 많이 연속되는 요소의 길이 리턴.
  * O(n) 시간안에 돌아가는 알고리즘 사용할것.
  */
+/*우선 처음 푼 방법은*/
+
+var longestConsecutive = function(nums) {
+    let maxCount = 0;
+    nums = [...nums].sort((a,b)=>a-b);
+    for(let i = 0;i < nums.length;i++){
+        let current = nums[i];
+        let count = 1;
+        for(let j = i+1;j<nums.length;j++){
+            if(current+1 == nums[j]){
+                current = nums[j]
+                count +=1;
+            }else if(current == nums[j]){
+                continue;
+            }
+        }
+        maxCount = Math.max(maxCount,count)
+        count = 1;
+    }
+    return maxCount
+};
+
+
+/*시간복잡도:
+2중for문+sort
+n^2 + nlogn => n^2.
+공간복잡도:
+nums는 초기화했고,
+기타 변수들만 사용을 했다(maxCount,current,count)=> O(1)
+
+하지만 이문제는 O(n)의 시간복잡도를 가져가야한다.
+그러려면 sort도 하지말아야하고, 2중for문을 쓰지도 말아야한다.
+(생각해보니 내가 사용한 방법을 인덱스+1해서 해결해도 되긴한다. 그래도 정렬때문에 nlogn이 된다.)
+
+두번째 방법으로는,set을 사용해서 중복을 제거하는 방법이다.
+*/
+
 /**
  * @param {number[]} nums
  * @return {number}
  */
-var longestConsecutive = function (nums) {
-  const numSet = new Set(nums);
-  let maxCount = 0;
-  for (let i of numSet) {
-    //n 번 순회
-    // ++ 이전에 연속체크가 되었을 수 있으므로, 이전 숫자가 존재한다면 pass
-    if (numSet.has(i - 1)) continue; //이미 진행 된 연속체크의 경우 하지 않는다.
-    //연속이 되는지 확인해서 있으면 1추가.
-    let length = 0;
-    while (numSet.has(i + length)) {
-      //연속이 끊기는 순간 멈추는 반복문. 즉 for문 전체 통틀어 최대 n번 실행.
-      length++;
+var longestConsecutive = function(nums) {
+    if(nums.length == 0) return 0
+    let maxCount = 1;
+    nums.sort((a,b)=>a-b);
+    nums = [...new Set(nums)];
+    let count = 1;
+    for (let i = 0; i < nums.length - 1; i++) {
+        if (nums[i] + 1 === nums[i + 1]) {
+            count += 1;
+        } else if (nums[i] === nums[i + 1]) {
+            // 중복일 경우 아무것도 안 하고 넘어감
+            continue;
+        } else {
+            maxCount = Math.max(maxCount, count);
+            count = 1;
+        }
     }
-    maxCount = Math.max(length, maxCount);
-  }
-  return maxCount;
+    maxCount = Math.max(maxCount, count); // 마지막에도 비교 필요
+
+    return maxCount
 };
+/*sort할때 시간복잡도가 nlog(n)인데 왜 통과했지.. 빅오 계산법이 최악의 경우를 계산한거라, 운좋게 통과한 것 같다.
+좀 더 최적화 해보자
+*/
 
-//시간복잡도 O(n) + O(n) = O(n) /공간복잡도 O(n)
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestConsecutive = function(nums) {
+    const numsSet = new Set(nums);
+    let maxCount = 0;
+    for(let num of numsSet){
+        //중복된 계산 패스
+        if(numsSet.has(num-1)) continue;
+        let length = 1;
+        while(numsSet.has(num+length)){
+            length++
+        }
+        maxCount = Math.max(maxCount,length)
+    }
+    return maxCount
+};
 
-//생각할 지점. 양쪽으로 진행된다면, 시간복잡도 최적화 가능
+/*
+set을 이용해서 중복을 제거
+set의 has메소드를 활용하여 조회 최적화
+while을 썼지만, for문의 첫번째 if문을 통해 실제 수행은 O(n)의 시간복잡도를 가짐.
+이 외에도, set으로 만든 다음에 삭제해가면서(while) 순회가 아닌, 왼쪽 오른쪽값들을 연속적으로(while) 지우고, 연속이 끝나면 pop에서 나온 값의 left right를 조회해서 없으면 다시 최대값과 비교하는 방식이 있다.
+근데 위의 코드에서 has로 조회하나, remove를 하려면 어차피 또 조회해야하니,
+성능상의 차이는 크게 없는 것 같다.
+*/
\ No newline at end of file

From ffa5dc36e45a01753d2895ff18dc1c2b90f474ef Mon Sep 17 00:00:00 2001
From: grapefruitgreentealoe
 <76976331+grapefruitgreentealoe@users.noreply.github.com>
Date: Sun, 20 Jul 2025 16:32:26 +0900
Subject: [PATCH 03/15] =?UTF-8?q?chore:=20=EC=A4=84=EB=B0=94=EA=BF=88=20?=
 =?UTF-8?q?=EC=B6=94=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 longest-consecutive-sequence/grapefruitgreentealoe.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/longest-consecutive-sequence/grapefruitgreentealoe.js b/longest-consecutive-sequence/grapefruitgreentealoe.js
index cc851993b..22d2dd9a5 100644
--- a/longest-consecutive-sequence/grapefruitgreentealoe.js
+++ b/longest-consecutive-sequence/grapefruitgreentealoe.js
@@ -96,4 +96,4 @@ while을 썼지만, for문의 첫번째 if문을 통해 실제 수행은 O(n)의
 이 외에도, set으로 만든 다음에 삭제해가면서(while) 순회가 아닌, 왼쪽 오른쪽값들을 연속적으로(while) 지우고, 연속이 끝나면 pop에서 나온 값의 left right를 조회해서 없으면 다시 최대값과 비교하는 방식이 있다.
 근데 위의 코드에서 has로 조회하나, remove를 하려면 어차피 또 조회해야하니,
 성능상의 차이는 크게 없는 것 같다.
-*/
\ No newline at end of file
+*/

From f20f1ffa5c73fb7f6b22795e6c5326d10878238b Mon Sep 17 00:00:00 2001
From: grapefruitgreentealoe
 <76976331+grapefruitgreentealoe@users.noreply.github.com>
Date: Mon, 21 Jul 2025 11:54:03 +0900
Subject: [PATCH 04/15] =?UTF-8?q?feat:=20house-robber=20=ED=92=80=EC=9D=B4?=
 =?UTF-8?q?=20=EC=B6=94=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 house-robber/grapefruitgreentealoe.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/house-robber/grapefruitgreentealoe.js b/house-robber/grapefruitgreentealoe.js
index fd7148257..6748f9f76 100644
--- a/house-robber/grapefruitgreentealoe.js
+++ b/house-robber/grapefruitgreentealoe.js
@@ -43,3 +43,23 @@ var rob2 = function (nums) {
 };
 //공간복잡도를 O(1)로 개선
 
+
+//7.21 풀이시간 10분 소요
+
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function(nums) {
+    const dp = new Array(nums.length+1).fill(0);
+    dp[1] = nums[0]
+    for(let i = 2; i<=nums.length;i++){
+        dp[i] = Math.max(dp[i-1],dp[i-2]+nums[i-1])
+    }
+    return dp[nums.length]
+};
+/**
+시간복잡도 : O(n)
+공간복잡도 : O(n)
+ */
\ No newline at end of file

From 55acc8dc446464d92b0e2ab6abaa79b11b942224 Mon Sep 17 00:00:00 2001
From: grapefruitgreentealoe
 <76976331+grapefruitgreentealoe@users.noreply.github.com>
Date: Mon, 21 Jul 2025 12:11:01 +0900
Subject: [PATCH 05/15] =?UTF-8?q?fix:=20=EA=B0=9C=ED=96=89=20=EC=B6=94?=
 =?UTF-8?q?=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 house-robber/grapefruitgreentealoe.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/house-robber/grapefruitgreentealoe.js b/house-robber/grapefruitgreentealoe.js
index 6748f9f76..45d91d0df 100644
--- a/house-robber/grapefruitgreentealoe.js
+++ b/house-robber/grapefruitgreentealoe.js
@@ -62,4 +62,4 @@ var rob = function(nums) {
 /**
 시간복잡도 : O(n)
 공간복잡도 : O(n)
- */
\ No newline at end of file
+ */

From b287334b59352049c180a3d12ee07431449abf66 Mon Sep 17 00:00:00 2001
From: grapefruitgreentealoe
 <76976331+grapefruitgreentealoe@users.noreply.github.com>
Date: Mon, 21 Jul 2025 14:25:22 +0900
Subject: [PATCH 06/15] =?UTF-8?q?chore:=20=EB=B9=88=20=ED=8C=8C=EC=9D=BC?=
 =?UTF-8?q?=20=EC=82=AD=EC=A0=9C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 valid-anagram/grapefruitgreentealoe.js | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 valid-anagram/grapefruitgreentealoe.js

diff --git a/valid-anagram/grapefruitgreentealoe.js b/valid-anagram/grapefruitgreentealoe.js
deleted file mode 100644
index e69de29bb..000000000

From 48c07375c5ba8361395b3b8d6a83cfccee7f149c Mon Sep 17 00:00:00 2001
From: grapefruitgreentealoe
 <76976331+grapefruitgreentealoe@users.noreply.github.com>
Date: Tue, 22 Jul 2025 10:20:17 +0900
Subject: [PATCH 07/15] =?UTF-8?q?feat:=20top=20k=20frequent=20=EB=AC=B8?=
 =?UTF-8?q?=EC=A0=9C=20=ED=92=80=EC=9D=B4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../grapefruitgreentealoe.js                  | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/top-k-frequent-elements/grapefruitgreentealoe.js b/top-k-frequent-elements/grapefruitgreentealoe.js
index 29981ee40..0861c5c24 100644
--- a/top-k-frequent-elements/grapefruitgreentealoe.js
+++ b/top-k-frequent-elements/grapefruitgreentealoe.js
@@ -27,3 +27,31 @@ var topKFrequent = function (nums, k) {
 };
 
 //O(n) + O(n log n) + O(n) + O(k) = O(n log n)
+
+
+//7.22 소요시간 10분
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var topKFrequent = function(nums, k) {
+    //우선은, Map으로 만들어서 숫자 각각에 대한 개수를 구한다. 
+    const numsMap  = new Map();
+    for(let num of nums){
+        if(numsMap.has(num)){
+            numsMap.set(num,numsMap.get(num)+1)
+        }else{
+            numsMap.set(num,1)
+        }
+    }
+    //그런다음 Map에 대해서, 가장 큰 값을 가진 순으로 정렬을 한다. 
+    const ret = [...numsMap].sort((a,b)=>b[1]-a[1]).slice(0,k).map(x=>x[0]);
+    return ret
+};
+
+// 이전 답과 비슷하지만, for문 처리에 대해서, 조금 풀어서 작성을 하게 된거같다.
+// 시간복잡도와 공간복잡도는 위의 코드와 같다. 
+
+// 시간 복잡도 : for문 - O(n) , sort O(nlogn)
+// 공간 복잡도 : O(n)
\ No newline at end of file

From 42e8b8c4484914ebaa3992260ff963aa84f9490e Mon Sep 17 00:00:00 2001
From: grapefruitgreentealoe
 <76976331+grapefruitgreentealoe@users.noreply.github.com>
Date: Tue, 22 Jul 2025 10:20:27 +0900
Subject: [PATCH 08/15] =?UTF-8?q?fix:=20=EA=B0=9C=ED=96=89=20=EC=B6=94?=
 =?UTF-8?q?=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 top-k-frequent-elements/grapefruitgreentealoe.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/top-k-frequent-elements/grapefruitgreentealoe.js b/top-k-frequent-elements/grapefruitgreentealoe.js
index 0861c5c24..26464ade4 100644
--- a/top-k-frequent-elements/grapefruitgreentealoe.js
+++ b/top-k-frequent-elements/grapefruitgreentealoe.js
@@ -54,4 +54,4 @@ var topKFrequent = function(nums, k) {
 // 시간복잡도와 공간복잡도는 위의 코드와 같다. 
 
 // 시간 복잡도 : for문 - O(n) , sort O(nlogn)
-// 공간 복잡도 : O(n)
\ No newline at end of file
+// 공간 복잡도 : O(n)

From 8b9e06929765ca79d3ff1ff1a9becdcc76717ddf Mon Sep 17 00:00:00 2001
From: grapefruitgreentealoe
 <76976331+grapefruitgreentealoe@users.noreply.github.com>
Date: Tue, 22 Jul 2025 10:20:28 +0900
Subject: [PATCH 09/15] =?UTF-8?q?fix:=20=EA=B0=9C=ED=96=89=20=EC=B6=94?=
 =?UTF-8?q?=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit


From e1fd38780261d5eb8fca7c9583219451b098e979 Mon Sep 17 00:00:00 2001
From: grapefruitgreentealoe
 <76976331+grapefruitgreentealoe@users.noreply.github.com>
Date: Wed, 23 Jul 2025 13:11:16 +0900
Subject: [PATCH 10/15] =?UTF-8?q?feat:=20contains-duplicate=20=ED=92=80?=
 =?UTF-8?q?=EC=9D=B4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 contains-duplicate/grapefruitgreentealoe.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/contains-duplicate/grapefruitgreentealoe.js b/contains-duplicate/grapefruitgreentealoe.js
index 2bd26ce0a..bc43b1400 100644
--- a/contains-duplicate/grapefruitgreentealoe.js
+++ b/contains-duplicate/grapefruitgreentealoe.js
@@ -24,3 +24,24 @@ var containsDuplicate = function (nums) {
   }
   return false;
 };
+
+//25.7.23 풀이시간 10분
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function(nums) {
+    //두번 이상 나타나는게 있으면 바로 리턴하시오. 
+    //이중 순회하게 되면 시간 초과할 예정.
+    //시간복잡도 중요. 
+    //1. 저장하는 배열을 만들고, 그 배열에 값이 있으면 리턴 false. 
+    //2.배열보다 Set을 사용한,삽입 및 조회 속도 최적화 활용하기. 
+    const container = new Set();
+    for(let i =0; i<nums.length;i++){
+        if(container.has(nums[i])) return true;
+        else(container.add(nums[i]))
+    }
+    return false
+};
+
+//위의 코드보다, 리턴을 더 빨리한다는 이점이 있다.
\ No newline at end of file

From 7c3200f35d0df32fc73206acd228f016a1e62417 Mon Sep 17 00:00:00 2001
From: grapefruitgreentealoe
 <76976331+grapefruitgreentealoe@users.noreply.github.com>
Date: Wed, 23 Jul 2025 13:12:23 +0900
Subject: [PATCH 11/15] =?UTF-8?q?fix:=20=EB=AC=B8=EB=B2=95=20=EC=98=A4?=
 =?UTF-8?q?=EB=A5=98=20=EC=88=98=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 contains-duplicate/grapefruitgreentealoe.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/contains-duplicate/grapefruitgreentealoe.js b/contains-duplicate/grapefruitgreentealoe.js
index bc43b1400..2808b50a6 100644
--- a/contains-duplicate/grapefruitgreentealoe.js
+++ b/contains-duplicate/grapefruitgreentealoe.js
@@ -39,9 +39,8 @@ var containsDuplicate = function(nums) {
     const container = new Set();
     for(let i =0; i<nums.length;i++){
         if(container.has(nums[i])) return true;
-        else(container.add(nums[i]))
+        else container.add(nums[i])
     }
     return false
 };
-
 //위의 코드보다, 리턴을 더 빨리한다는 이점이 있다.
\ No newline at end of file

From 0f414112660f576852d2376470a8f84ffbbd1e51 Mon Sep 17 00:00:00 2001
From: grapefruitgreentealoe
 <76976331+grapefruitgreentealoe@users.noreply.github.com>
Date: Wed, 23 Jul 2025 13:12:36 +0900
Subject: [PATCH 12/15] =?UTF-8?q?chore:=20=EA=B0=9C=ED=96=89=20=EC=B6=94?=
 =?UTF-8?q?=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 contains-duplicate/grapefruitgreentealoe.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contains-duplicate/grapefruitgreentealoe.js b/contains-duplicate/grapefruitgreentealoe.js
index 2808b50a6..7331c3e47 100644
--- a/contains-duplicate/grapefruitgreentealoe.js
+++ b/contains-duplicate/grapefruitgreentealoe.js
@@ -43,4 +43,4 @@ var containsDuplicate = function(nums) {
     }
     return false
 };
-//위의 코드보다, 리턴을 더 빨리한다는 이점이 있다.
\ No newline at end of file
+//위의 코드보다, 리턴을 더 빨리한다는 이점이 있다.

From 7673518edda725fe741f1a9c45b5947561b836e3 Mon Sep 17 00:00:00 2001
From: grapefruitgreentealoe
 <76976331+grapefruitgreentealoe@users.noreply.github.com>
Date: Thu, 24 Jul 2025 18:46:06 +0900
Subject: [PATCH 13/15] =?UTF-8?q?feat:two-sum=20=ED=92=80=EC=9D=B4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 two-sum/grapefruitgreentealoe.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/two-sum/grapefruitgreentealoe.js b/two-sum/grapefruitgreentealoe.js
index cce88588a..e0768809d 100644
--- a/two-sum/grapefruitgreentealoe.js
+++ b/two-sum/grapefruitgreentealoe.js
@@ -48,3 +48,30 @@ var twoSum3 = function (nums, target) {
     numMap.set(nums[i], i); // 공간 O(1)
   }
 };
+
+
+//25.7.24 
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function(nums, target) {
+    //우선 nums배열에서 target보다 큰것은 삭제한다. => 이것 또한 시간복잡도가 든다. 하지말자
+    //1. 투포인터 방식으로 접근한다. 
+    for(let i=0;i<nums.length-1;i++){
+        let total = nums[i]
+        for(let j=i+1;j<nums.length;j++){
+            if(total+nums[j] == target){
+                return [i,j]
+            }
+        }
+    }    
+};
+
+/**
+ * 시간복잡도: O(N^2)
+ * 공간복잡도: O(1)
+ */
+
+//투포인터로 다시 풀었지만, 이 문제의 핵심은 Map의 메소드를 활용하는것. 
\ No newline at end of file

From ae484a4d4e0f65b9af6703ef0270e1ee79a91794 Mon Sep 17 00:00:00 2001
From: grapefruitgreentealoe
 <76976331+grapefruitgreentealoe@users.noreply.github.com>
Date: Thu, 24 Jul 2025 21:57:25 +0900
Subject: [PATCH 14/15] =?UTF-8?q?fix:=20=EA=B0=9C=ED=96=89=EC=B6=94?=
 =?UTF-8?q?=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 two-sum/grapefruitgreentealoe.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/two-sum/grapefruitgreentealoe.js b/two-sum/grapefruitgreentealoe.js
index e0768809d..2cce122e2 100644
--- a/two-sum/grapefruitgreentealoe.js
+++ b/two-sum/grapefruitgreentealoe.js
@@ -74,4 +74,4 @@ var twoSum = function(nums, target) {
  * 공간복잡도: O(1)
  */
 
-//투포인터로 다시 풀었지만, 이 문제의 핵심은 Map의 메소드를 활용하는것. 
\ No newline at end of file
+//투포인터로 다시 풀었지만, 이 문제의 핵심은 Map의 메소드를 활용하는것. 

From c99a3cfc2048ff296bc90fe25153e36519c77d50 Mon Sep 17 00:00:00 2001
From: grapefruitgreentealoe
 <76976331+grapefruitgreentealoe@users.noreply.github.com>
Date: Fri, 25 Jul 2025 15:19:01 +0900
Subject: [PATCH 15/15] =?UTF-8?q?feat:=20=20two-sum=20map=20=EC=9C=BC?=
 =?UTF-8?q?=EB=A1=9C=20=ED=92=80=EC=9D=B4=20=EC=B6=94=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 two-sum/grapefruitgreentealoe.js | 25 ++++++++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/two-sum/grapefruitgreentealoe.js b/two-sum/grapefruitgreentealoe.js
index 2cce122e2..91206909b 100644
--- a/two-sum/grapefruitgreentealoe.js
+++ b/two-sum/grapefruitgreentealoe.js
@@ -74,4 +74,27 @@ var twoSum = function(nums, target) {
  * 공간복잡도: O(1)
  */
 
-//투포인터로 다시 풀었지만, 이 문제의 핵심은 Map의 메소드를 활용하는것. 
+/*
+투포인터로 다시 풀었지만, 이 문제의 핵심은 map 메소드를 활용해서, 조회를 빠르게 하는것.. 
+Map.get(key) : 	O(1) 평균	해시 테이블 기반이기 때문에, 키 조회가 상수 시간
+Array.includes(value)	: O(n)	배열 처음부터 끝까지 순차 탐색 (최악의 경우 전체 탐색)
+*/
+
+var twoSum = function(nums, target) {
+  //현재 nums에 대해서, subnums를 저장한다.
+  const subNumsMap = new Map(); 
+  for(let i = 0;i<nums.length;i++){
+    const subNum = target - nums[i];
+    if(subNumsMap.has(subNum)){
+      return [subNumsMap.get(subNum),i]
+    }
+    subNumsMap.set(nums[i],i)
+  }
+};
+//시간복잡도: O(n) , 공간복잡도 : O(n)
+
+/*
+Q. 여기서 의문. Map이좋냐 object가 좋냐?
+알고리즘용 해시맵 대용이라면 대부분 Map 추천
+Object는 JSON-like 데이터 보관용에 적합
+ */