ํ๋ก๊ทธ๋๋จธ์ค ํ์์๋ ๊ธฐ๋ฅ ๊ฐ์ ์์ ์ ์ํ ์ค์ ๋๋ค. ๊ฐ ๊ธฐ๋ฅ์ ์ง๋๊ฐ 100%์ผ ๋ ์๋น์ค์ ๋ฐ์ํ ์ ์์ต๋๋ค.
๋, ๊ฐ ๊ธฐ๋ฅ์ ๊ฐ๋ฐ์๋๋ ๋ชจ๋ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ๋ค์ ์๋ ๊ธฐ๋ฅ์ด ์์ ์๋ ๊ธฐ๋ฅ๋ณด๋ค ๋จผ์ ๊ฐ๋ฐ๋ ์ ์๊ณ , ์ด๋ ๋ค์ ์๋ ๊ธฐ๋ฅ์ ์์ ์๋ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋ ๋ ํจ๊ป ๋ฐฐํฌ๋ฉ๋๋ค.
๋จผ์ ๋ฐฐํฌ๋์ด์ผ ํ๋ ์์๋๋ก ์์ ์ ์ง๋๊ฐ ์ ํ ์ ์ ๋ฐฐ์ด progresses์ ๊ฐ ์์ ์ ๊ฐ๋ฐ ์๋๊ฐ ์ ํ ์ ์ ๋ฐฐ์ด speeds๊ฐ ์ฃผ์ด์ง ๋ ๊ฐ ๋ฐฐํฌ๋ง๋ค ๋ช ๊ฐ์ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋๋์ง๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์ธ์.
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] |
์ฒซ ๋ฒ์งธ ๊ธฐ๋ฅ์ 93% ์๋ฃ๋์ด ์๊ณ ํ๋ฃจ์ 1%์ฉ ์์
์ด ๊ฐ๋ฅํ๋ฏ๋ก 7์ผ๊ฐ ์์
ํ ๋ฐฐํฌ๊ฐ ๊ฐ๋ฅํฉ๋๋ค.
๋ ๋ฒ์งธ ๊ธฐ๋ฅ์ 30%๊ฐ ์๋ฃ๋์ด ์๊ณ ํ๋ฃจ์ 30%์ฉ ์์
์ด ๊ฐ๋ฅํ๋ฏ๋ก 3์ผ๊ฐ ์์
ํ ๋ฐฐํฌ๊ฐ ๊ฐ๋ฅํฉ๋๋ค. ํ์ง๋ง ์ด์ ์ฒซ ๋ฒ์งธ ๊ธฐ๋ฅ์ด ์์ง ์์ฑ๋ ์ํ๊ฐ ์๋๊ธฐ ๋๋ฌธ์ ์ฒซ ๋ฒ์งธ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋๋ 7์ผ์งธ ๋ฐฐํฌ๋ฉ๋๋ค.
์ธ ๋ฒ์งธ ๊ธฐ๋ฅ์ 55%๊ฐ ์๋ฃ๋์ด ์๊ณ ํ๋ฃจ์ 5%์ฉ ์์
์ด ๊ฐ๋ฅํ๋ฏ๋ก 9์ผ๊ฐ ์์
ํ ๋ฐฐํฌ๊ฐ ๊ฐ๋ฅํฉ๋๋ค.
๋ฐ๋ผ์ 7์ผ์งธ์ 2๊ฐ์ ๊ธฐ๋ฅ, 9์ผ์งธ์ 1๊ฐ์ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋ฉ๋๋ค.
๋ชจ๋ ๊ธฐ๋ฅ์ด ํ๋ฃจ์ 1%์ฉ ์์ ์ด ๊ฐ๋ฅํ๋ฏ๋ก, ์์ ์ด ๋๋๊ธฐ๊น์ง ๋จ์ ์ผ์๋ ๊ฐ๊ฐ 5์ผ, 10์ผ, 1์ผ, 1์ผ, 20์ผ, 1์ผ์ ๋๋ค. ์ด๋ค ๊ธฐ๋ฅ์ด ๋จผ์ ์์ฑ๋์๋๋ผ๋ ์์ ์๋ ๋ชจ๋ ๊ธฐ๋ฅ์ด ์์ฑ๋์ง ์์ผ๋ฉด ๋ฐฐํฌ๊ฐ ๋ถ๊ฐ๋ฅํฉ๋๋ค.
๋ฐ๋ผ์ 5์ผ์งธ์ 1๊ฐ์ ๊ธฐ๋ฅ, 10์ผ์งธ์ 3๊ฐ์ ๊ธฐ๋ฅ, 20์ผ์งธ์ 2๊ฐ์ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋ฉ๋๋ค.
๋๋ ์ธ๋ฑ์ค ๋ณ์๋ฅผ ํ๋ ๋ง๋ค์ด์ ๋ฌธ์ ์ ์ ๊ทผ์ ํด๋ณด์๋ค.
ํ์ฌ ์ธ๋ฑ์ค ์์์ ๊ฐ์ด 100 ์ด์์ด๋ฉด, ์ฆ, ์ง๋๊ฐ 100% ์ด์์ด๋ผ๋ฉด, ์ง๋๊ฐ 100% ์๋ ๊ฐ์ ๋ง๋ ๋๊น์ง, ์ธ๋ฑ์ค๋ฅผ ์ฆ๊ฐ์์ผ ์ฃผ๋ฉด์ ๋์์ ๋ฐฐํฌ๋ ๊ธฐ๋ฅ์ ๊ฐ์๋ฅผ 1์ฉ ์ฆ๊ฐ์์ผ์ฃผ๋ฉด ๋ ๊ฒ์ด๋ผ ์๊ฐํ๊ณ ์ฝ๋๋ฅผ ์์ฑํ๋ค.
import java.util.*;
class Solution {
public ArrayList<Integer> solution(int[] progresses, int[] speeds) {
int releaseIndex = 0;
ArrayList<Integer> answer = new ArrayList<>();
while (releaseIndex < progresses.length) {
for (int j = 0; j < progresses.length; j++) {
progresses[j] += speeds[j];
}
int count = 0;
while (releaseIndex < progresses.length && progresses[releaseIndex] >= 100) {
releaseIndex++;
count ++;
}
if (count > 0) {
answer.add(count);
}
}
return answer;
}
}
์ฐ์ ๋์์ ๋ฐฐ๋ณด๋ ๊ธฐ๋ฅ์ ๊ฐ์๋ฅผ ๋ด๋ ArrayList answer
๋ฅผ ์ ์ธํด ์ฃผ์๋ค.
progresses
๋ฅผ ์์ฐจ์ ์ผ๋ก ํ์ํ๊ธฐ ์ํด releaseIndex
๋ ์ ์ธํด ์ฃผ์๊ณ , progresses
์ ๊ธธ์ด๋งํผ ์ํํ๋๋ก ๋ฐ๋ณต๋ฌธ์ ๋ง๋ค์๋ค.
์ผ๋จ, ์์
์ ํ ๋ฒ ์งํ์์ผ ์ฃผ๊ธฐ ์ํด ๊ฐ๊ฐ์ ์ง๋์ ๊ฐ๊ฐ์ speed๋ฅผ ๋ํด์ฃผ์๋ค.
์ด์ , ๋ง์ฝ, releaseIndex
๊ฐ ๊ฐ๋ฆฌํค๋ ์ง๋๊ฐ 100%๋ผ๋ฉด,
๊ทธ๋ฆฌ๊ณ , ๊ทธ ๋ค์ ์ง๋๊ฐ 100%์ธ ์์๊ฐ ๋ ์กด์ฌํ๋ค๋ฉด,
๊ทธ ๊ฐ์๋งํผ ๋ฐฐํฌ๋ฅผ ์์ผ์ฃผ์ด์ผ ํ๋ค.
์ด๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํด ํ์ฌ releaseIndex
๊ฐ ๊ฐ๋ฆฌํค๋ ์ง๋๊ฐ 100% ์ด์์ด๋ผ๋ ์กฐ๊ฑด์ ๋ฐ๋ณต๋ฌธ์ ๋ง๋ค์ด releaseIndex
๊ฐ ๋ค์ ์ธ๋ฑ์ค๋ก ์ด๋ํ๋๋ก 1์ ์ฆ๊ฐ์์ผ ์ฃผ์๊ณ , ๋ฐฐํฌ๋ ๊ธฐ๋ฅ์ ๊ฐ์๋ฅผ ๋ํ๋ด๋ count
๋ณ์์๋ 1์ ์ฆ๊ฐ์์ผ ์ฃผ์๋ค.
๊ทธ๋ ๊ฒ ํ ๋ฒ์ ๋ฐฐํฌ๋ ๊ธฐ๋ฅ์ ๊ฐ์๋ฅผ answer
์ ์ถ๊ฐํด์ค์ผ๋ก์จ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์๋ค!
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
class Solution {
public int[] solution(int[] progresses, int[] speeds) {
// ๊ฐ ๊ธฐ๋ฅ์ ๊ฐ๋ฐ์ด ์๋ฃ๋๋ ๋ฐ ํ์ํ ๋ ์๋ฅผ ์ ์ฅํ ๋ฆฌ์คํธ
List<Integer> days = new ArrayList<>();
// ๊ฐ ๊ธฐ๋ฅ๋ณ๋ก ๊ฐ๋ฐ ์๋ฃ๊น์ง ๊ฑธ๋ฆฌ๋ ๋ ์๋ฅผ ๊ณ์ฐ
for (int i = 0; i < progresses.length; i++) {
int progress = progresses[i]; // ํ์ฌ ์์
์ ์ง๋
int speed = speeds[i]; // ํ์ฌ ์์
์ ๊ฐ๋ฐ ์๋
// ์์
์๋ฃ๊น์ง ๊ฑธ๋ฆฌ๋ ๋ ์ ๊ณ์ฐ
int daysToComplete = (int) Math.ceil((100 - progress) / speed);
// ๋ฆฌ์คํธ์ ๊ณ์ฐ๋ ๋ ์ ์ถ๊ฐ
days.add(daysToComplete);
}
// ๊ฐ๋ฐ ์๋ฃ๊น์ง ๊ฑธ๋ฆฌ๋ ๋ ์๋ฅผ ํ์ ์ ์ฅ
Queue<Integer> queue = new LinkedList<>(days);
// ๊ฐ ๋ฐฐํฌ์ผ์ ๋ช ๊ฐ์ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋๋์ง๋ฅผ ์ ์ฅํ ๋ฆฌ์คํธ
List<Integer> result = new ArrayList<>();
// ํ๊ฐ ๋น ๋๊น์ง ๋ฐ๋ณต
while (!queue.isEmpty()) {
// ํ์ฌ ์ฒ๋ฆฌํ ๊ธฐ๋ฅ์ ๊ฐ๋ฐ ์๋ฃ๊น์ง ๊ฑธ๋ฆฌ๋ ๋ ์
int currentDay = queue.poll();
int count = 1; // ํ์ฌ ๊ธฐ๋ฅ์ ํฌํจํ์ฌ ๋ฐฐํฌ๋๋ ๊ธฐ๋ฅ ์ (์ต์ 1๊ฐ๋ ๋ฐฐํฌ๋จ)
// ํ์ฌ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋ ๋ ์ ๋ฐฐํฌ๋ ์ ์๋ ํ์ ๊ธฐ๋ฅ๋ค ํ์ธ
while (!queue.isEmpty() && queue.peek() <= currentDay) {
queue.poll(); // ํ์ ๊ธฐ๋ฅ์ ํ์์ ์ ๊ฑฐ
count++; // ๋ฐฐํฌ๋๋ ๊ธฐ๋ฅ ์ ์ฆ๊ฐ
}
// ๋ฐฐํฌ๋๋ ๊ธฐ๋ฅ์ ์๋ฅผ ๊ฒฐ๊ณผ ๋ฆฌ์คํธ์ ์ถ๊ฐ
result.add(count);
}
// ๊ฒฐ๊ณผ ๋ฆฌ์คํธ๋ฅผ ๋ฐฐ์ด๋ก ๋ณํํ์ฌ ๋ฐํ
return result.stream().mapToInt(i -> i).toArray();
}
}
์๊ฑด ์ค๋ ์ธ์ ์์ ๋ณธ ๋ค๋ฅธ ๋ถ์ ์ฝ๋์ด๋ค
๊ฐ ๊ธฐ๋ฅ๋ณ๋ก ๊ฐ๋ฐ ์๋ฃ๊น์ง ๊ฑธ๋ฆฌ๋ ๋ ์๋ฅผ ๋จผ์ ๊ณ์ฐํ ๋ค์,
ํ๋ฅผ ์ฌ์ฉํด ํ์ฌ ๊ธฐ๋ฅ๊ณผ ํ์ ๊ธฐ๋ฅ์ ๋ฐฐํฌ ๊ฐ๋ฅ ์ฌ๋ถ๋ฅผ ๋ฐ์ง๋ฉด์ ํ์์ ์์๋ค์ ํ๋์ฉ ์ ๊ฑฐํ๋ฉฐ ์ซ์๋ฅผ ์นด์ดํธ ํด์ฃผ๋ ๋ฐฉ์์ด๋ค.
๋ ์ง๋ฅผ ๋ฏธ๋ฆฌ ๊ณ์ฐํด์ ํธ๋ ๋ฐฉ๋ฒ๋ ์์๋ค๋..!
์ค๋๋ ํ ์ ๋ฐฐ์ฐ๊ณ ๊ฐ๋๋ค!๐ช
๐๐๐