โค๏ธ Problem
- ๋ฌธ์
๊ณผ์ผ ์ฅ์๊ฐ ์ฌ๊ณผ ์์๋ฅผ ํฌ์ฅํ๊ณ ์์ต๋๋ค. ์ฌ๊ณผ๋ ์ํ์ ๋ฐ๋ผ 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 ํด์ฃผ์ธ์.
- ์ ์ถ๋ ฅ ์ & ์ค๋ช
no | k | m | score | return |
1 | 3 | 4 | [1, 2, 3, 1, 2, 3, 1] | 8 |
2 | 4 | 3 | [4, 1, 2, 2, 4, 4, 4, 4, 1, 2, 4, 2] | 33 |
- ๋ฌธ์ ์ ์์์ ๊ฐ์ต๋๋ค.
- ๋ค์๊ณผ ๊ฐ์ด ์ฌ๊ณผ ์์๋ฅผ ํฌ์ฅํ์ฌ ๋ชจ๋ ํ๋ฉด ์ต๋ ์ด์ต์ ๋ผ ์ ์์ต๋๋ค.
์ฌ๊ณผ ์์ ๊ฐ๊ฒฉ
[1, 1, 2] 1 x 3 = 3
[2, 2, 2] 2 x 3 = 6
[4, 4, 4] 4 x 3 = 12
[4, 4, 4] 4 x 3 = 12
๋ฐ๋ผ์ (1 x 3 x 1) + (2 x 3 x 1) + (4 x 3 x 2) = 33์ returnํฉ๋๋ค.
๐ Solution
ํ์ด 1
import java.util.Arrays;
class Solution {
public int solution(int k, int m, int[] score) {
Arrays.sort(score);
int price = 0;
int length = score.length-m;
while(length >= 0) {
int lowest = score[length];
price += lowest * m;
length = length-m;
}
return price;
}
}
์ฒ๋ฆฌ์๋ GOOD๐
ํ์ด 2
import java.util.Arrays;
class Solution {
public int solution(int k, int m, int[] score) {
int price = 0;
Arrays.sort(score);
for(int i = score.length; i >= m; i -= m){
price += score[i-m] * m;
}
return price;
}
}
์ฒ๋ฆฌ์๋ GOOD๐
๐ Comment
ํ์ด 1์ ์ค๋ช ํ๋ฉด ๋จผ์ , int[] score๋ฅผ Arrays.sort๋ฅผ ์ฌ์ฉํ์ฌ ์ ๋ ฌํ๋ค. ๊ทธ ์ด์ ๋ ๋ฑ๊ธ์ด ์์ฐจ์ ์ผ๋ก ์ฆ๊ฐํ๋๋ก ํ์ฌ ๋ฐฐ์ด์ ๋์์๋ถํฐ ์์์ ๋ด๊ธฐ ์ํจ์ด์๋ค. ๋ฌผ๋ก ์ค๋ฆ์ฐจ์์ด ์๋ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํด์ ๋ฐฐ์ด์ ์์์๋ถํฐ ๋์ด๊ฐ๋๊ฒ ๋ ผ๋ฆฌ์ ์ผ๋ก ์ดํด๊ฐ ๋ ์ฝ์ง๋ง, ๊ทธ๋ ๊ฒ ํ๋ฉด Collections.reverseOrder();๋ฅผ ์ฌ์ฉํด์ผํ๋ฏ๋ก Integer๋ก ๋ณํํ๋ ์์ ์ด ํ์ํ๋ค. ๊ตณ์ด ๋ถํ์ํ ์์ ์ ์ถ๊ฐํ๊ธฐ๊ฐ ์ซ์ด ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค.
๊ทธ ๋ค์, ๊ฐ๊ฒฉ์ ๋์ ์ํฌ int price๋ฅผ ์ ์ธํ๊ณ ์ฌ๊ณผ ๊ฐ์๋ฅผ ๋ด์ ๋ณ์ int length์ score.length-m;์ ๋ฃ์๋ค. m์ ๋บ ์ด์ ๋ ๋ฐฐ์ด์ ๋์์๋ถํฐ m๊ฐ ์์ ์๋ ๋ฑ๊ธ์ ์ฐ์ถํ๊ธฐ ์ํด์์๋ค. ํด๋น ๋ฐ์ค์ ์ต์ ๋ฑ๊ธ์ด ๋ค์์๋ถํฐ m๋ฒ์งธ ์ธ๋ฑ์ค๋ฅผ ๊ฐ๊ธฐ ๋๋ฌธ์ด๋ค.
๊ทธ ๋ค์, while ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํด์ length๊ฐ 0๋ณด๋ค ํด ๋๊น์ง ๋ฐ๋ณตํ๋๋ก ํ์๋๋ฐ ์ด๋ m๊ฐ์ฉ ํ ์์๋ฅผ ๋ง๋ค๊ธฐ ๋๋ฌธ์ ๋ฐ๋ณต๋ฌธ ์์์ length๋ฅผ ๋ฐ๋ณต๋ฌธ์ด ๋๋ ๋์ length-m;์ ๊ฐ์ ๋ฃ์ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ๋ฆฌ๊ณ int lowest๋ length ์ธ๋ฑ์ค๋ฅผ ๊ฐ์ง๋ score์ ๊ฐ์ ๊ฐ๋๋ก ํ์ฌ ํด๋น ์์์ ๊ฐ์ฅ ๋ฎ์ ๋ฑ๊ธ์ด ๋ค์ด๊ฐ๋๋ก ํ์๋ค. int price์๋ ์ฌ๊ณผ๋ฑ๊ธ(lowest)*์ฌ๊ณผ๊ฐ์(m)์ ๋์ ์์ผฐ๋ค. ์ด๋ ๊ฒ ํ๋ฉด ์์ฝ๊ฒ price๋ฅผ ๊ตฌํ ์ ์๋ค.
ํ์ด 1๊ณผ ํ์ด 2์ ํ๋ก์ธ์ค๋ ๋์ผํ๋, while๋ฌธ์ ์ผ๋์ง์ for๋ฌธ์ ์ผ๋์ง ์ ๋์ ์ฐจ์ด๊ฐ ์๋ค.
'Programmers lv-1' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ฌธ์์ด ๋๋๊ธฐ - Java [์ฝ๋ฉํ ์คํธ ์ฐ์ต] (0) | 2023.01.02 |
---|---|
์ซ์ ์ง๊ฟ - Java [์ฝ๋ฉํ ์คํธ ์ฐ์ต] (0) | 2022.12.27 |
์คํจ์จ - Java [์ฝ๋ฉํ ์คํธ ์ฐ์ต] (0) | 2022.12.26 |
๊ฐ์ฅ ๊ฐ๊น์ด ๊ฐ์ ๊ธ์ - Java [์ฝ๋ฉํ ์คํธ ์ฐ์ต] (0) | 2022.12.23 |
์์ฃผํ์ง ๋ชปํ ์ ์ - Java [์ฝ๋ฉํ ์คํธ ์ฐ์ต] (0) | 2022.12.23 |
์ฝ๋ผ ๋ฌธ์ - Java [์ฝ๋ฉํ ์คํธ ์ฐ์ต] (0) | 2022.12.21 |
๋๊ธ