Skip to content

Commit 936af59

Browse files
geegonggeegong
authored
Merge pull request DaleStudy#2018 from geegong/main
[geegong] WEEK 01 Solutions
2 parents 580d05f + d907097 commit 936af59

File tree

5 files changed

+210
-100
lines changed

5 files changed

+210
-100
lines changed

‎contains-duplicate/Geegong.java‎

Lines changed: 13 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -9,17 +9,26 @@ public class Geegong {
99
* time complexity : O(n)
1010
* space complexity : o(n)
1111
* @param nums
12-
* @return
12+
* @return boolean
1313
*/
1414
public boolean containsDuplicate(int[] nums) {
15+
16+
17+
1518
HashSet<Integer> uniques = new HashSet<>();
1619

1720
for (int num : nums) {
18-
if (uniques.contains(num)) {
21+
22+
// 명확하게 hashSet에 값이 있는지 체크하는 메소드로 확인이 가능하지만
23+
// if (uniques.contains(num)) {
24+
// return true;
25+
// }
26+
// uniques.add(num);
27+
28+
// hashSet 의 Add 는 이미 값이 있다면 FALSE를 리턴하기에 아래처럼도 동작 가능 (더 빠른 결과확인)
29+
if (!uniques.add(num)) {
1930
return true;
2031
}
21-
22-
uniques.add(num);
2332
}
2433

2534
return false;

‎house-robber/Geegong.java‎

Lines changed: 49 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,52 @@
1+
import java.util.HashMap;
2+
import java.util.Map;
3+
14
public class Geegong {
2-
// 이 문제는 시간이 남을때 풀 예정 😅
5+
6+
/**
7+
* top-down + memoization 방식으로 풀이
8+
* memoization (memo 변수) 없이 풀이하면 Time Limit Exceeded 발생
9+
* time complexity : O(N) -> memo 가 있어서 이미 연산이 된건 패스함
10+
* space complexity : O(N) -> index 만큼의 연산 결과가 있음
11+
* @param nums
12+
* @return
13+
*/
14+
public int rob(int[] nums) {
15+
// memoization 하지 않으면 Time Limit Exceeded.
16+
Map<Integer, Integer> memo = new HashMap<>();
17+
18+
int maxAmount = 0;
19+
for (int idx=0; idx<nums.length; idx++) {
20+
int currAmount = Math.max(
21+
nums[idx] + rob(nums, idx+2, memo), rob(nums, idx+1, memo));
22+
maxAmount = Math.max(currAmount, maxAmount);
23+
}
24+
25+
return maxAmount;
26+
}
27+
28+
29+
public int rob(int[] origin, int currIdx, Map<Integer, Integer> memo) {
30+
if (currIdx == origin.length - 1) {
31+
return origin[currIdx];
32+
} else if (currIdx >= origin.length) { // when out of bounds
33+
return 0;
34+
}
35+
36+
if (memo.containsKey(currIdx)) {
37+
return memo.get(currIdx);
38+
}
39+
40+
int currentVal = origin[currIdx];
41+
42+
int maxAmount = Math.max(
43+
currentVal + rob(origin, currIdx + 2, memo), rob(origin, currIdx+1, memo));
44+
45+
memo.put(currIdx, maxAmount);
46+
47+
return maxAmount;
48+
}
49+
50+
351
}
452

‎longest-consecutive-sequence/Geegong.java‎

Lines changed: 30 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
1+
import java.util.Arrays;
12
import java.util.HashMap;
23
import java.util.HashSet;
34
import java.util.Map;
@@ -7,42 +8,45 @@
78
*/
89
public class Geegong {
910

11+
/**
12+
* Time complexity : O(N) + O(N long N) + O(N)
13+
* - o(N) : 한번 순회해서 set
14+
* - O(N log N) : sorting
15+
* - O (N) : sorting된걸 한번 더 순회
16+
* Space complexity : O(N) -> hash set
17+
* @param nums
18+
* @return int
19+
*/
1020
public int longestConsecutive(int[] nums) {
11-
HashSet<Integer> setOfNums = new HashSet<>();
12-
// key : startIndex , value : length
13-
Map<Integer, Integer> lengthMap = new HashMap<>();
14-
15-
// sort..? 를 해야될까 싶음..
16-
17-
// initialize
18-
for (int num : nums) {
19-
setOfNums.add(num);
21+
if (nums.length == 0) {
22+
return 0;
2023
}
2124

22-
Integer longest = 0;
23-
24-
for (Integer num : setOfNums) {
25-
int length = iterate(setOfNums, num, 0, lengthMap);
26-
longest = Math.max(longest, length);
25+
// hashSet
26+
HashSet<Integer> hashSet = new HashSet<>();
27+
for (int num : nums) {
28+
hashSet.add(num);
2729
}
2830

29-
return longest;
30-
}
31+
int[] sortedNums = hashSet.stream().mapToInt(val -> val).sorted().toArray();
3132

32-
public Integer iterate(HashSet<Integer> hashSet, int currIndex, int currLength, Map<Integer, Integer> lengthMap) {
33-
if (lengthMap.containsKey(currIndex)) {
34-
return lengthMap.get(currIndex);
35-
}
33+
int maxLength = 1;
34+
int currentLength = 1;
35+
int prev = sortedNums[0];
36+
for(int index=1; index<sortedNums.length; index++) {
37+
int current = sortedNums[index];
38+
if (current == prev + 1) {
39+
currentLength++;
3640

37-
if (hashSet.contains(currIndex)) {
38-
currLength++;
39-
return iterate(hashSet, currIndex+1, currLength, lengthMap);
41+
} else {
42+
maxLength = Math.max(currentLength, maxLength);
43+
currentLength = 1;
44+
}
4045

41-
} else {
42-
lengthMap.put(currIndex, currLength);
43-
return currLength;
46+
prev = sortedNums[index];
4447
}
4548

49+
return Math.max(currentLength, maxLength);
4650
}
4751

4852
}

‎top-k-frequent-elements/Geegong.java‎

Lines changed: 108 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -1,75 +1,128 @@
1-
import java.util.HashMap;
2-
import java.util.HashSet;
3-
import java.util.Map;
1+
import java.util.*;
42

5-
public class Geegong {
63

74

8-
public int[] topKFrequent(int[] nums, int k) {
9-
int[] result = new int[k];
5+
public class Geegong {
106

11-
// key : num element in nums / value : frequency of num elements
12-
Map<Integer, Integer> numMap = new HashMap<>();
137

14-
// key : frequency of num elements / value : HashSet<Integer> num elements
15-
Map<Integer, HashSet<Integer>> frequencyMap = new HashMap<>();
8+
/**
9+
* Map 으로 빈도수를 key , 빈도수에 해당되는 num 들을 list 로 저장
10+
* key (빈도수) 를 sorting
11+
* k 만큼 골라낸다
12+
* Time Complexity : O(N) + O(N logN) + O(N)
13+
* - O(N) : nums 만큼 iterate
14+
* - O(N log N) : sorting
15+
* - O(N) : frequency 그룹핑된 그룹 갯수만큼 iterate
16+
* @param nums
17+
* @param k
18+
* @return int[]
19+
*/
20+
public int[] topKFrequent(int[] nums, int k) {
1621

17-
// most frequent numbers
18-
int maxCount = 0;
22+
// key : frequency , value : list of nums
23+
Map<Integer, List<Integer>> map = new HashMap<>();
24+
Arrays.sort(nums);
25+
int current = nums[0];
26+
int count = 1;
1927

20-
// initialize numMap
21-
for (int num : nums) {
22-
if (numMap.containsKey(num)) {
23-
Integer alreadyCounted = numMap.get(num);
24-
numMap.put(num, alreadyCounted + 1);
28+
for (int i = 1; i < nums.length; i++) {
29+
if (nums[i] == current) {
30+
count++;
2531
} else {
26-
numMap.put(num, 1);
32+
map.computeIfAbsent(count, el -> new ArrayList<>()).add(current);
33+
current = nums[i];
34+
count = 1;
2735
}
2836
}
2937

38+
// Add last group
39+
map.computeIfAbsent(count, el -> new ArrayList<>()).add(current);
3040

31-
//numHashSetMap
32-
for (int num : numMap.keySet()) {
33-
int frequencyOfNum = numMap.get(num);
34-
maxCount = Math.max(maxCount, frequencyOfNum);
35-
36-
if (frequencyMap.containsKey(frequencyOfNum)) {
37-
HashSet<Integer> alreadySet = frequencyMap.get(frequencyOfNum);
38-
alreadySet.add(num);
39-
40-
frequencyMap.put(frequencyOfNum, alreadySet);
41-
42-
} else {
43-
HashSet<Integer> newHashSet = new HashSet<>();
44-
newHashSet.add(num);
45-
46-
frequencyMap.put(frequencyOfNum, newHashSet);
47-
}
48-
}
41+
List<Integer> sortedFrequency = map.keySet().stream().sorted(Comparator.reverseOrder()).toList();
42+
List<Integer> result = new ArrayList<>();
43+
for (int index=0; index<sortedFrequency.size(); index++ ) {
44+
int mostFrequency = sortedFrequency.get(index);
45+
List<Integer> numsOfFreq = map.get(mostFrequency);
4946

47+
for(int innerIndex = 0; innerIndex<numsOfFreq.size(); innerIndex++) {
48+
if (result.size() == k) {
49+
return result.stream().mapToInt(Integer::intValue).toArray();
50+
}
5051

51-
// maxCount 부터 decreasing
52-
int resultIndex=0;
53-
for(int frequency=maxCount; frequency>=0; frequency--) {
54-
if (resultIndex >= result.length) {
55-
return result;
52+
result.add(numsOfFreq.get(innerIndex));
5653
}
5754

58-
if (frequencyMap.containsKey(frequency)) {
59-
HashSet<Integer> numElements = frequencyMap.get(frequency);
60-
61-
for (int numElement : numElements) {
62-
result[resultIndex] = numElement;
63-
resultIndex++;
64-
65-
66-
if (resultIndex >= result.length) {
67-
return result;
68-
}
69-
}
70-
}
7155
}
7256

73-
return result;
57+
return result.stream().mapToInt(Integer::intValue).toArray();
58+
59+
// 아래 문제풀이는 예전 기수에 풀었던 방법으로 Map 으로 빈도수와 num을 관리하는 값을 가지긴 하나
60+
// sorting은 하지 않고 maxNumOfFrequency를 구하여 순차적으로 작은 값들을 꺼내서 k만큼 리턴한다
61+
// int[] result = new int[k];
62+
//
63+
// // key : num element in nums / value : frequency of num elements
64+
// Map<Integer, Integer> numMap = new HashMap<>();
65+
//
66+
// // key : frequency of num elements / value : HashSet<Integer> num elements
67+
// Map<Integer, HashSet<Integer>> frequencyMap = new HashMap<>();
68+
//
69+
// // most frequent numbers
70+
// int maxCount = 0;
71+
//
72+
// // initialize numMap
73+
// for (int num : nums) {
74+
// if (numMap.containsKey(num)) {
75+
// Integer alreadyCounted = numMap.get(num);
76+
// numMap.put(num, alreadyCounted + 1);
77+
// } else {
78+
// numMap.put(num, 1);
79+
// }
80+
// }
81+
//
82+
//
83+
// //numHashSetMap
84+
// for (int num : numMap.keySet()) {
85+
// int frequencyOfNum = numMap.get(num);
86+
// maxCount = Math.max(maxCount, frequencyOfNum);
87+
//
88+
// if (frequencyMap.containsKey(frequencyOfNum)) {
89+
// HashSet<Integer> alreadySet = frequencyMap.get(frequencyOfNum);
90+
// alreadySet.add(num);
91+
//
92+
// frequencyMap.put(frequencyOfNum, alreadySet);
93+
//
94+
// } else {
95+
// HashSet<Integer> newHashSet = new HashSet<>();
96+
// newHashSet.add(num);
97+
//
98+
// frequencyMap.put(frequencyOfNum, newHashSet);
99+
// }
100+
// }
101+
//
102+
//
103+
// // maxCount 부터 decreasing
104+
// int resultIndex=0;
105+
// for(int frequency=maxCount; frequency>=0; frequency--) {
106+
// if (resultIndex >= result.length) {
107+
// return result;
108+
// }
109+
//
110+
// if (frequencyMap.containsKey(frequency)) {
111+
// HashSet<Integer> numElements = frequencyMap.get(frequency);
112+
//
113+
// for (int numElement : numElements) {
114+
// result[resultIndex] = numElement;
115+
// resultIndex++;
116+
//
117+
//
118+
// if (resultIndex >= result.length) {
119+
// return result;
120+
// }
121+
// }
122+
// }
123+
// }
124+
//
125+
// return result;
126+
}
74127
}
75128

‎two-sum/Geegong.java‎

Lines changed: 10 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -8,26 +8,22 @@ public class Geegong {
88
* space complexity : O(n)
99
* @param nums
1010
* @param target
11-
* @return
11+
* @return int[]
1212
*/
1313
public int[] twoSum(int[] nums, int target) {
14-
Map<Integer, Integer> map = new HashMap<>();
1514
int[] result = new int[2];
15+
// key : value, value = index
16+
Map<Integer, Integer> maps = new HashMap<Integer, Integer>();
1617

17-
// if target = -9 / num = 1 , num = -10
18-
for (int index=0; index<nums.length; index++) {
19-
map.put(nums[index], index);
20-
}
21-
22-
for (int index=0; index<nums.length; index++) {
23-
int difference = target - nums[index];
24-
25-
if (map.containsKey(difference)
26-
&& map.get(difference) != index) {
27-
result[0] = index;
28-
result[1] = map.get(difference);
18+
for(int index=0; index<nums.length; index++) {
19+
int findOne = target - nums[index];
20+
if (maps.containsKey(findOne)) {
21+
result[0] = maps.get(findOne);
22+
result[1] = index;
2923
return result;
3024
}
25+
26+
maps.put(nums[index], index);
3127
}
3228

3329
return result;

0 commit comments

Comments
 (0)