๐ฅDAY +8
https://programmers.co.kr/learn/courses/30/lessons/42840?language=java
> ๋ฌธ์ ๋ฅผ ๋ณด๊ณ ์ถ๋ค๋ฉด ๋๋ณด๊ธฐ ํด๋ฆญ!
๋ฌธ์ ์ค๋ช
์ํฌ์๋ ์ํ์ ํฌ๊ธฐํ ์ฌ๋์ ์ค๋ง์ ๋๋ค. ์ํฌ์ ์ผ์ธ๋ฐฉ์ ๋ชจ์๊ณ ์ฌ์ ์ํ ๋ฌธ์ ๋ฅผ ์ ๋ถ ์ฐ์ผ๋ ค ํฉ๋๋ค. ์ํฌ์๋ 1๋ฒ ๋ฌธ์ ๋ถํฐ ๋ง์ง๋ง ๋ฌธ์ ๊น์ง ๋ค์๊ณผ ๊ฐ์ด ์ฐ์ต๋๋ค.
1๋ฒ ์ํฌ์๊ฐ ์ฐ๋ ๋ฐฉ์: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...
2๋ฒ ์ํฌ์๊ฐ ์ฐ๋ ๋ฐฉ์: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ...
3๋ฒ ์ํฌ์๊ฐ ์ฐ๋ ๋ฐฉ์: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...
1๋ฒ ๋ฌธ์ ๋ถํฐ ๋ง์ง๋ง ๋ฌธ์ ๊น์ง์ ์ ๋ต์ด ์์๋๋ก ๋ค์ ๋ฐฐ์ด answers๊ฐ ์ฃผ์ด์ก์ ๋, ๊ฐ์ฅ ๋ง์ ๋ฌธ์ ๋ฅผ ๋งํ ์ฌ๋์ด ๋๊ตฌ์ธ์ง ๋ฐฐ์ด์ ๋ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ ์กฐ๊ฑด- ์ํ์ ์ต๋ 10,000 ๋ฌธ์ ๋ก ๊ตฌ์ฑ๋์ด์์ต๋๋ค.
- ๋ฌธ์ ์ ์ ๋ต์ 1, 2, 3, 4, 5์ค ํ๋์ ๋๋ค.
- ๊ฐ์ฅ ๋์ ์ ์๋ฅผ ๋ฐ์ ์ฌ๋์ด ์ฌ๋ฟ์ผ ๊ฒฝ์ฐ, returnํ๋ ๊ฐ์ ์ค๋ฆ์ฐจ์ ์ ๋ ฌํด์ฃผ์ธ์.
[1,2,3,4,5] | [1] |
[1,3,2,4,2] | [1,2,3] |
์ ์ถ๋ ฅ ์ #1
- ์ํฌ์ 1์ ๋ชจ๋ ๋ฌธ์ ๋ฅผ ๋งํ์ต๋๋ค.
- ์ํฌ์ 2๋ ๋ชจ๋ ๋ฌธ์ ๋ฅผ ํ๋ ธ์ต๋๋ค.
- ์ํฌ์ 3์ ๋ชจ๋ ๋ฌธ์ ๋ฅผ ํ๋ ธ์ต๋๋ค.
๋ฐ๋ผ์ ๊ฐ์ฅ ๋ฌธ์ ๋ฅผ ๋ง์ด ๋งํ ์ฌ๋์ ์ํฌ์ 1์ ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- ๋ชจ๋ ์ฌ๋์ด 2๋ฌธ์ ์ฉ์ ๋ง์ท์ต๋๋ค.
๐ฅ [๋ก์ง]
1~3๋ฒ ์ํฌ์๋ค์๊ฒ๋ ์ผ์ ํ๊ฒ ์ฐ๋ ์ ๋ตํจํด์ด ์๋ค. ์ฐ์ ์ด๊ฑธ ์ฐพ์๋ด๋๊ฒ ์ค์ํ๋น.
1๋ฒ์ {1,2,3,4,5}, 2๋ฒ์ {2,1,2,3,2,4,2,5}, 3๋ฒ์ {3,3,1,1,2,2,4,4,5,5}์ ์ซ์๊ฐ ๋ฐ๋ณต๋๋๋ฐ ์ด ํจํด์ 2์ฐจ์ ๋ฐฐ์ด์ ์ ์ฅํ๋ค!
๊ทธ๋ฆฌ๊ณ ๊ฐ ์ํฌ์๋ค์ ์ ์๋ฅผ ๋ด๋ 1์ฐจ์ ๋ฐฐ์ด์ธ score๋ ์ ์ธํด์ฃผ๊ณ 0์ผ๋ก ์ด๊ธฐํํ๋ค.
๊ทธ ๋ค์! ๋ฌธ์ ์๋งํผ ๋๋ for๋ฌธ์ ์ ์ธํ๋๋ฐ, ๋ง์ฝ์ ์ ๋ต๊ณผ ํจํด์ด ์ผ์นํ๋ ๊ฒฝ์ฐ ํด๋น ์ํฌ์์ score์ ์ฆ๊ฐํด์ค๋ค!
์ฌ๊ธฐ์ ๊ณ ๋ คํด์ผ ํ๋ ์ค์ํ ํฌ์ธํธ๊ฐ ์๋ค
๋ฌธ์ ์๊ฐ ํจํด์ ์๋ณด๋ค ๋ง์ ๊ฒฝ์ฐ์ด๋ค.
์๋ฅผ ๋ค์๋ฉด ๋ฌธ์ ์ ์ ๋ต์ด 1,2,3,4,5,1์ผ ๋ 1๋ฒ ์ํฌ์๋ ์ ๋ตํจํด์ ๊ธธ์ด๊ฐ 5์ด๊ธฐ ๋๋ฌธ์ 6๋ฒ ๋ฌธ์ ์ ๋ํ 1๋ฒ ์ํฌ์์ ๋ต์ 1์ด ๋์ด์ผ ํ๋ค๋ ๊ฒ์ด๋ค!
๋ํ ์ํฌ์๋ค๋ง๋ค ๊ฐ์ง ์ ๋ตํจํด์ ๊ธธ์ด๊ฐ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ์ด๋ฅผ ๋ชจ๋ ๊ณ ๋ คํ ์ ์๋ ๋ฐฉ๋ฒ์ ์๊ฐํด์ผ ํ๋ค.
๋ด๊ฐ ์๊ฐํ ๋ฐฉ๋ฒ์ (ํ์ฌ ์ฑ์ ์ค์ธ ๋ฌธ์ ๋ฒํธ)์์ ๊ฐ (์ํฌ์๋ค์ ํจํด ๊ฐ์)์ ๋๋จธ์ง๋ฅผ ๊ตฌํ๋ ๊ฒ์ด๋ค(๋ค๋ค ์ด๋ ๊ฒ ์๊ฐํ์ง ์์๊น ์ถ๋ค)
๋ง๋ก ์ค๋ช ํ๊ธฐ ์ฐธ ์ด๋ ต๊ธดํ๋ฐ.. ๊ฒฐ๊ณผ์ ์ผ๋ก๋ ์ํฌ์๋ค์ ์ ๋ต์ด ๋ํ์ด๋๋ ์ ์ ๊ณฐ๊ณฐํ ์ ์๊ฐํด๋ณด๋ฉด ์ดํด๊ฐ ๊ฐ ๊ฒ์ด๋ค!
์ด๋ ๊ฒ ํด์ ๊ฐ ์ํฌ์๋ค์ ์ฑ์ ์ ๊ตฌํ๊ณ , ๊ทธ ๋ค์ ์ต๋๊ฐ์ ๊ตฌํ๋๋ฐ ์ด๋๋ stream์ ์ด์ฉํด ๋ฐฐ์ด์์์ ์ต๋๊ฐ์ ๊ฐ์ ธ์๋ค.
int max = Arrays.stream(score).max().getAsInt();
์ด๋ ๊ฒ
๊ทธ๋ฆฌ๊ณ ์ ๋ต ArrayList๋ฅผ ์ ์ธํด max๊ฐ์ ๊ฐ์ง ์ํฌ์๋ค์ ์์ด๋๋ฅผ ์ฐจ๋ก๋ก ์ถ๊ฐํด์ฃผ์๋ค!
๋ง์ง๋ง์ผ๋ก ๋ฆฌํด๊ฐ์ intํ ๋ฐฐ์ด, answer์ ArrayList์ด๊ธฐ ๋๋ฌธ์ intํ ๋ฐฐ์ด๋ก ํ๋ณํ์ ํด์ฃผ๋ฉด ๋!
answer.stream().mapToInt(i -> i).toArray();
์๋ ๊ฒ
๐ฅ [์ต์ข ์ฝ๋]
import java.util.Arrays;
import java.util.ArrayList;
import java.util.List;
class Solution {
public int[] solution(int[] answers) {
//์ํฌ์๋ค์ ์ ๋ตํจํด
int[][] patterns = {{1,2,3,4,5}, {2,1,2,3,2,4,2,5}, {3,3,1,1,2,2,4,4,5,5}};
int[] score = {0,0,0};
for(int i = 0; i < answers.length; i++) {
for(int j = 0; j < 3; j++) {
int index = i % patterns[j].length;
if(answers[i] == patterns[j][index]) {
score[j]++;
}
}
}
List<Integer> answer = new ArrayList<>();
int index = 0;
int max = Arrays.stream(score).max().getAsInt();
for(int s = 0; s < 3; s++) {
if(score[s] == max) {
answer.add(s+1);
}
}
return answer.stream().mapToInt(i -> i).toArray();
}
}
๐ฅ [์๊ฐ]
์ฌ์ค ๋ฌธ์ ์์ ์๊ตฌํ๋ ๋ฉ์ธ ๋ก์ง์ ๊ธ๋ฐฉ ์งฐ๋๋ฐ ํ๋ณํ, ์ต๋๊ฐ ๊ตฌํ๊ธฐ์ ๋ํ ๊ฐ๋ ์ด ์ ์กํ์์ง ์์์ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฐ ๊ฒ ๊ฐ๋ค.
๋ก์ง ํํธ์ ์๋ ๋๊ฐ์ง ์ฝ๋ ๊ตฌ๋ฌธ๋ค์ ์ ๋ง ์ค์ํ์ง๋ง ์ ์ธ์์ง์ง ์๋ ๊ฒ ๊ฐ๋คใ ๋ช๋ฒ์ด๋ ๋ค์ ์ฐพ์๋ดค๋์ง ๋ชจ๋ฅด๊ฒ ๋น ์์์ ์ผ๋ก ์ธ์ฐ๋ ์๊ฐ์ ๊ฐ์ ธ์ผ ํ ๊ฒ ๊ฐ๋ค!
๊ทธ๋ฆฌ๊ณ stream์ ๋ํด์๋ ํ๋ฒ ์ ๋ฆฌํ๋ฉด ์ข์๊ฒ๊ฐ๋ค.
+)
๋๋ ์ํ์ ๊ทธ๋ฅ ์ข์ํ์ง ์์ง๋ง ์ ๋ ๊ฒ ํ๋ํ๊ฒ ํจํด๊น์ง ๋ง๋ค์ด๊ฐ๋ฉด์ ์ฐ์ด๋ณธ์ ์ ์๋ค.. ์ ๊ฒ๋ ์์ง์๋๊นใ
์ฝํ ์ค๋น๋ฅผ ๋ณธ๊ฒฉ์ ์ผ๋ก ์์ํ์ง ์ผ๋ง ๋์ง ์์ ์ฝ๋์ ๋ฏธํกํ ์ ์ด ๋ง์ ์ ์์ต๋๋ค.
๋ถ์กฑํ ์ ํผ๋๋ฐฑ ์ฃผ์๋ฉด ์์ผ๋ก์ ํฌ์คํ ์ ๋ฐ์ํ๊ฒ ์ต๋๋ค! ๋ด์ฃผ์ ์ ์ ๋ง ๊ฐ์ฌํฉ๋๋ค :)
-budtree