Merge pull request #2012 from hyunolike/main

[hyunolike] WEEK 01 solutions

Author: hyunolike

contains-duplicate/hyunolike.java

@@ -0,0 +1,23 @@
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        // 중복 체크
+        // 각 요소 순환
+
+        // 1. 배열 순환
+        // 2. 2 이상 true 체크
+
+        // 자료구조 Map 사용
+        HashMap<Integer, Integer> map = new HashMap<>();
+
+        for (int num : nums) {
+            //System.out.println(num);
+            if (map.containsKey(num)) {
+                return true;
+            }
+
+            map.put(Integer.valueOf(num), Integer.valueOf(num));
+        }
+
+        return false;
+    }
+}

house-robber/hyunolike.java

@@ -0,0 +1,14 @@
+class Solution {
+    public int rob(int[] nums) {
+        if (nums.length == 0) return 0;
+
+        int prev1 = 0;
+        int prev2 = 0;
+        for(int num : nums) {
+            int tmp = prev1;
+            prev1 = Math.max(prev2 + num, prev1);
+            prev2 = tmp;
+        }
+        return prev1;
+    }
+}

longest-consecutive-sequence/hyunolike.java

@@ -0,0 +1,28 @@
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        // 연속된 숫자 길이 파악
+        // 연속된 거 어떻게?
+        if(nums.length == 0 || nums == null) return 0;
+
+        int result = 0;
+
+        Arrays.sort(nums);
+
+        int maxLen = 1;
+        int len = 1;
+
+        for(int i = 1; i < nums.length; i++) {
+            // 중복 체크
+            if(nums[i] == nums[i-1]) {
+                continue;
+            }else if(nums[i] == nums[i-1] + 1) {
+                len++;
+                maxLen = Math.max(maxLen, len);
+            }else{
+                len = 1;
+            }
+        }
+
+        return maxLen;
+    }
+}

top-k-frequent-elements/hyunolike.java

@@ -0,0 +1,23 @@
+class Solution {
+    public int[] topKFrequent(int[] nums, int k) {
+            Map<Integer, Integer> counter = new HashMap<>();
+            for (int n : nums) {
+                counter.put(n, counter.getOrDefault(n, 0) + 1);
+            }
+
+            PriorityQueue<Map.Entry<Integer, Integer>> heap = new PriorityQueue<>(
+                (a, b) -> Integer.compare(b.getValue(), a.getValue())
+            );
+
+            for (Map.Entry<Integer, Integer> entry : counter.entrySet()) {
+                heap.offer(entry);
+            }
+
+            int[] res = new int[k];
+            for(int i = 0; i < k; i++) {
+                res[i] = Objects.requireNonNull(heap.poll()).getKey();
+            }
+
+            return res;
+    }
+}

two-sum/hyunolike.java

@@ -0,0 +1,20 @@
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        // 모든 경우의 수 체크
+
+        // 결과값 
+        int[] result = null;
+
+        // 순회
+        for(int i = 0; i < nums.length; i++){
+            for(int j = i+1; j < nums.length; j++) {
+                int sum = nums[i] + nums[j];
+                if(sum == target) {
+                    result = new int[]{i, j};
+                }
+            }
+        }
+
+        return result;
+    }
+}