[donghyeon95] Week 1

contains-duplicate/donghyeon95.java

@@ -0,0 +1,31 @@
+import java.util.*;
+
+class Solution {
+	public boolean containsDuplicate(int[] nums) {
+		/*
+		* -- 풀이 --
+		* nums를 순회하면서 HashSet에 데이터를 넣어서 중복되었는 지 확인한다.
+		*
+		* -- 시간 복잡도 --
+		* 길이 N인 nums를 순환하는데 대한 시간 복잡도 => O(N)
+		* hashSet의 add에 대한 시간 복잡도 => O(1)
+		* 전체 시간 복잡도 O(1)*O(N) =O(n)
+		* ------------------------------------------
+		*
+		* -- 공간 복잡도 --
+		* 길이 N인 nums를 넣을 Hashset이 있어야 하기에 O(N)
+		* -------------------------------------------
+		*/
+
+		// 중복을 확인할 수 있는 set 선언
+		HashSet<Integer> hashSet = new HashSet<>();
+
+		for (int num: nums) {
+			// set에 있다면
+			if (!hashSet.add(num)) return true;
+		}
+
+		return false;
+	}
+}
+

house-robber/donghyeon95.java

@@ -0,0 +1,40 @@
+import java.util.Arrays;
+
+class Solution {
+	private int[] dp;
+
+	public int rob(int[] nums) {
+		// 점화식
+		// f(x) = f(나를 선택) + f(나를 안선택)
+		// 100개라서 가능은 할 거 같다.
+
+		dp = new int[100];
+
+		// 0도 가능 하다
+		Arrays.fill(dp, -1);
+
+
+		return recurse(nums, 0);
+
+	}
+
+	public int recurse(int[] nums, int index) {
+		// 종료 조건
+		if (index >= nums.length) return 0;
+
+		// 이미 한번 처리가 되었다면
+		if (dp[index] != -1) return dp[index];
+
+		int result = 0;
+
+		// 나를 선택하는 경우,
+		result = Math.max(recurse(nums, index+2)+nums[index], result);
+
+		// 나를 선택하지 않는 경우,
+		result = Math.max(recurse(nums, index+1), result);
+
+		dp[index] = result;
+		return result;
+	}
+}
+

longest-consecutive-sequence/donghyeon95.java

@@ -0,0 +1,34 @@
+import java.util.HashSet;
+
+public class Solution {
+	public int longestConsecutive(int[] nums) {
+		HashSet<Integer> set = new HashSet<>();
+		for (int num : nums) {
+			set.add(num);
+		}
+
+		int maxStreak = 0;
+
+		for (int num : nums) {
+			// 내가 시작 값이라면
+			if (!set.contains(num - 1)) {
+				int currentNum = num;
+				int currentStreak = 1;
+
+				// 나로부터 연결되는 값을 찾는다.
+				while (set.contains(currentNum + 1)) {
+					currentNum++;
+					currentStreak++;
+				}
+
+				maxStreak = Math.max(maxStreak, currentStreak);
+			}
+		}
+
+		return maxStreak;
+	}
+}
+
+
+
+

top-k-frequent-elements/donghyeon95.java

@@ -0,0 +1,29 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+class Solution {
+	public int[] topKFrequent(int[] nums, int k) {
+		HashMap<Integer, Integer> hm = new HashMap<>();
+
+		for (int num: nums) {
+			hm.put(num, hm.getOrDefault(num, 0)+1);
+		}
+
+		List<Map.Entry<Integer, Integer>> list = new ArrayList<>(hm.entrySet());
+		list.sort(Map.Entry.comparingByValue(Collections.reverseOrder()));
+
+		int index = 1;
+		ArrayList<Integer> answer = new ArrayList<>();
+		for (Map.Entry<Integer, Integer> entry: list) {
+			if (index > k) break;
+			answer.add(entry.getKey());
+			index++;
+		}
+
+		return answer.stream().mapToInt(Integer::intValue).toArray();
+	}
+}
+

valid-palindrome/donghyeon95.java

@@ -0,0 +1,17 @@
+/* 첫 시도
+	leetCode 기준 18ms
+ */
+
+class Solution {
+	public boolean isPalindrome(String s) {
+		// 1. remove non-alphanumeric using regex
+		String alphanumeric = s.replaceAll("[^a-zA-Z0-9]", "");
+
+		// 2. change lowerCase
+		String lowerCase = alphanumeric.toLowerCase();
+
+		// 3. compare reverse String
+		return lowerCase.contentEquals(new StringBuffer(lowerCase).reverse());
+	}
+}
+