๋ฌธ์ ์ค๋ช
https://school.programmers.co.kr/learn/courses/30/lessons/42586
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก, ์ฑ์ฉ๊น์ง Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
ํ๋ก๊ทธ๋๋จธ์ค ํ์์๋ ๊ธฐ๋ฅ ๊ฐ์ ์์ ์ ์ํ ์ค์ ๋๋ค. ๊ฐ ๊ธฐ๋ฅ์ ์ง๋๊ฐ 100%์ผ ๋ ์๋น์ค์ ๋ฐ์ํ ์ ์์ต๋๋ค.
๋, ๊ฐ ๊ธฐ๋ฅ์ ๊ฐ๋ฐ์๋๋ ๋ชจ๋ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ๋ค์ ์๋ ๊ธฐ๋ฅ์ด ์์ ์๋ ๊ธฐ๋ฅ๋ณด๋ค ๋จผ์ ๊ฐ๋ฐ๋ ์ ์๊ณ , ์ด๋ ๋ค์ ์๋ ๊ธฐ๋ฅ์ ์์ ์๋ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋ ๋ ํจ๊ป ๋ฐฐํฌ๋ฉ๋๋ค.
๋จผ์ ๋ฐฐํฌ๋์ด์ผ ํ๋ ์์๋๋ก ์์ ์ ์ง๋๊ฐ ์ ํ ์ ์ ๋ฐฐ์ด progresses์ ๊ฐ ์์ ์ ๊ฐ๋ฐ ์๋๊ฐ ์ ํ ์ ์ ๋ฐฐ์ด speeds๊ฐ ์ฃผ์ด์ง ๋ ๊ฐ ๋ฐฐํฌ๋ง๋ค ๋ช ๊ฐ์ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋๋์ง๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์ธ์.
์ ํ ์ฌํญ
- ์์ ์ ๊ฐ์(progresses, speeds๋ฐฐ์ด์ ๊ธธ์ด)๋ 100๊ฐ ์ดํ์ ๋๋ค.
- ์์ ์ง๋๋ 100 ๋ฏธ๋ง์ ์์ฐ์์ ๋๋ค.
- ์์ ์๋๋ 100 ์ดํ์ ์์ฐ์์ ๋๋ค.
- ๋ฐฐํฌ๋ ํ๋ฃจ์ ํ ๋ฒ๋ง ํ ์ ์์ผ๋ฉฐ, ํ๋ฃจ์ ๋์ ์ด๋ฃจ์ด์ง๋ค๊ณ ๊ฐ์ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด ์ง๋์จ์ด 95%์ธ ์์ ์ ๊ฐ๋ฐ ์๋๊ฐ ํ๋ฃจ์ 4%๋ผ๋ฉด ๋ฐฐํฌ๋ 2์ผ ๋ค์ ์ด๋ฃจ์ด์ง๋๋ค.
์ ์ถ๋ ฅ ์
progresses | speeds | return |
[93, 30, 55] | [1, 30, 5] | [2, 1] |
[95, 90, 99, 99, 80, 99] | [1, 1, 1, 1, 1, 1] | [1, 3, 2] |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- ์ฒซ ๋ฒ์งธ ๊ธฐ๋ฅ์ 93% ์๋ฃ๋์ด ์๊ณ ํ๋ฃจ์ 1%์ฉ ์์ ์ด ๊ฐ๋ฅํ๋ฏ๋ก 7์ผ๊ฐ ์์ ํ ๋ฐฐํฌ๊ฐ ๊ฐ๋ฅํฉ๋๋ค.
- ๋ ๋ฒ์งธ ๊ธฐ๋ฅ์ 30%๊ฐ ์๋ฃ๋์ด ์๊ณ ํ๋ฃจ์ 30%์ฉ ์์
์ด ๊ฐ๋ฅํ๋ฏ๋ก 3์ผ๊ฐ ์์
ํ ๋ฐฐํฌ๊ฐ ๊ฐ๋ฅํฉ๋๋ค.
ํ์ง๋ง ์ด์ ์ฒซ ๋ฒ์งธ ๊ธฐ๋ฅ์ด ์์ง ์์ฑ๋ ์ํ๊ฐ ์๋๊ธฐ ๋๋ฌธ์ ์ฒซ ๋ฒ์งธ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋๋ 7์ผ์งธ ๋ฐฐํฌ๋ฉ๋๋ค. - ์ธ ๋ฒ์งธ ๊ธฐ๋ฅ์ 55%๊ฐ ์๋ฃ๋์ด ์๊ณ ํ๋ฃจ์ 5%์ฉ ์์ ์ด ๊ฐ๋ฅํ๋ฏ๋ก 9์ผ๊ฐ ์์ ํ ๋ฐฐํฌ๊ฐ ๊ฐ๋ฅํฉ๋๋ค.
- ๋ฐ๋ผ์ 7์ผ์งธ์ 2๊ฐ์ ๊ธฐ๋ฅ, 9์ผ์งธ์ 1๊ฐ์ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋ฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- ๋ชจ๋ ๊ธฐ๋ฅ์ด ํ๋ฃจ์ 1%์ฉ ์์ ์ด ๊ฐ๋ฅํ๋ฏ๋ก, ์์ ์ด ๋๋๊ธฐ๊น์ง ๋จ์ ์ผ์๋ ๊ฐ๊ฐ 5์ผ, 10์ผ, 1์ผ, 1์ผ, 20์ผ, 1์ผ์ ๋๋ค.
- ์ด๋ค ๊ธฐ๋ฅ์ด ๋จผ์ ์์ฑ๋์๋๋ผ๋ ์์ ์๋ ๋ชจ๋ ๊ธฐ๋ฅ์ด ์์ฑ๋์ง ์์ผ๋ฉด ๋ฐฐํฌ๊ฐ ๋ถ๊ฐ๋ฅํฉ๋๋ค.
- ๋ฐ๋ผ์ 5์ผ์งธ์ 1๊ฐ์ ๊ธฐ๋ฅ, 10์ผ์งธ์ 3๊ฐ์ ๊ธฐ๋ฅ, 20์ผ์งธ์ 2๊ฐ์ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋ฉ๋๋ค.
๋ด๊ฐ ์์ฑํ ์ฝ๋
import java.util.*;
class Solution {
public int[] solution(int[] progresses, int[] speeds) {
// ๊ฐ ์์
์ด ์๋ฃ๋๊ธฐ๊น์ง ๋จ์ ๋ ์ง๋ฅผ ์ ์ฅํ ํ ์์ฑ
Queue<Integer> queue = new LinkedList<>();
// ๋ฐฐํฌ ๋จ์๋ฅผ ์ ์ฅํ ๋ฆฌ์คํธ ์์ฑ
ArrayList<Integer> list = new ArrayList<>();
// ๋ฐ๋ณต๋ฌธ์ ํ์ฉํ์ฌ progresses์ speeds ๋ฐฐ์ด ์ํ
for (int i = 0; i < progresses.length; i++) {
// ๋ง์ฝ ๋๋จธ์ง๊ฐ 0์ธ ๊ฒฝ์ฐ
if ((100 - progresses[i]) % speeds[i] == 0) {
// ๊ทธ๋๋ก ๋๋๊ณ queue์ ๊ณ์ฐํ ๊ฒฐ๊ณผ ์ ์ฅ
queue.add((100 - progresses[i]) / speeds[i]);
} else {
// queue์ ๊ณ์ฐํ ๊ฒฐ๊ณผ์ +1 ํ ์ ์ฅ
queue.add((100 - progresses[i]) / speeds[i] + 1);
}
}
// queue์์ ๊บผ๋ธ ๊ฐ num์ ์ ์ฅ
int num = queue.poll();
// ํ์๋ฅผ ์ ์ฅํ count ๋ณ์ ์์ฑ
int count = 1;
// queue๊ฐ ๋น์ด์์ ๋๊น์ง ๋ฐ๋ณต
while (!queue.isEmpty()) {
// ๋ง์ฝ queue์ ์ต์์ ๊ฐ์ด num๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๊ฒฝ์ฐ
if (num >= queue.peek()) {
// count +1
count++;
// queue ์ต์์ ๊ฐ ๊บผ๋ด๊ธฐ
queue.poll();
} else {
// ํ์ฌ count๋ฅผ list์ ์ ์ฅ
list.add(count);
// count๋ฅผ 1๋ก ์ด๊ธฐํ
count = 1;
// num์ queue ์ต์์ ๊ฐ ๊บผ๋ด๊ธฐ
num = queue.poll();
}
}
// list์ count๊ฐ ์ ์ฅ
list.add(count);
// answer ๋ฐฐ์ด ์์ฑ
int[] answer = new int[list.size()];
// ๋ฐ๋ณต๋ฌธ์ ํ์ฉํ์ฌ answer ์ํ
for (int i = 0; i < answer.length; i++) {
// answer์ list ๊ฐ ์ ์ฅ
answer[i] = list.get(i);
}
// answer ๋ฐํ
return answer;
}
}
๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํด ์๊ฐํ ๋ฐฉํฅ
- ๋ชปํ์ด์ ๋ต ํ์ธํ๊ณ ์ดํดํ๋ฉด์ ํด๊ฒฐ,,ํ์ต๋๋ค,,
'๐งฉ ํ๋ก๊ทธ๋๋จธ์ค > ๐ต ์๊ณ ๋ฆฌ์ฆ ํ์ด(Java)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค/Java] H-index (0) | 2025.04.02 |
---|---|
[ ํ๋ก๊ทธ๋๋จธ์ค/Java ] ๊ฐ์ฅ ํฐ ์ (0) | 2025.04.01 |
[ ํ๋ก๊ทธ๋๋จธ์ค/Java ] ์์ฐ (1) | 2025.03.28 |
[ ํ๋ก๊ทธ๋๋จธ์ค/Java ] ๊ฐ์ ์ซ์๋ ์ซ์ด (1) | 2025.03.27 |
[ ํ๋ก๊ทธ๋๋จธ์ค/Java ] JadenCase ๋ฌธ์์ด ๋ง๋ค๊ธฐ (0) | 2025.03.27 |