โ๋ฌธ์
๐์ ํ
ํด์
โ๐ปํ์ด
์ฅ๋ฅด๋ณ ์ด ํ์๋ฅผ ๊ตฌํ HashMap์ ๊ตฌํจ.
pop์๋ 1, 4๋ฒ์ด classic์๋ 0, 2, 3 ๋ฒ์ผ๋ก ๋๋์ผ๋ก์จ ๊ฐ ์ฅ๋ฅด๋ณ๋ก ์จ๋ฒ์ ๋๋.
์ฅ๋ฅด๋ณ ์ด ํ์๋ฅผ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ์ฌ ์ด ํ์๊ฐ ๊ฐ์ฅ ๋ง์ ์ฅ๋ฅด ์์ผ๋ก ์ ๋ ฌํจ.
๊ฐ ์ฅ๋ฅด๋ณ๋ก ์จ๋ฒ๋ ์ฌ์ ํ์๋ฅผ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํจ.
์จ๋ฒ ์ค ์ฌ์ํ์๊ฐ ๊ฐ์ฅ ๋ง์ ๊ฒ์ answer์ ์ถ๊ฐ. ์จ๋ฒ์ ์๊ฐ 2๊ฐ ์ด์์ด๋ผ๋ฉด ํ๋ ๋ ์ถ๊ฐ.
๐ป์ฝ๋
import java.util.*;
import java.io.*;
class Solution {
public int[] solution(String[] genres, int[] plays) {
Map<String, Integer> cnt = new HashMap<>();
Map<String, HashMap<Integer, Integer>> album = new HashMap<>();
for(int i = 0; i < genres.length; i++){
if(!cnt.containsKey(genres[i])){
HashMap<Integer, Integer> m = new HashMap<>();
m.put(i, plays[i]);
album.put(genres[i], m);
cnt.put(genres[i], plays[i]);
} else {
album.get(genres[i]).put(i, plays[i]);
cnt.put(genres[i], cnt.get(genres[i]) + plays[i]);
}
}
List<String> keySet = new ArrayList<>(cnt.keySet());
keySet.sort((o1, o2) -> cnt.get(o2) - (cnt.get(o1)));
List<Integer> answer = new ArrayList();
for(String i : keySet) {
HashMap<Integer, Integer> map = album.get(i);
List<Integer> key = new ArrayList(map.keySet());
key.sort((o1, o2) -> map.get(o2) - (map.get(o1)));
answer.add(key.get(0));
if(key.size() > 1) // ํ์ฌ ์ฅ๋ฅด์ ์จ๋ฒ ์๊ฐ 2๊ฐ ์ด์์ด๋ผ๋ฉด ์ถ๊ฐ.
answer.add(key.get(1));
}
return answer.stream().mapToInt(i -> i).toArray();
}
}
๐ก์๋ก ๋ฐฐ์ด ๋ด์ฉ
**List ๋๋คํจ์ ์ฌ์ฉํ์ฌ ์ ๋ ฌ**
- ์ค๋ฆ์ฐจ์ ์ ๋ ฌ List.sort((o1, o2) -> map.get(o1) - (map.get(o2)))
- ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ List.sort((o1, o2) -> map.get(o2) - (map.get(o1)))
**์คํธ๋ฆผ**
- ์ปฌ๋ ์
, ๋ฐฐ์ด ๋ฑ์ ์ ์ฅ๋ ์์๋ค์ ํ๋์ฉ ์ฐธ์กฐํ๋ฉด์ ์ฝ๋๋ฅผ ์คํํ ์ ์๋ ๊ธฐ๋ฅ.
- ๋ถํ์ํ for๋ฌธ์ ์ฌ์ฉํ์ง ์๊ณ , ๋๋ค์์ ํ์ฉํ์ฌ ์ฝ๋๋ฅผ ์ง๊ด์ ์ด๊ฒ ์ฒ๋ฆฌ ๊ฐ๋ฅ.
**์คํธ๋ฆผ ์ค๊ฐ ์ฐ์ฐ**
- filter(Predicate<T> predicate): ์ฃผ์ด์ง ์กฐ๊ฑด์ ๋ง๋ ์์๋ง ์ ํ.
- map(Function<T, R> mapper): ๊ฐ ์์๋ฅผ ๋ค๋ฅธ ํํ๋ก ๋ณํ.
- flatMap(Function<T, Stream<R>> mapper): ๊ฐ ์์๋ฅผ ์ฌ๋ฌ ์์๋ก ํ์ฅํ๊ณ ํํํ.
- distinct(): ์ค๋ณต๋ ์์๋ฅผ ์ ๊ฑฐ.
- sorted(): ์์๋ฅผ ๊ธฐ๋ณธ ์ ๋ ฌ ์์๋ก ์ ๋ ฌ.
- peek(Consumer<T> action): ๊ฐ ์์์ ๋ํด ์ฃผ์ด์ง ๋์์ ์ํํ๊ณ , ๋์ ๊ฒฐ๊ณผ๋ฅผ ๊ทธ๋๋ก ๋ฐํ.
**์คํธ๋ฆผ ์ต์ข
์ฐ์ฐ**
- forEach(Consumer<T> action): ๊ฐ ์์์ ๋ํด ์ฃผ์ด์ง ๋์์ ์ํ.
- toArray(): Stream์ ์์๋ฅผ ๋ฐฐ์ด๋ก ๋ณํ..
- reduce(BinaryOperator<T> accumulator): ๋ชจ๋ ์์๋ฅผ ํ๋์ ๊ฐ์ผ๋ก ์ถ์
- collect(Collector<T, A, R> collector): Stream์ ์์๋ค์ ์ปฌ๋ ์
์ผ๋ก ์์ง.
- min(Comparator<T> comparator): Stream์ ์ต์๊ฐ์ ์ฐพ๊ธฐ.
- max(Comparator<T> comparator): Stream์ ์ต๋๊ฐ์ ์ฐพ๊ธฐ.
- count(): Stream์ ์์ ๊ฐ์๋ฅผ ๋ฐํ.
- anyMatch(Predicate<T> predicate): ์ฃผ์ด์ง ์กฐ๊ฑด์ ๋ง๋ ์์๊ฐ ํ๋๋ผ๋ ์๋์ง ํ์ธ.
- allMatch(Predicate<T> predicate): ๋ชจ๋ ์์๊ฐ ์ฃผ์ด์ง ์กฐ๊ฑด์ ๋ง์กฑํ๋์ง ํ์ธ.
- noneMatch(Predicate<T> predicate): ๋ชจ๋ ์์๊ฐ ์ฃผ์ด์ง ์กฐ๊ฑด์ ๋ง์กฑํ์ง ์๋์ง ํ์ธ.
- findFirst(): Stream์ ์ฒซ ๋ฒ์งธ ์์๋ฅผ ๋ฐํ.
- findAny(): Stream์ ์๋ฌด ์์๋ ๋ฐํ.