๐โ๏ธ ๋ฌธ์ ์ค๋ช
๊ณผ์ผ ์ฅ์๊ฐ ์ฌ๊ณผ ์์๋ฅผ ํฌ์ฅํ๊ณ ์์ต๋๋ค. ์ฌ๊ณผ๋ ์ํ์ ๋ฐ๋ผ 1์ ๋ถํฐ k์ ๊น์ง์ ์ ์๋ก ๋ถ๋ฅํ๋ฉฐ, k์ ์ด ์ต์ํ์ ์ฌ๊ณผ์ด๊ณ 1์ ์ด ์ตํํ์ ์ฌ๊ณผ์ ๋๋ค. ์ฌ๊ณผ ํ ์์์ ๊ฐ๊ฒฉ์ ๋ค์๊ณผ ๊ฐ์ด ๊ฒฐ์ ๋ฉ๋๋ค.
- ํ ์์์ ์ฌ๊ณผ๋ฅผ m๊ฐ์ฉ ๋ด์ ํฌ์ฅํฉ๋๋ค.
- ์์์ ๋ด๊ธด ์ฌ๊ณผ ์ค ๊ฐ์ฅ ๋ฎ์ ์ ์๊ฐ p (1 ≤ p ≤ k)์ ์ธ ๊ฒฝ์ฐ, ์ฌ๊ณผ ํ ์์์ ๊ฐ๊ฒฉ์ p * m ์ ๋๋ค.
๊ณผ์ผ ์ฅ์๊ฐ ๊ฐ๋ฅํ ๋ง์ ์ฌ๊ณผ๋ฅผ ํ์์ ๋, ์ป์ ์ ์๋ ์ต๋ ์ด์ต์ ๊ณ์ฐํ๊ณ ์ ํฉ๋๋ค.(์ฌ๊ณผ๋ ์์ ๋จ์๋ก๋ง ํ๋งคํ๋ฉฐ, ๋จ๋ ์ฌ๊ณผ๋ ๋ฒ๋ฆฝ๋๋ค)
์๋ฅผ ๋ค์ด, k = 3, m = 4, ์ฌ๊ณผ 7๊ฐ์ ์ ์๊ฐ [1, 2, 3, 1, 2, 3, 1]์ด๋ผ๋ฉด, ๋ค์๊ณผ ๊ฐ์ด [2, 3, 2, 3]์ผ๋ก ๊ตฌ์ฑ๋ ์ฌ๊ณผ ์์ 1๊ฐ๋ฅผ ๋ง๋ค์ด ํ๋งคํ์ฌ ์ต๋ ์ด์ต์ ์ป์ ์ ์์ต๋๋ค.
- (์ต์ ์ฌ๊ณผ ์ ์) x (ํ ์์์ ๋ด๊ธด ์ฌ๊ณผ ๊ฐ์) x (์์์ ๊ฐ์) = 2 x 4 x 1 = 8
์ฌ๊ณผ์ ์ต๋ ์ ์ k, ํ ์์์ ๋ค์ด๊ฐ๋ ์ฌ๊ณผ์ ์ m, ์ฌ๊ณผ๋ค์ ์ ์ score๊ฐ ์ฃผ์ด์ก์ ๋, ๊ณผ์ผ ์ฅ์๊ฐ ์ป์ ์ ์๋ ์ต๋ ์ด์ต์ returnํ๋ solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
โ ์ ํ์ฌํญ
- 3 ≤ k ≤ 9
- 3 ≤ m ≤ 10
- 7 ≤ score์ ๊ธธ์ด ≤ 1,000,000
- 1 ≤ score[i] ≤ k
- ์ด์ต์ด ๋ฐ์ํ์ง ์๋ ๊ฒฝ์ฐ์๋ 0์ return ํด์ฃผ์ธ์.
๐ก ์ ์ถ๋ ฅ ์
์ ์ถ๋ ฅ ์ #1
- ๋ฌธ์ ์ ์์์ ๊ฐ์ต๋๋ค.
์ ์ถ๋ ฅ ์ #2
- ๋ค์๊ณผ ๊ฐ์ด ์ฌ๊ณผ ์์๋ฅผ ํฌ์ฅํ์ฌ ๋ชจ๋ ํ๋ฉด ์ต๋ ์ด์ต์ ๋ผ ์ ์์ต๋๋ค.
๋ฐ๋ผ์ (1 x 3 x 1) + (2 x 3 x 1) + (4 x 3 x 2) = 33์ returnํฉ๋๋ค.
๐ฉ ๋ด ํ์ด
import java.util.*;
class Solution {
public int solution(int k, int m, int[] score) {
int answer = 0;
// ๋ฐฐ์ด ์ ๋ ฌ
Arrays.sort(score);
for (int i = score.length-1; i >=0 ; i--) {
if ((score.length - i) % m == 0) {
answer += score[i]*m;
}
}
return answer;
}
}
์ ๋ ฌ ํ์, ํฐ ์๋ถํฐ ์๋ฅด๊ธฐ๋ก ํ์ดํ๋ค.
'Back-end > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค] ์์ ์ฐพ๊ธฐ (java) (0) | 2023.08.13 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค] ์ฝ๋ผ ๋ฌธ์ (java) (0) | 2023.08.12 |
[ํ๋ก๊ทธ๋๋จธ์ค] ๋ ๊ฐ ๋ฝ์์ ๋ํ๊ธฐ (java) (0) | 2023.08.08 |
[ํ๋ก๊ทธ๋๋จธ์ค] ๋ฌธ์์ด ๋ด ๋ง์๋๋ก ์ ๋ ฌํ๊ธฐ (java) (0) | 2023.08.06 |
[ํ๋ก๊ทธ๋๋จธ์ค] ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์ (java) (0) | 2023.08.04 |