From 06f4278fb9d7a393d994cbf3c4cb1b843c5f3366 Mon Sep 17 00:00:00 2001 From: Suhyen Im Date: Sat, 26 Jul 2025 23:49:29 +0900 Subject: [PATCH 1/2] [suhyenim] WEEK01 solutions --- contains-duplicate/suhyenim.java | 65 +++++++++++++++++++++++++++ top-k-frequent-elements/suhyenim.java | 61 +++++++++++++++++++++++++ two-sum/suhyenim.java | 57 +++++++++++++++++++++++ 3 files changed, 183 insertions(+) create mode 100644 contains-duplicate/suhyenim.java create mode 100644 top-k-frequent-elements/suhyenim.java create mode 100644 two-sum/suhyenim.java diff --git a/contains-duplicate/suhyenim.java b/contains-duplicate/suhyenim.java new file mode 100644 index 000000000..30b98306a --- /dev/null +++ b/contains-duplicate/suhyenim.java @@ -0,0 +1,65 @@ +/* [5th/week01] 217. Contains Duplicate + +1. 문제 요약 +링크: https://leetcode.com/problems/contains-duplicate/ +배열에서 동일한 숫자가 2번 이상 존재하면 true 반환, 아니면 false 반환 + +2. 풀이 로직 +제출1: 반복문을 중첩으로 돌리면서, 동일한 값을 발견하면 바로 true 반환 +실패: Time Limit Exceeded 발생 +=> 시간 복잡도: O(n^2), 공간 복잡도: O(1) +class Solution { + public boolean containsDuplicate(int[] nums) { + for (int i = 0; i < nums.length; i++) { + for (int j = i + 1; j < nums.length; j++) { + if (nums[i] == nums[j]) { + return true; + } + } + } + return false; + } +} + +풀이2: 크기를 오름차순으로 정렬해서, 바로 옆 숫자랑 겹치는지 확인 +성공: Time: 21 ms (19.91%), Space: 56.4 MB (98.12%) +=> 시간 복잡도: O(nlog(n)), 공간 복잡도: O(1) +class Solution { + public boolean containsDuplicate(int[] nums) { + Arrays.sort(nums); + for (int i = 0; i < nums.length - 1; i++) + if (nums[i] == nums[i + 1]) return true; + return false; + } +} + +풀이3: 배열을 순회하면서 HashSet에 겹치는 숫자가 존재하면 true 반환, 아니라면 HashSet에 본(seen) 숫자로 추가 +성공: Time: 14 ms (61.51%), Space: 58.2 MB (61.9%) +=> 시간 복잡도: O(n), 공간 복잡도: O(n) +class Solution { + public boolean containsDuplicate(int[] nums) { + HashSet seen = new HashSet<>(); + for (int i = 0; i < nums.length; i++) { + if (seen.contains(nums[i])) return true; + seen.add(nums[i]); + } + return false; + } +} + +3. TIL +그리고 메모리가 충분하고 빠른 속도가 필요할 때, HashSet을 사용해볼 수 있다. +하지만 메모리가 여유롭지 않다면, HashSet을 사용하는 방식보다는 기존의 정렬을 사용하는 방식이 알맞을 수 있다. + +*/ + +import java.util.Arrays; + +class Solution { + public boolean containsDuplicate(int[] nums) { + Arrays.sort(nums); + for (int i = 0; i < nums.length - 1; i++) + if (nums[i] == nums[i + 1]) return true; + return false; + } +} diff --git a/top-k-frequent-elements/suhyenim.java b/top-k-frequent-elements/suhyenim.java new file mode 100644 index 000000000..a3dd04efd --- /dev/null +++ b/top-k-frequent-elements/suhyenim.java @@ -0,0 +1,61 @@ +/* [5th/week01] 347. Top K Frequent Elements + +1. 문제 요약 +링크: https://leetcode.com/problems/top-k-frequent-elements/description/ +가장 빈도가 높은 k개의 숫자를 배열로 반환 + +2. 풀이 로직 +풀이1: +성공: Time: 17 ms (12.72%), Space: 48.9 MB (34.62%) +=> 시간 복잡도: O(nlogn), 공간 복잡도: O(n) + +class Solution { + public int[] topKFrequent(int[] nums, int k) { + Map count = new HashMap<>(); + for(int n : nums) { + if(!count.containsKey(n)) { + count.put(n, 1); + } else { + count.put(n, count.get(n) + 1); + } + } + + List keys = new ArrayList<>(count.keySet()); + keys.sort((a, b) -> count.get(b) - count.get(a)); + + int[] answer = new int[k]; + for (int i = 0; i < k; i++){ + answer[i] = keys.get(i); + } + + return answer; + } +} + +3. TIL +value값 기준으로 key를 내림차순 정렬하는 방법: keys.sort((a, b) -> count.get(b) - count.get(a)); + +*/ + +class Solution { + public int[] topKFrequent(int[] nums, int k) { + Map count = new HashMap<>(); + for(int n : nums) { + if(!count.containsKey(n)) { + count.put(n, 1); + } else { + count.put(n, count.get(n) + 1); + } + } + + List keys = new ArrayList<>(count.keySet()); + keys.sort((a, b) -> count.get(b) - count.get(a)); + + int[] answer = new int[k]; + for (int i = 0; i < k; i++){ + answer[i] = keys.get(i); + } + + return answer; + } +} diff --git a/two-sum/suhyenim.java b/two-sum/suhyenim.java new file mode 100644 index 000000000..15b84fa26 --- /dev/null +++ b/two-sum/suhyenim.java @@ -0,0 +1,57 @@ +/* [5th/week01] 1. Two Sum + +1. 문제 요약 +링크: https://leetcode.com/problems/two-sum/description/ +배열 내 두 숫자의 합이 target이 되는 key들을 배열로 반환 +(특이점: 답은 반드시 하나만 존재) + +2. 풀이 로직 +제출1: 반복문을 중첩으로 돌리면서, 두 숫자의 합이 target일 때의 두 인덱스를 배열로 반환 +성공: Time: 45 ms (30.61%), Space: 44.9 MB (63.79%) +=> 시간 복잡도: O(n^2), 공간 복잡도: O(1) +class Solution { + public int[] twoSum(int[] nums, int target) { + for (int i = 0; i < nums.length - 1; i++) { + for (int j = i + 1; j < nums.length; j++) { + if (nums[i] + nums[j] == target) + return new int[]{i, j}; + } + } + return null; + } +} + +풀이2: target과의 차가 HashMap의 key들 중에 존재하면 두 인덱스를 배열로 반환, 아니라면 HashMap에 value-key쌍으로 추가 +성공: 2 ms (98.95%), Space: 45.1 MB (30.45%) +=> 시간 복잡도: O(n), 공간 복잡도: O(n) +class Solution { + public int[] twoSum(int[] nums, int target) { + Map indices = new HashMap<>(); + for (int i = 0; i < nums.length; i++) { + int complement = target - nums[i]; + if (indices.containsKey(complement)) { + int j = indices.get(complement); + return new int[]{j, i}; + } + indices.put(nums[i], i); + } + return null; + } +} + +3. TIL +HashTable을 활용해서 key-value 자료구조를 구현할 수 있다. + +*/ + +class Solution { + public int[] twoSum(int[] nums, int target) { + for (int i = 0; i < nums.length - 1; i++) { + for (int j = i + 1; j < nums.length; j++) { + if (nums[i] + nums[j] == target) + return new int[]{i, j}; + } + } + return null; + } +} From b8a21e0a5d2c03f49cfb29912c557c5dfc7d5f75 Mon Sep 17 00:00:00 2001 From: Suhyen Im Date: Sun, 27 Jul 2025 00:18:31 +0900 Subject: [PATCH 2/2] =?UTF-8?q?top-k-frequent-elements=20=ED=92=80?= =?UTF-8?q?=EC=9D=B4=20=EC=84=A4=EB=AA=85=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- top-k-frequent-elements/suhyenim.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/top-k-frequent-elements/suhyenim.java b/top-k-frequent-elements/suhyenim.java index a3dd04efd..f4d133831 100644 --- a/top-k-frequent-elements/suhyenim.java +++ b/top-k-frequent-elements/suhyenim.java @@ -5,7 +5,7 @@ 가장 빈도가 높은 k개의 숫자를 배열로 반환 2. 풀이 로직 -풀이1: +풀이1: 빈도 HashMap을 만들고 -> 높은 빈도 순으로 key 정렬 -> top k까지만 배열로 반환 성공: Time: 17 ms (12.72%), Space: 48.9 MB (34.62%) => 시간 복잡도: O(nlogn), 공간 복잡도: O(n)