
์ด์์ฒด์ ์ ์ญํ ์ค ํ๋๋ ์ปดํจํฐ ์์คํ ์ ์์์ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํ๋ ๊ฒ์ ๋๋ค. ์ด ๋ฌธ์ ์์๋ ์ด์์ฒด์ ๊ฐ ๋ค์ ๊ท์น์ ๋ฐ๋ผ ํ๋ก์ธ์ค๋ฅผ ๊ด๋ฆฌํ ๊ฒฝ์ฐ ํน์ ํ๋ก์ธ์ค๊ฐ ๋ช ๋ฒ์งธ๋ก ์คํ๋๋์ง ์์๋ด๋ฉด ๋ฉ๋๋ค.
- ์คํ ๋๊ธฐ ํ(Queue)์์ ๋๊ธฐ์ค์ธ ํ๋ก์ธ์ค ํ๋๋ฅผ ๊บผ๋ ๋๋ค.
- ํ์ ๋๊ธฐ์ค์ธ ํ๋ก์ธ์ค ์ค ์ฐ์ ์์๊ฐ ๋ ๋์ ํ๋ก์ธ์ค๊ฐ ์๋ค๋ฉด ๋ฐฉ๊ธ ๊บผ๋ธ ํ๋ก์ธ์ค๋ฅผ ๋ค์ ํ์ ๋ฃ์ต๋๋ค.
- ๋ง์ฝ ๊ทธ๋ฐ ํ๋ก์ธ์ค๊ฐ ์๋ค๋ฉด ๋ฐฉ๊ธ ๊บผ๋ธ ํ๋ก์ธ์ค๋ฅผ ์คํํฉ๋๋ค.
3.1 ํ ๋ฒ ์คํํ ํ๋ก์ธ์ค๋ ๋ค์ ํ์ ๋ฃ์ง ์๊ณ ๊ทธ๋๋ก ์ข ๋ฃ๋ฉ๋๋ค.
์๋ฅผ ๋ค์ด ํ๋ก์ธ์ค 4๊ฐ[A, B, C, D]๊ฐ ์์๋๋ก ์คํ ๋๊ธฐ ํ์ ๋ค์ด์๊ณ , ์ฐ์ ์์๊ฐ[2, 1, 3, 2]๋ผ๋ฉด[C, D, A, B]์์ผ๋ก ์คํํ๊ฒ ๋ฉ๋๋ค.
ํ์ฌ ์คํ ๋๊ธฐ ํ(Queue)์ ์๋ ํ๋ก์ธ์ค์ ์ค์๋๊ฐ ์์๋๋ก ๋ด๊ธด ๋ฐฐ์ด priorities์, ๋ช ๋ฒ์งธ๋ก ์คํ๋๋์ง ์๊ณ ์ถ์ ํ๋ก์ธ์ค์ ์์น๋ฅผ ์๋ ค์ฃผ๋ location์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ํด๋น ํ๋ก์ธ์ค๊ฐ ๋ช ๋ฒ์งธ๋ก ์คํ๋๋์ง return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
priorities์ ๊ธธ์ด โฆ 100priorities์ ์์ โฆ 9priorities์ ์์๋ ์ฐ์ ์์๋ฅผ ๋ํ๋ด๋ฉฐ ์ซ์๊ฐ ํด ์๋ก ์ฐ์ ์์๊ฐ ๋์ต๋๋ค.location โฆ ๋๊ธฐ ํ์ ์๋ ํ๋ก์ธ์ค ์ - 1priorities์ ๊ฐ์ฅ ์์ ์์ผ๋ฉด 0, ๋ ๋ฒ์งธ์ ์์ผ๋ฉด 1 โฆ ๊ณผ ๊ฐ์ด ํํํฉ๋๋ค.| priorities | location | return |
|---|---|---|
| [2, 1, 3, 2] | 2 | 1 |
| [1, 1, 9, 1, 1, 1] | 0 | 5 |
์ฐ์ , ๋ฌธ์ ์ ์ค๋ช ๋๋ก ํ์ด๋ฅผ ์งํํ์ต๋๋ค.
ํ๋ก์ธ์ค๊ฐ ์์๋๋ก ์ฃผ์ด์ง๋ ์์์ ํจ๊ป ํ์ ๋ฃ์ด์ค๋๋ค.
ํ์์ ํ๋์ฉ ๊บผ๋ด์ด ์ฐ์ ์์๋ฅผ ํ์ธํ๊ณ ํ๋ด์ ํด๋น ํ๋ก๊ทธ๋จ๋ณด๋ค ์ฐ์ ์์๊ฐ ๋์ ํ๋ก๊ทธ๋จ์ด ์๋ค๋ฉด ํ์ ๋ค์ ๋ฃ์ด์ฃผ๊ณ , ์๋๋ผ๋ฉด ๊บผ๋ด์ด ์ค๋๋ค.
์ต์ข
์ ์ผ๋ก ๋ชจ๋ ์ํํ ๋ค์, location์ ํด๋นํ๋ ํ๋ก๊ทธ๋จ์ด ๋ช ๋ฒ์งธ๋ก ์คํ๋์๋์ง ์ฐพ์์ค๋๋ค.
function solution(priorities, location) {
const queue = priorities.map((el, idx) => [idx, el])
const printOrder = [];
while(queue.length){
const [idx, priority] = queue.shift();
if(queue.some(el => el[1] > priority)){
queue.push([idx, priority])
}else{
order.push([idx, priority])
}
}
return order.findIndex(el => el[0] === location) + 1
}
๋ฌด์ฌํ ํต๊ณผํฉ๋๋ค. ํ์ง๋ง, order๋ก ๋ชจ๋ ์คํํ ํ์ ์์ด๋ณด์
๋๋ค. ์ฐ๋ฆฌ๊ฐ ์๊ณ ์ถ์ location์ ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ฉด ์์๋ง ์ถ๋ ฅํ๋ฉด ๋ฉ๋๋ค.
๋ฐ๋ผ์, order์ ๋ฐฐ์ด๋์ ์ ์์๋ง ๊ธฐ์ตํ๋๋ก ๋ฐ๊ฟ์ฃผ๊ณ , while๋ฌธ ์์์ ์งํํ๋ค๊ฐ location์ ํ๋ก๊ทธ๋จ์ ๋ง๋๋ฉด ํด๋น ์์๋ฅผ ์ถ๋ ฅํ๋๋ก ๋ฆฌํฉํ ๋งํด์ค๋๋ค.
function solution(priorities, location) {
const queue = priorities.map((priority, index) => ({ index, priority }));
let printOrder = 0;
while (queue.length) {
const current = queue.shift();
if (queue.some(task => task.priority > current.priority)) {
queue.push(current);
} else {
printOrder++;
if (current.index === location) {
return printOrder;
}
}
}
}