From 829d5a466c4c0460227ae03f79f84e4caaa1f563 Mon Sep 17 00:00:00 2001 From: kdh-92 Date: Wed, 4 Dec 2024 19:03:52 +0900 Subject: [PATCH 1/6] solve : #217 (Contains Duplicate) with Java --- contains-duplicate/kdh-92.java | 35 ++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 contains-duplicate/kdh-92.java diff --git a/contains-duplicate/kdh-92.java b/contains-duplicate/kdh-92.java new file mode 100644 index 000000000..942931bc8 --- /dev/null +++ b/contains-duplicate/kdh-92.java @@ -0,0 +1,35 @@ +class Solution { + public boolean containsDuplicate(int[] nums) { + /** + * Constraints + * - 1 <= nums[] <= 10^5 + * - -10^9 <= nums[i] <= 10^9 + * + * Output + * - true : 중복 값 존재 + * - false : 모든 값이 유일 + */ + + // 해결법 1 (HashMap 방식 - HashSet 유사) + // 시간복잡도: O(N), 공간 복잡도 : O(N) + Map countMap = new HashMap<>(); + + for (int num: nums) { + int count = countMap.getOrDefault(num, 0) + 1; + if (count > 1) return true; + countMap.put(num, count); + } + + return false; + + // 해결법 2 (정렬) + // 시간 복잡도 : O(N log N), 공간 복잡도 : O(1) + Arrays.sort(nums); + + for (int i = 0; i < nums.length - 1; i++) { + if (nums[i] == nums[i + 1]) return true; + } + + return false; + } +} From e09178a625b0cc0962cf3d45d3ab92e586c5ad8c Mon Sep 17 00:00:00 2001 From: kdh-92 Date: Thu, 5 Dec 2024 02:00:25 +0900 Subject: [PATCH 2/6] solve : #220 (valid-palindrome) with Java --- valid-palindrome/kdh-92.java | 65 ++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 valid-palindrome/kdh-92.java diff --git a/valid-palindrome/kdh-92.java b/valid-palindrome/kdh-92.java new file mode 100644 index 000000000..21fa3f61b --- /dev/null +++ b/valid-palindrome/kdh-92.java @@ -0,0 +1,65 @@ +/** + * Constraints + * - 1 <= s.length <= 2 * 10^5 + * - s consists only of printable ASCII characters. + * + * Output + * - true : 좌우 동일 + * - false : 좌우 비동일 + */ + + +class Solution { + public boolean isPalindrome(String s) { + + // 해결법 1 (투포인터) + // 시간복잡도: O(N), 공간 복잡도 : O(1) + // 2ms & Beats 99.05% + int left = 0, right = s.length() - 1; + + while (left < right) { + // (1) + if (!Character.isLetterOrDigit(s.charAt(left))) { + left++; + } + else if (!Character.isLetterOrDigit(s.charAt(right))) { + right--; + } + else { + if (Character.toLowerCase(s.charAt(left)) != Character.toLowerCase(s.charAt(right))) { + return false; + } + + left++; + right--; + } + + + // (2) + while (left < right && !Character.isLetterOrDigit(s.charAt(left))) { + left++; + } + while (left < right && !Character.isLetterOrDigit(s.charAt(right))) { + right--; + } + if (Character.toLowerCase(s.charAt(left)) != Character.toLowerCase(s.charAt(right))) { + return false; + } + left++; + right--; + } + + return true; + + // 해결법 2 (Stream API) + // 시간 복잡도 : O(N), 공간 복잡도 : O(N) + // 133ms & Beats 5.58% + String filtered = s.chars() + .filter(Character::isLetterOrDigit) + .mapToObj(c -> String.valueOf((char) Character.toLowerCase(c))) + .reduce("", String::concat); + + return IntStream.range(0, filtered.length() / 2) + .allMatch(i -> filtered.charAt(i) == filtered.charAt(filtered.length() - 1 - i)); + } +} From f9c216ca0624f58d58b2fffae7833c5d67662fad Mon Sep 17 00:00:00 2001 From: kdh-92 Date: Sun, 8 Dec 2024 07:06:51 +0900 Subject: [PATCH 3/6] solve : #237 (Top K Frequent Elements) with Java --- top-k-frequent-elements/kdh-92.java | 82 +++++++++++++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 top-k-frequent-elements/kdh-92.java diff --git a/top-k-frequent-elements/kdh-92.java b/top-k-frequent-elements/kdh-92.java new file mode 100644 index 000000000..3759619e9 --- /dev/null +++ b/top-k-frequent-elements/kdh-92.java @@ -0,0 +1,82 @@ +/** + * Constraints + * 1 <= nums.length <= 10^5 + * -10^4 <= nums[i] <= 10^4 + * k is in the range [1, the number of unique elements in the array]. + * It is guaranteed that the answer is unique. + * + * Output + * - int 배열 + */ + +class Solution { + public int[] topKFrequent(int[] nums, int k) { + // (1) HashMap + PriorityQueue + // 시간복잡도 : O(N log N) + // Runtime : 15ms Beats 38.03% + // Memory : 48.93MB Beats 20.01% + Map frequencyMap = new HashMap<>(); + + for (int num : nums) { + frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1); + } + + PriorityQueue> minHeap = new PriorityQueue<>(Comparator.comparingInt(Map.Entry::getValue)); + + for (Map.Entry entry : frequencyMap.entrySet()) { + minHeap.offer(entry); + if (minHeap.size() > k) { + minHeap.poll(); + } + } + + int[] result = new int[k]; + + for (int i = 0; i < k; i++) { + result[i] = minHeap.poll().getKey(); + } + + return result; + + // (2) Stream + // 시간복잡도 : O(N log N) + // Runtime : 19ms Beats 8.16% + // Memory : 49.00MB Beats 20.01% + // Stream에 익숙해지기 위해 공부용 + return Arrays.stream(nums) + .boxed() + .collect(Collectors.groupingBy(num -> num, Collectors.summingInt(num -> 1))) + .entrySet().stream() + .sorted((a, b) -> b.getValue() - a.getValue()) + .limit(k) + .mapToInt(Map.Entry::getKey) + .toArray(); + + // (3) Array List + // 시간복잡도 : O(N) + // Runtime : 13ms Beats 75.77% + // Memory : 48.44MB Beats 61.68% + Map frequencyMap = new HashMap<>(); + for (int num : nums) { + frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1); + } + + List[] buckets = new List[nums.length + 1]; + for (int key : frequencyMap.keySet()) { + int freq = frequencyMap.get(key); + if (buckets[freq] == null) { + buckets[freq] = new ArrayList<>(); + } + buckets[freq].add(key); + } + + List result = new ArrayList<>(); + for (int i = buckets.length - 1; i >= 0 && result.size() < k; i--) { + if (buckets[i] != null) { + result.addAll(buckets[i]); + } + } + + return result.stream().mapToInt(Integer::intValue).toArray(); + } +} From e48bda1a65ee732e57500a5e6e2ed98ce5a1f474 Mon Sep 17 00:00:00 2001 From: kdh-92 Date: Mon, 9 Dec 2024 07:11:25 +0900 Subject: [PATCH 4/6] solve : #240 (Longest Consecutive Sequence) with Java --- longest-consecutive-sequence/kdh-92.java | 61 ++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 longest-consecutive-sequence/kdh-92.java diff --git a/longest-consecutive-sequence/kdh-92.java b/longest-consecutive-sequence/kdh-92.java new file mode 100644 index 000000000..7b548d43a --- /dev/null +++ b/longest-consecutive-sequence/kdh-92.java @@ -0,0 +1,61 @@ +/** + * Constraints: + * - 0 <= nums.length <= 105 + * - -109 <= nums[i] <= 109 + * + * Output + * - 가장 긴 길이 + * + * 풀이 특이점 + * - 둘다 시간복잡도는 O(N)으로 생각되는데 Runtime의 결과 차이가 꽤 크게 나온 점 + */ + +class Solution { + public int longestConsecutive(int[] nums) { + // (1) Set & num -1 + // 시간복잡도 : O(N) + // Runtime : 1267ms Beats 5.15% + // Memory : 63.30MB Beats 62.58% + // Set uniqueNums = Arrays.stream(nums).boxed().collect(Collectors.toSet()); + // int result = 0; + + // for (int num : nums) { + // if (uniqueNums.contains(num - 1)) continue; + // int length = 1; + // while (uniqueNums.contains(num + length)) length += 1; + // result = Math.max(length, result); + // } + + // return result; + + // (2) HashMap + // 시간복잡도 : O(N) + // Runtime : 38ms Beats 46.54% + // Memory : 66.45MB Beats 51.28% + HashMap hm = new HashMap<>(); + + for(int i=0; i Date: Mon, 9 Dec 2024 18:54:54 +0900 Subject: [PATCH 5/6] =?UTF-8?q?Check=20filename=20rules=20=ED=95=B4?= =?UTF-8?q?=EA=B2=B0=20=EC=8B=9C=EB=8F=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- longest-consecutive-sequence/kdh-92.java | 6 +-- top-k-frequent-elements/kdh-92.java | 56 ++++++++++++------------ 2 files changed, 31 insertions(+), 31 deletions(-) diff --git a/longest-consecutive-sequence/kdh-92.java b/longest-consecutive-sequence/kdh-92.java index 7b548d43a..f9fb62cbc 100644 --- a/longest-consecutive-sequence/kdh-92.java +++ b/longest-consecutive-sequence/kdh-92.java @@ -39,7 +39,7 @@ public int longestConsecutive(int[] nums) { } for(int key : hm.keySet()){ - if(hm.containsKey(key - 1)== false){ + if(hm.containsKey(key - 1)){ hm.put(key, true); } } @@ -47,8 +47,8 @@ public int longestConsecutive(int[] nums) { int max = 0; for(int key : hm.keySet()){ int k =1; - if(hm.get(key) == true){ - while(hm.containsKey(key + k) == true){ + if(hm.get(key)){ + while(hm.containsKey(key + k)){ k++; } } diff --git a/top-k-frequent-elements/kdh-92.java b/top-k-frequent-elements/kdh-92.java index 3759619e9..745fab795 100644 --- a/top-k-frequent-elements/kdh-92.java +++ b/top-k-frequent-elements/kdh-92.java @@ -43,40 +43,40 @@ public int[] topKFrequent(int[] nums, int k) { // Runtime : 19ms Beats 8.16% // Memory : 49.00MB Beats 20.01% // Stream에 익숙해지기 위해 공부용 - return Arrays.stream(nums) - .boxed() - .collect(Collectors.groupingBy(num -> num, Collectors.summingInt(num -> 1))) - .entrySet().stream() - .sorted((a, b) -> b.getValue() - a.getValue()) - .limit(k) - .mapToInt(Map.Entry::getKey) - .toArray(); + return Arrays.stream(nums) + .boxed() + .collect(Collectors.groupingBy(num -> num, Collectors.summingInt(num -> 1))) + .entrySet().stream() + .sorted((a, b) -> b.getValue() - a.getValue()) + .limit(k) + .mapToInt(Map.Entry::getKey) + .toArray(); // (3) Array List // 시간복잡도 : O(N) // Runtime : 13ms Beats 75.77% // Memory : 48.44MB Beats 61.68% - Map frequencyMap = new HashMap<>(); - for (int num : nums) { - frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1); - } + Map frequencyMap = new HashMap<>(); + for (int num : nums) { + frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1); + } - List[] buckets = new List[nums.length + 1]; - for (int key : frequencyMap.keySet()) { - int freq = frequencyMap.get(key); - if (buckets[freq] == null) { - buckets[freq] = new ArrayList<>(); - } - buckets[freq].add(key); - } + List[] buckets = new List[nums.length + 1]; + for (int key : frequencyMap.keySet()) { + int freq = frequencyMap.get(key); + if (buckets[freq] == null) { + buckets[freq] = new ArrayList<>(); + } + buckets[freq].add(key); + } - List result = new ArrayList<>(); - for (int i = buckets.length - 1; i >= 0 && result.size() < k; i--) { - if (buckets[i] != null) { - result.addAll(buckets[i]); - } - } + List result = new ArrayList<>(); + for (int i = buckets.length - 1; i >= 0 && result.size() < k; i--) { + if (buckets[i] != null) { + result.addAll(buckets[i]); + } + } - return result.stream().mapToInt(Integer::intValue).toArray(); + return result.stream().mapToInt(Integer::intValue).toArray(); } -} +} \ No newline at end of file From 324485eb232a6d4a7d15353263ce00884f3d0d76 Mon Sep 17 00:00:00 2001 From: kdh-92 Date: Tue, 10 Dec 2024 02:52:18 +0900 Subject: [PATCH 6/6] solve : #264 (House Robber) with Java --- house-robber/kdh-92.java | 29 +++++++++++++++++++++++++++++ top-k-frequent-elements/kdh-92.java | 2 +- 2 files changed, 30 insertions(+), 1 deletion(-) create mode 100644 house-robber/kdh-92.java diff --git a/house-robber/kdh-92.java b/house-robber/kdh-92.java new file mode 100644 index 000000000..a98ff6092 --- /dev/null +++ b/house-robber/kdh-92.java @@ -0,0 +1,29 @@ +class Solution { + public int rob(int[] nums) { + // (1) dp + // int n = nums.length; + + // if (n == 1) return nums[0]; + + // int[] dp = new int[n]; + + // dp[0] = nums[0]; + // dp[1] = Math.max(nums[0], nums[1]); + + // for (int i = 2; i < n; i++) { + // dp[i] = Math.max(dp[i - 1], nums[i] + dp[i - 2]); + // } + + // return dp[n - 1]; + + // (2) 인접 값 비교 + int prev = 0, curr = 0; + for (int num : nums) { + int temp = curr; + curr = Math.max(num + prev, curr); + prev = temp; + } + + return curr; + } +} diff --git a/top-k-frequent-elements/kdh-92.java b/top-k-frequent-elements/kdh-92.java index 745fab795..17e74ab56 100644 --- a/top-k-frequent-elements/kdh-92.java +++ b/top-k-frequent-elements/kdh-92.java @@ -79,4 +79,4 @@ public int[] topKFrequent(int[] nums, int k) { return result.stream().mapToInt(Integer::intValue).toArray(); } -} \ No newline at end of file +}