Merge branch 'main' of https://github.com/taurus09318976/leetcode-study

Author: taurus09318976

contains-duplicate/Ujoonnee.java

@@ -0,0 +1,24 @@
+import java.util.HashSet;
+import java.util.Set;
+
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> numberSet = new HashSet<>();
+        for(int number : nums) {
+            if(numberSet.contains(number)) {
+                return true;
+            }
+
+            numberSet.add(number);
+        }
+        return false;
+    }
+}
+
+/*
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        return Arrays.stream(nums).distinct().count() != nums.length;
+    }
+}
+*/

contains-duplicate/runnz121.java

@@ -0,0 +1,25 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class runnz121 {
+
+    public class Solution {
+
+        public boolean containsDuplicate(int[] nums) {
+
+            Map<Integer, Integer> countMap = new HashMap<>();
+
+            for (int i = 0; i < nums.length; i++) {
+                countMap.put(nums[i], countMap.getOrDefault(nums[i] , 0) + 1);
+            }
+
+            for (Map.Entry<Integer, Integer> map : countMap.entrySet()) {
+                if (map.getValue() >= 2) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}

house-robber/Ujoonnee.java

@@ -0,0 +1,13 @@
+class Solution {
+    public int rob(int[] nums) {
+        int[] dp = new int[nums.length+1];
+        dp[0] = 0;
+        dp[1] = nums[0];
+
+        for (int i=1; i<nums.length; i++) {
+            dp[i+1] = Math.max(nums[i] + dp[i-1], dp[i]);
+        }
+
+        return dp[nums.length];
+    }
+}

house-robber/runnz121.java

@@ -0,0 +1,24 @@
+import java.util.Arrays;
+
+public class runnz121 {
+
+    public class Solution {
+        public int rob(int[] nums) {
+
+            if (nums.length == 1) {
+                return nums[0];
+            }
+
+            int[] dp = new int[nums.length];
+
+            dp[0] = nums[0];
+            dp[1] = Math.max(nums[1], nums[0]);
+            for (int i = 2; i < nums.length; i++) {
+                int comp1 = Math.max(nums[i] + dp[i - 2], dp[i] + nums[i - 2]);
+                dp[i] = Math.max(comp1, dp[i - 1]);
+            }
+
+            return Arrays.stream(dp).max().stream().findFirst().orElse(Math.max(dp[0], dp[1]));
+        }
+    }
+}

longest-consecutive-sequence/Ujoonnee.java

@@ -0,0 +1,31 @@
+import java.util.Arrays;
+
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        if (nums.length == 0) {
+            return 0;
+        }
+
+        Arrays.sort(nums);
+
+        int answer = 1;
+        int current = 1;
+        for (int i=1; i<nums.length; i++) {
+            // 이전 숫자와 같다면 스킵
+            if (nums[i-1] == nums[i]) {
+                continue;
+            }
+
+            // 연속된 숫자라면 증가, 아니라면 초기화
+            if (nums[i-1] + 1 == nums[i]) {
+                current++;
+                answer = Math.max(answer, current);
+
+            } else {
+                current = 1;
+            }
+        }
+
+        return answer;
+    }
+}

longest-consecutive-sequence/runnz121.java

@@ -0,0 +1,52 @@
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class runnz121 {
+
+    public class Solution {
+
+        public int longestConsecutive(int[] nums) {
+
+            if (nums.length == 0) {
+                return 0;
+            }
+
+            Set<Integer> collect = Arrays.stream(nums).boxed().collect(Collectors.toSet());
+            int[] array = collect.stream().mapToInt(Integer::intValue).toArray();
+
+            List<Integer> minus = new ArrayList<>();
+            List<Integer> plus = new ArrayList<>();
+
+            for (int i = 0; i < collect.size(); i++) {
+
+                if (array[i] < 0) {
+                    minus.add(array[i]);
+                } else {
+                    plus.add(array[i]);
+                }
+            }
+
+            Collections.sort(minus);
+            Collections.sort(plus);
+
+            List<Integer> total = new ArrayList<>();
+            total.addAll(minus);
+            total.addAll(plus);
+
+            int ans = 0;
+            int subAns = 1;
+            for (int i = 0; i < total.size() - 1; i++) {
+                if (total.get(i + 1) == total.get(i) + 1) {
+                    subAns += 1;
+                } else {
+                    ans = Math.max(subAns, ans);
+                    subAns = 1;
+                }
+            }
+
+            ans = Math.max(ans, subAns);
+
+            return ans;
+        }
+    }
+}

top-k-frequent-elements/Ujoonnee.java

@@ -0,0 +1,32 @@
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+class Solution {
+    public int[] topKFrequent(int[] nums, int k) {
+        // 배열의 숫자가 몇 번씩 등장하는지 저장
+        Map<Integer, Integer> frequencyMap = new HashMap<>();
+        for(int num : nums) {
+            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
+        }
+
+        // Map 형식의 데이터를 [숫자, 빈도] 의 배열로 변환
+        Map.Entry<Integer, Integer>[] arr = new Map.Entry[frequencyMap.size()];
+        Iterator<Map.Entry<Integer, Integer>> iterator = frequencyMap.entrySet().iterator();
+        for (int i=0; i<arr.length; i++) {
+            arr[i] = iterator.next();
+        }
+
+        // 빈도 기준 내림차순 정렬
+        Arrays.sort(arr, (e1, e2) -> e2.getValue() - e1.getValue());
+
+        // k개만 꺼내기
+        int[] answer = new int[k];
+        for (int i=0; i<k; i++) {
+            answer[i] = arr[i].getKey();
+        }
+
+        return answer;
+    }
+}

top-k-frequent-elements/runnz121.java

@@ -0,0 +1,31 @@
+import java.util.HashMap;
+import java.util.Map;
+import java.util.PriorityQueue;
+
+public class runnz121 {
+
+    public class Solution {
+
+        public int[] topKFrequent(int[] nums, int k) {
+
+            Map<Integer, Integer> map = new HashMap<>();
+
+            for (int i = 0; i < nums.length; i++) {
+                map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
+            }
+
+            PriorityQueue<Integer> maxPq = new PriorityQueue<>(
+                    (a, b) -> map.get(b) - map.get(a)
+            );
+
+            maxPq.addAll(map.keySet());
+
+            int[] result = new int[k];
+
+            for (int i = 0; i < k; i++) {
+                result[i] = maxPq.poll();
+            }
+            return result;
+        }
+    }
+}

two-sum/Ujoonnee.java

@@ -0,0 +1,40 @@
+/*
+브루트 포스틑 이중 반복문을 사용하므로 시간 복잡도가 O(n^2)
+-> map에 (값, 인덱스)로 저장 후 배열을 반복하며 합이 target인 값을 찾는다.
+*/
+import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> numberMap = new HashMap<>();
+        for (int i=0; i<nums.length; i++) {
+            numberMap.put(nums[i], i);
+        }
+
+        for(int i=0; i<nums.length; i++) {
+            int operand = target - nums[i];
+            if (numberMap.containsKey(operand) && numberMap.get(operand) != i) { // 자기 자신은 제외
+                return new int[] { numberMap.get(target - nums[i]), i };
+            }
+        }
+
+        return new int[] {};
+    }
+}
+
+/*
+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 new int[] {};
+    }
+}
+*/

two-sum/runnz121.java

@@ -0,0 +1,26 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class runnz121 {
+
+    public class Solution {
+
+        public int[] twoSum(int[] nums, int target) {
+
+            Map<Integer, Integer> map = new HashMap<>();
+
+            for (int i = 0; i < nums.length; i++) {
+
+                int remain = target - nums[i];
+
+                if (map.containsKey(remain)) {
+                    return new int[]{map.get(remain), i};
+                }
+
+                map.put(nums[i], i);
+            }
+
+            return new int[]{0, 0};
+        }
+    }
+}