๋ณธ๋ฌธ
๊ธฐ๋ฅ๊ฐ๋ฐ #์คํ/ํ #level2

๐ก ์คํ
import java.util.Arrays;
public class Run {
public static void main(String[] args) {
int[] inputs = { 93, 30, 55 };
int[] speed = { 1, 30, 5 };
// result: [2, 1]
System.out.println(Arrays.toString(new FuncDevelopment().solution(inputs, speed)));
}
}
๐ก ํ์ด
import java.util.ArrayList;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
public class FuncDevelopment {
public int[] solution(int[] progresses, int[] speeds) {
// Queue์ ๊ฐ ๊ธฐ๋ฅ๊ฐ๋ฐ์ ๊ฑธ๋ฆฌ๋ ์ผ์๋ฅผ ์ฝ์
ํ๋ค.
// progresses[i]๊ฐ speeds[i]์ ๋๋ ๋จ์ด์ง๋ฉด ๋ชซ์, ๊ทธ๋ ์ง ์๋ค๋ฉด ๋ชซ + 1์ ์ฝ์
ํด์ค๋ค.
Queue<Integer> queue = new ConcurrentLinkedQueue<>();
for (int i = 0; i < progresses.length; i++) {
queue.add(
(100 - progresses[i]) % speeds[i] == 0 ?
(100 - progresses[i]) / speeds[i] :
(100 - progresses[i]) / speeds[i] + 1);
}
// queue: [7, 3, 9]
System.out.println("queue: " + queue);
// whlie๋ฌธ์ด ์์ํ๊ธฐ ์ ์ queue์์ ์ฒซ๋ฒ์งธ์์๋ฅผ poll()ํด์ค๋ค.(๊ฐ์ฅ ์ฒ์ ๊ฐ๋ฐ๋๊ธฐ ์์ํ ๊ธฐ๋ฅ)
ArrayList<Integer> list = new ArrayList<>();
int prevFunc = queue.poll();
int numOfFuncs = 1;
// ์ฒซ๋ฒ์งธ์ ๊ธฐ๋ฅ์ ๊ฐ๋ฐํ๋ ๋ฐ์ ๊ฑธ๋ฆฌ๋ ์ผ์๊ฐ ๋ค์ ๊ธฐ๋ฅ์ ๊ฐ๋ฐํ๋ ๋ฐ ๊ฑธ๋ฆฌ๋ ์ผ์๋ณด๋ค ์ค๋๊ฑธ๋ฆฌ๊ฑฐ๋ ๊ฐ๋ค๋ฉด
// ์ฒซ๋ฒ์งธ์ ๊ธฐ๋ฅ์ ๋ฐฐํฌํ ๋ ๋ค์ ๊ธฐ๋ฅ๋ ๊ฐ์ด ๋ฐฐํฌํด์ผํ๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ numOfFuncs์ ๊ฐ์ 1์ฆ๊ฐ ์ํจ๋ค.
// ๋ง์ฝ ๊ทธ๋ ์ง ์๋ค๋ฉด (์์ ๊ธฐ๋ฅ๋ณด๋ค ๋ค์ ๊ธฐ๋ฅ์ ๊ฐ๋ฐํ๋ ๋ฐ ๋ ์ค๋ ๊ฑธ๋ฆฐ๋ค๋ฉด)
// ์์ ๊ธฐ๋ฅ์ ๋ฐฐํฌํ ๋๋ ํด๋น ๊ธฐ๋ฅ๋ง ๋ฐฐํฌํ๊ธฐ ๋๋ฌธ์ numOfFuncs๋ 1์ด ๋๋ค.
while (!queue.isEmpty()) {
int curFunc = queue.poll();
// prevFunc: 7, curFunc: 3
// prevFunc: 7, curFunc: 9
System.out.println("prevFunc: " + prevFunc + ", curFunc: " + curFunc);
if (prevFunc >= curFunc) {
numOfFuncs++;
} else {
list.add(numOfFuncs);
numOfFuncs = 1;
prevFunc = curFunc;
}
}
list.add(numOfFuncs);
int[] answer = new int[list.size()];
for (int i = 0; i < list.size(); i++) {
answer[i] = list.get(i);
}
return answer;
}
}
P.S. ConcurrentLinkedQueue
์๋ฐ์ java.util ์์ ์ ๊ณตํ๋ Queue ํด๋์ค๋ ๋ฉํฐ ์ค๋ ๋ ํ๊ฒฝ์์ ์๊ณ์์ญ(critical section)์ ๋ํ ๋๊ธฐํ๊ฐ ์ ์ฉ๋์ด ์์ง ์๋ค.
๋ฌด์จ ๋ง์ด๋,
์ฌ๋ฌ ๊ฐ์ ์ฐ๋ ๋์์ ํ๋์ Queue ๊ฐ์ฒด์ ๋ค์ด์๋ ๋ฐ์ดํฐ๋ฅผ ๊บผ๋ด๊ธฐ ์ํด queue.poll() ๋ฉ์๋๋ฅผ ํธ์ถํ ๊ฒฝ์ฐ, ๋์ผํ ์คํ ๊ฒฐ๊ณผ๊ฐ ๋ํ๋ ์ ์๋ค. ์๋ฅผ ๋ค์ด, Queue์ [1, 2, 3]๊ณผ ๊ฐ์ ๋ฐ์ดํฐ๊ฐ ๋ค์ด์์ ๊ฒฝ์ฐ, ์ค๋ ๋ 3๊ฐ๊ฐ critical section์์ poll() ๋ฉ์๋๋ฅผ ํธ์ถํ๋ฉด ๊ฐ ์ค๋ ๋๋ค์ ๋ชจ๋ 1์ด๋ผ๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๊ณ Queue์๋ [2, 3]๋ง ๋จ๊ฒ ๋๋ค. ํ๊ฐ ๋น์ด์์ ๊ฒฝ์ฐ null์ ๋ฆฌํดํ๊ฒ ๋๋ค.
์ด์ ์ฐ๋ฆฌ๋ ๋ฉํฐ ์ค๋ ๋ ํ๊ฒฝ์์ ์๋ฐ๋ ๋ฉํฐ ์ค๋ ๋ ํ๊ฒฝ์์ ์ปฌ๋ ์ ์ ์์๋ฅผ ๋์์ ์ฒ๋ฆฌํ ์ ์๋ Queue๋ฅผ ์ฌ์ฉํด์ผํ๋๋ฐ ์ฌ๊ธฐ์์๋ ConcurrentLinkedQueue๋ฅผ ์ฌ์ฉํ๋ค.
ConcurrentLinkedQueue๋ ์์ฐ์-์๋น์ producer-consumer ๋ชจ๋ธ์์ ์๋น์๊ฐ ๋ง๊ณ ์์ฐ์๊ฐ ํ๋์ธ ๊ฒฝ์ฐ์ ์ฃผ๋ก ์ฌ์ฉ๋๋ค.
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
Queue<Object> queue = new ConcurrentLinkedQueue<Object>();
queue.offer(data); // put
queue.poll(); // get
๋๊ธ