ํ๋ก๊ทธ๋๋จธ์ค LV. 2 ํ๋ก์ธ์ค JS
์ด์์ฒด์ ์ ์ญํ ์ค ํ๋๋ ์ปดํจํฐ ์์คํ ์ ์์์ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํ๋ ๊ฒ์ ๋๋ค.
์ด ๋ฌธ์ ์์๋ ์ด์์ฒด์ ๊ฐ ๋ค์ ๊ท์น์ ๋ฐ๋ผ ํ๋ก์ธ์ค๋ฅผ ๊ด๋ฆฌํ ๊ฒฝ์ฐ ํน์ ํ๋ก์ธ์ค๊ฐ ๋ช ๋ฒ์งธ๋ก ์คํ๋๋์ง ์์๋ด๋ฉด ๋ฉ๋๋ค.1. ์คํ ๋๊ธฐ ํ(Queue)์์ ๋๊ธฐ์ค์ธ ํ๋ก์ธ์ค ํ๋๋ฅผ ๊บผ๋ ๋๋ค. 2. ํ์ ๋๊ธฐ์ค์ธ ํ๋ก์ธ์ค ์ค ์ฐ์ ์์๊ฐ ๋ ๋์ ํ๋ก์ธ์ค๊ฐ ์๋ค๋ฉด ๋ฐฉ๊ธ ๊บผ๋ธ ํ๋ก์ธ์ค๋ฅผ ๋ค์ ํ์ ๋ฃ์ต๋๋ค. 3. ๋ง์ฝ ๊ทธ๋ฐ ํ๋ก์ธ์ค๊ฐ ์๋ค๋ฉด ๋ฐฉ๊ธ ๊บผ๋ธ ํ๋ก์ธ์ค๋ฅผ ์คํํฉ๋๋ค. 3.1 ํ ๋ฒ ์คํํ ํ๋ก์ธ์ค๋ ๋ค์ ํ์ ๋ฃ์ง ์๊ณ ๊ทธ๋๋ก ์ข ๋ฃ๋ฉ๋๋ค.
์๋ฅผ ๋ค์ด ํ๋ก์ธ์ค 4๊ฐ [A, B, C, D]๊ฐ ์์๋๋ก ์คํ ๋๊ธฐ ํ์ ๋ค์ด์๊ณ , ์ฐ์ ์์๊ฐ [2, 1, 3, 2]๋ผ๋ฉด [C, D, A, B] ์์ผ๋ก ์คํํ๊ฒ ๋ฉ๋๋ค.
ํ์ฌ ์คํ ๋๊ธฐ ํ(Queue)์ ์๋ ํ๋ก์ธ์ค์ ์ค์๋๊ฐ ์์๋๋ก ๋ด๊ธด ๋ฐฐ์ด priorities์, ๋ช ๋ฒ์งธ๋ก ์คํ๋๋์ง ์๊ณ ์ถ์ ํ๋ก์ธ์ค์ ์์น๋ฅผ ์๋ ค์ฃผ๋ location์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ํด๋น ํ๋ก์ธ์ค๊ฐ ๋ช ๋ฒ์งธ๋ก ์คํ๋๋์ง return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- priorities์ ๊ธธ์ด๋ 1 ์ด์ 100 ์ดํ์ ๋๋ค.
- priorities์ ์์๋ 1 ์ด์ 9 ์ดํ์ ์ ์์ ๋๋ค.
- priorities์ ์์๋ ์ฐ์ ์์๋ฅผ ๋ํ๋ด๋ฉฐ ์ซ์๊ฐ ํด ์๋ก ์ฐ์ ์์๊ฐ ๋์ต๋๋ค.- location์ 0 ์ด์ (๋๊ธฐ ํ์ ์๋ ํ๋ก์ธ์ค ์ - 1) ์ดํ์ ๊ฐ์ ๊ฐ์ง๋๋ค.
- priorities์ ๊ฐ์ฅ ์์ ์์ผ๋ฉด 0, ๋ ๋ฒ์งธ์ ์์ผ๋ฉด 1 โฆ ๊ณผ ๊ฐ์ด ํํํฉ๋๋ค.
์ ์ถ๋ ฅ ์
priorities | location | return |
---|---|---|
[2, 1, 3, 2] | 2 | 1 |
[1, 1, 9, 1, 1, 1] | 0 | 5 |
function solution(priorities, location) {
let process = [], result = []
let front = 0, max = 0
for (let i = 0; i < priorities.length; i++){
process.push(i) // ํ์ฌ ๊ฐ๋ค์ ์ธ๋ฑ์ค๋ง ๋ฐ๋ก ์ ๋ ฌ
}
while (priorities.length > 0) {
front = priorities.shift() // ์์ ๊ฐ ๋นผ๊ธฐ
max = Math.max(...priorities) // ๋๋จธ์ง ์ซ์ ์ค ๋์์์์๋์ง ํ์ธ
if(front < max) { // ๋๋จธ์ง ์ค์ ๋ ๋์ ์ฐ์ ์์๊ฐ ์๋ ๊ฒฝ์ฐ
priorities.push(front)
process.push(process.shift())
}else{ // ๋๋จธ์ง ์ค์ ๋ ๋์ ์ฐ์ ์์๊ฐ ์๋ ๊ฒฝ์ฐ
result.push(process.shift()) // ์ถ๋ ฅํ ์ธ๋ฑ์ค๋ค ์ ์ฅ
}
}
for (let i = 0; i < result.length;i++){
if(result[i] == location){ //์ํ๋ ์ธ๋ฑ์ค์ ์์ ์ถ๋ ฅ
return i+1;
}
}
}
์ธ๋ฑ์ค๋ฅผ ์ด์ฉํ๋ ๊ฒ ๋๋ฌธ์ ์ด๋ ค์ ๋ค.