โฐ๋ฌธ์
์์ด ์ ์์ ์ํ ์ ์์ ํ๊ท ์ ์๋ฅผ ๊ธฐ์ค์ผ๋ก ํ์๋ค์ ๋ฑ์๋ฅผ ๋งค๊ธฐ๋ ค๊ณ ํฉ๋๋ค. ์์ด ์ ์์ ์ํ ์ ์๋ฅผ ๋ด์ 2์ฐจ์ ์ ์ ๋ฐฐ์ด score๊ฐ ์ฃผ์ด์ง ๋, ์์ด ์ ์์ ์ํ ์ ์์ ํ๊ท ์ ๊ธฐ์ค์ผ๋ก ๋งค๊ธด ๋ฑ์๋ฅผ ๋ด์ ๋ฐฐ์ด์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- 0 ≤ score[0], score[1] ≤ 100
- 1 ≤ score์ ๊ธธ์ด ≤ 10
- score์ ์์ ๊ธธ์ด๋ 2์ ๋๋ค.
- score๋ ์ค๋ณต๋ ์์๋ฅผ ๊ฐ์ง ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
score | result |
[[80, 70], [90, 50], [40, 70], [50, 80]] | [1, 2, 4, 3] |
[[80, 70], [70, 80], [30, 50], [90, 100], [100, 90], [100, 100], [10, 30]] | [4, 4, 6, 2, 2, 1, 7] |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- ํ๊ท ์ ๊ฐ๊ฐ 75, 70, 55, 65 ์ด๋ฏ๋ก ๋ฑ์๋ฅผ ๋งค๊ฒจ [1, 2, 4, 3]์ returnํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- ํ๊ท ์ ๊ฐ๊ฐ 75, 75, 40, 95, 95, 100, 20 ์ด๋ฏ๋ก [4, 4, 6, 2, 2, 1, 7] ์ returnํฉ๋๋ค.
- ๊ณต๋ 2๋ฑ์ด ๋ ๋ช , ๊ณต๋ 4๋ฑ์ด 2๋ช ์ด๋ฏ๋ก 3๋ฑ๊ณผ 5๋ฑ์ ์์ต๋๋ค.
๐กํ์ด
์ฒ์์๋ ๊ฐ ํ์์ ํ๊ท ์ ๋ฐฐ์ด๋ก ์ ์ฅํ๊ณ ์ ๋ ฌ์ ํ๋ คํ๋๋, ๊ทธ๋ฌ๋ฉด ํ๊ท ์ด ๊ฐ์ ํ์๋ผ๋ฆฌ ๊ฐ์ ๋ฑ์๋ก ์ฒ๋ฆฌํ๊ธฐ๊ฐ ์ด๋ ค์์ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ์๊ฐํด๋ณด์๋ค.
์ ์ฒด๋ฅผ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๋๋ฉด์ ํ๊ท ๊ฐ์ ๋น๊ตํด ๊ฐ๊ฐ์ ๋ฑ์๋ฅผ ๋งค๊ฒจ์ฃผ๋ ๋ฐฉ์์ผ๋ก ํ๋ค.
1. score์ ๊ฐ ์ ์์ ํ๊ท ์ ์ ์ฅํ ๋ฐฐ์ด์ ์์ฑ ํ ๊ฐ์ ์ ์ฅํ๋ค. ( avg[] )
2. ์ด์ค for๋ฌธ์ผ๋ก ๋ฐฐ์ด์ ๋๋ฉด์ ์๊ธฐ ์์ ์ด์ธ์ ๊ฐ๋ณด๋ค ํฐ ๊ฐ์ด ์๋ค๋ฉด rank +1์ ํด์ฃผ์ด ๋ฑ์๋ฅผ ๋ฎ์ถ๋ค.
โญ์ ์ถ ์ฝ๋
class Solution {
public int[] solution(int[][] score) {
int[] answer = new int[score.length];
double[] avg = new double[score.length]; //๊ฐ ํ์์ ํ๊ท ์ ์ฅ
for(int i=0; i<score.length; i++) {
avg[i] = (double)(score[i][0] + score[i][1]) / 2;
}
for(int i=0; i<avg.length; i++) {
int rank = 1;
for(int j=0; j<avg.length; j++) {
if(avg[i] < avg[j]) {
rank++;
}
}
answer[i] = rank;
}
return answer;
}
}
ํ๋ค๋ณด๋ฉด ๋ ๊ฐ๋จํ ๋ฐฉ๋ฒ์ด ์์์๋ ์์ง ๋ฌธ์ ํด๊ฒฐ์ ์ํ ์ฌ๊ณ ๋ฐฉ์์ด ๋ถ์กฑํ ๊ฒ ๊ฐ์ ๋ ๋ง์ ๋ฌธ์ ๋ฅผ ํ์ด๋ณด๋ฉฐ ๋ ธ๋ ฅํด์ผํ ๊ฒ ๊ฐ๋ค.
'๐ Algorithm > ํ๋ก๊ทธ๋๋จธ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Programmers] ํน์ดํ ์ ๋ ฌ(์๋ฐ) (1) | 2023.10.27 |
---|---|
[Programmers] ๋ฌ๋ฆฌ๊ธฐ ๊ฒฝ์ฃผ(์๋ฐ) (1) | 2023.10.13 |
[Programmers] ์น์์ด(2)(์๋ฐ) (0) | 2023.06.12 |
[Programmers] ์ต์์ง์ฌ๊ฐํ(์๋ฐ) (0) | 2023.05.15 |
[Programmers] ์ด์ง์ ๋ํ๊ธฐ(์๋ฐ) (0) | 2023.04.25 |