Develop record
[ํ๋ก๊ทธ๋๋จธ์ค] ๋ชจ์๊ณ ์ฌ-Java ๋ณธ๋ฌธ
https://school.programmers.co.kr/learn/courses/30/lessons/42840
๐ ๋ฌธ์ ์ค๋ช
์ํฌ์๋ ์ํ์ ํฌ๊ธฐํ ์ฌ๋์ ์ค๋ง์ ๋๋ค. ์ํฌ์ ์ผ์ธ๋ฐฉ์ ๋ชจ์๊ณ ์ฌ์ ์ํ ๋ฌธ์ ๋ฅผ ์ ๋ถ ์ฐ์ผ๋ ค ํฉ๋๋ค. ์ํฌ์๋ 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ํ๋ ๊ฐ์ ์ค๋ฆ์ฐจ์ ์ ๋ ฌํด์ฃผ์ธ์.
๐ ์ ์ถ๋ ฅ ์
answers | return |
[1,2,3,4,5] | [1] |
[1,3,2,4,2] | [1,2,3] |
๐ ์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- ์ํฌ์ 1์ ๋ชจ๋ ๋ฌธ์ ๋ฅผ ๋งํ์ต๋๋ค.
- ์ํฌ์ 2๋ ๋ชจ๋ ๋ฌธ์ ๋ฅผ ํ๋ ธ์ต๋๋ค.
- ์ํฌ์ 3์ ๋ชจ๋ ๋ฌธ์ ๋ฅผ ํ๋ ธ์ต๋๋ค.
๋ฐ๋ผ์ ๊ฐ์ฅ ๋ฌธ์ ๋ฅผ ๋ง์ด ๋งํ ์ฌ๋์ ์ํฌ์ 1์ ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- ๋ชจ๋ ์ฌ๋์ด 2๋ฌธ์ ์ฉ์ ๋ง์ท์ต๋๋ค.
๐๏ธ ์์ฑ ์ฝ๋
import java.util.*;
class Solution {
public Integer[] solution(int[] answers) {
ArrayList<Integer> list = new ArrayList<>();
int [] one = new int[]{1,2,3,4,5}; // 5๊ฐ์ฉ ๋ฐ๋ณต
int [] two = new int[]{2,1,2,3,2,4,2,5}; // 8๊ฐ์ฉ ๋ฐ๋ณต
int [] three = new int[]{3,3,1,1,2,2,4,4,5,5}; // 10๊ฐ์ฉ ๋ฐ๋ณต
int [] arr = new int[3]; // ๊ฐ ์ํฌ์๋ค์ ์ ์
for (int i = 0; i < answers.length; i++) {
// ์ํฌ์๋ค ๊ธธ์ด์ answer์ ๊ธธ์ด ๋ง์ถฐ์ฃผ๊ธฐ
one = Arrays.copyOf(one,answers.length);
two = Arrays.copyOf(two,answers.length);
three = Arrays.copyOf(three,answers.length);
// ์ํฌ์๋ค ๊ฐ์ด 0 ์ผ๊ฒฝ์ฐ ๊ฐ์ด ๋ฐ๋ณต ๋๋๋ก ๋ฃ์ด์ฃผ๊ธฐ
if(one[i] == 0){
one[i] = one[i%5];
}if(two[i] == 0){
two[i] = two[i%8];
}if(three[i] == 0){
three[i] = three[i%10];
}
// ์ํฌ์๋ค์ ์ ์ ๊ณ์ฐ
if(answers[i] == one[i]){
arr[0]++;
}if (answers[i] == two[i]) {
arr[1]++;
}if (answers[i] == three[i]){
arr[2]++;
}
}
for (int i = 0; i < arr.length; i++) {
// ์ต๋ ์ ์ ๊ตฌํ๊ธฐ
int max = Arrays.stream(arr).max().getAsInt();
// ์ต๋ ์ ์๋ฅผ ๊ฐ์ง ์ธ์ ์ ๋งํผ
if (max == arr[i]){
// ๋ฆฌ์คํธ์ add
list.add(i+1);
list.sort((a,b) -> a-b);
}
}
return list.toArray(new Integer[0]);
}
}
- ์ํฌ์๋ค์ ๊ฐ๊ฐ ๊ธธ์ด๋งํผ ๋ฐฐ์ด์ด ๋ฐ๋ณต๋จ
- ์ํฌ์๋ค์ ๊ธธ์ด๊ฐ answers ์ ๊ธธ์ด๋ณด๋ค ์์ ๋ ์ํฌ์[i] == answers[i] ๋น๊ตํ ๊ฒฝ์ฐ index bounds ์๋ฌ ๋ฐ์ํ๊ธฐ ๋๋ฌธ์ copy of ์ฌ์ฉํ์ฌ answers์ ๊ธธ์ด์ ๊ฐ๊ฒ ๋ง๋ค์ด ์ค
- ์ถ๊ฐ ๋ index์ ์ด๊ธฐ๊ฐ์ด 0์ด๊ธฐ ๋๋ฌธ์ ์ํฌ์๋ค[i] ์ ์ํฌ์๋ค[i%์๋ ์ํฌ์๋ค ๊ธธ์ด] ๋ก ํด์ ๋ฃ์ด์ฃผ๋ฉด ์ฒ์๊ฐ ๋ถํฐ ๋์ ๋จ
- ๊ทธ ํ ์ํฌ์๋ค์ ๋ชจ๋ ๊ฐ์ answers ์ ๊ฐ๊ณผ ๋น๊ตํ๊ณ ๊ฐ ์ํฌ์๋ค ์ ์ ๊ณ์ฐํ๊ธฐ
- ์ต๋ ์ ์๋ฅผ ๊ตฌํ๊ณ ์ต๋ ์ ์๊ฐ ๊ฐ ์ํฌ์๋ค์ ์ ์์ ๊ฐ๋ค๋ฉด ๋ฆฌ์คํธ์ ๋ฃ์ด์ค ํ ์ ๋ ฌํ๊ธฐ
- ๋ฐํ๊ฐ์ด int[] ๋ฅผ Integer[]๋ก ๋ฐ๊ฟ๋ฒ๋ ธ๋ค..
์ฒ์๋ถํฐ ์ํฌ์๋ค์ ๊ธธ์ด๋ฅผ answers์ ๊ธธ์ด๋ ๊ฐ๊ฒ ๋ง๋ค์ด์ฃผ์ง ์๊ณ answers[i] ๊ฐ๊ณผ ์ํฌ์๋ค[i%๊ฐ ์ํฌ์๋ค ๊ธธ์ด]๊ฐ์ด ๊ฐ์์ง๋ง
๋น๊ตํ๋ฉด ๋์๋๋ฐ ํผ์ ์ด์ํ๊ฒ ํ ๋ค...
์ด์งํผ ๋ฐ์์ ์๋ ๊ธธ์ด๋ก ๋๋ ์ ๋์ ํ ๊ฑฐ๋ฉด ์ฒจ ๋ถํฐ copyํ์ง ์๊ณ ๊ฐ ๋น๊ตํ๋ฉด ๋๋๊ฑธ ์ ๊ทธ๋ ๊ฒ ์๊ฐ์ด ์๋ ๊น ใ ใ ใ
๋ค๋ฅธ ์ฌ๋๋ค ํ์ด ๋ณด๊ณ ์..... ๊นจ๋ฌ์์ ์ป์
์ํ์ ์ฝํ๊ฑด์ง.. ์ฌ๊ณ ํ๋ก๊ฐ ์์ง ๋ถ์กฑํ๋ฏ...ใ ใ