โป ์ฃผ์! ๋ ๋ฐธ 2 ์ค ๊ฐ์ธ์ ์ธ ๊ทน์ ์ ๋์ด๋
๋๋ฌด ํ๋ค์ด์ ๋ค๋ฅธ๋ถ์ ๊ฐ๋ฐ ๋ธ๋ก๊ทธ๋ฅผ ์ฐธ๊ณ ํ์๋ค.
๊ฐ์ธ์ ์ผ๋ก ์ดํดํ๊ธฐ ์กฐ์ฐจ ๋ฒ
์ฐจ ๋ด ๋๋ฆ์ ์ฃผ์์ ๋ฌ๊ณ ๋ฌธ์ ๋ฅผ ํํค์ณ๋ณด์์
์ถ์ฒ : ISA(๋ฅ) ๋์ ๊ฐ๋ฐ๋ธ๋ก๊ทธ
๋ฌธ์ ์ค๋ช
๊ฐ ์นธ๋ง๋ค S, L, ๋๋ R๊ฐ ์จ์ ธ ์๋ ๊ฒฉ์๊ฐ ์์ต๋๋ค. ๋น์ ์ ์ด ๊ฒฉ์์์ ๋น์ ์๊ณ ์ ํฉ๋๋ค. ์ด ๊ฒฉ์์ ๊ฐ ์นธ์๋ ๋ค์๊ณผ ๊ฐ์ ํน์ดํ ์ฑ์ง์ด ์์ต๋๋ค.
๋น์ด "S"๊ฐ ์จ์ง ์นธ์ ๋๋ฌํ ๊ฒฝ์ฐ, ์ง์งํฉ๋๋ค.
๋น์ด "L"์ด ์จ์ง ์นธ์ ๋๋ฌํ ๊ฒฝ์ฐ, ์ขํ์ ์ ํฉ๋๋ค.
๋น์ด "R"์ด ์จ์ง ์นธ์ ๋๋ฌํ ๊ฒฝ์ฐ, ์ฐํ์ ์ ํฉ๋๋ค.
๋น์ด ๊ฒฉ์์ ๋์ ๋์ด๊ฐ ๊ฒฝ์ฐ, ๋ฐ๋์ชฝ ๋์ผ๋ก ๋ค์ ๋์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ๋น์ด 1ํ์์ ํ์ด ์ค์ด๋๋ ๋ฐฉํฅ์ผ๋ก ์ด๋ํ ๊ฒฝ์ฐ, ๊ฐ์ ์ด์ ๋ฐ๋์ชฝ ๋ ํ์ผ๋ก ๋ค์ ๋์์ต๋๋ค.
๋น์ ์ ์ด ๊ฒฉ์ ๋ด์์ ๋น์ด ์ด๋ํ ์ ์๋ ๊ฒฝ๋ก ์ฌ์ดํด์ด ๋ช ๊ฐ ์๊ณ , ๊ฐ ์ฌ์ดํด์ ๊ธธ์ด๊ฐ ์ผ๋ง์ธ์ง ์๊ณ ์ถ์ต๋๋ค. ๊ฒฝ๋ก ์ฌ์ดํด์ด๋, ๋น์ด ์ด๋ํ๋ ์ํ ๊ฒฝ๋ก๋ฅผ ์๋ฏธํฉ๋๋ค.
์๋ฅผ ๋ค์ด, ๋ค์ ๊ทธ๋ฆผ์ ๊ฒฉ์ ["SL","LR"]์์ 1ํ 1์ด์์ 2ํ 1์ด ๋ฐฉํฅ์ผ๋ก ๋น์ ์ ๊ฒฝ์ฐ, ํด๋น ๋น์ด ์ด๋ํ๋ ๊ฒฝ๋ก ์ฌ์ดํด์ ํํํ ๊ฒ์ ๋๋ค.
์ด ๊ฒฉ์์๋ ๊ธธ์ด๊ฐ 16์ธ ์ฌ์ดํด 1๊ฐ๊ฐ ์์ผ๋ฉฐ, ๋ค๋ฅธ ์ฌ์ดํด์ ์กด์ฌํ์ง ์์ต๋๋ค.
๊ฒฉ์์ ์ ๋ณด๋ฅผ ๋ํ๋ด๋ 1์ฐจ์ ๋ฌธ์์ด ๋ฐฐ์ด grid๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์ฃผ์ด์ง ๊ฒฉ์๋ฅผ ํตํด ๋ง๋ค์ด์ง๋ ๋น์ ๊ฒฝ๋ก ์ฌ์ดํด์ ๋ชจ๋ ๊ธธ์ด๋ค์ ๋ฐฐ์ด์ ๋ด์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ์ฌ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
๋์ ํ์ด
function solution(grid) {
const result = []
// ๊ฐ ์ ์๋ ๋ชจ๋ ๋ฐฉํฅ์ ๊ธธ์ ์์ฑ
const root = Array.from(Array(grid.length), () => Array.from(Array(grid[0].length), () => Array(4).fill(true)))
// ์์ง์ผ ๋ฐฉํฅ ์,ํ,์ข,์ฐ
const pos = [[-1,0],[1,0],[0,-1],[0,1]]
root.forEach((row,rowIdx) => {
row.forEach((col,colIdx) => {
col.forEach((item,idx) => {
// ๋ชจ๋ ํ๋ฒ์ฉ ์ดํด๋ณด๋ฉฐ ํด๋น ๊ฒฝ๋ก๊ฐ ํ์๋์ง ์์๋ค๋ฉด ์ธ์ดํด์ ๊ตฌํด ๋ช๋ฒ์ ๋๋์ง ํ์ธํ์ฌ ์ ๋ต ๋ฐฐ์ด์ ์ฝ์
( ์ด๊ธฐ์ ๋ชจ๋ ๋ฐฐ์ด์ true ๋ฅผ ๋ฃ์ ์ด์ )
if(item) {
result.push(CycleCount(rowIdx,colIdx,idx))
}
})
})
})
// ๋ช๋ฒ์ ์ธ์ดํด์ ๋ ์ ์๋์ง ํ์ธํ๋ ํจ์
function CycleCount(rowIdx,colIdx,idx) {
let count = 0
while(1) {
// ํ์ฌ์ ์ขํ๊ฐ์ด ์ง๋์๋ ์๋ฆฌ๋ผ๋ฉด ๋ฐ๋ณต์ ๋ฉ์ถค
if(!root[rowIdx][colIdx][idx]) break
// ํ์ฌ ์ขํ๋ฅผ ์ง๋๊ฐ๋ค๊ณ ํ์
root[rowIdx][colIdx][idx] = false
count++
// ํ์ฌ ์ขํ์ ์์น ์ ์ฉ
rowIdx+=pos[idx][0]
colIdx+=pos[idx][1]
// ์ ๋์์ ๋์ด๊ฐ๋ค๋ฉด ๋ฐ๋ํธ ์ฒ์ ์ ์ผ๋ก
if(rowIdx < 0) rowIdx = root.length-1
if(rowIdx >= root.length ) rowIdx = 0
if(colIdx < 0) colIdx = root[0].length-1
if(colIdx >= root[0].length) colIdx = 0
// ์ฒ์ ์,ํ,์ข,์ฐ ๋ฅผ ๊ธฐ์ค์ผ๋ก ์ผ์ชฝ ํน์ ์ค๋ฅธ์ชฝ์ธ ๊ฒฝ์ฐ ๋ค์ ๋ฐฉํฅ์ ์ ์ธ
if(grid[rowIdx][colIdx] === 'L') idx = [2,3,1,0][idx]
if(grid[rowIdx][colIdx] === 'R') idx = [3,2,0,1][idx]
}
return count
}
return result.sort((a,b) => a-b)
}
์๊ฒ๋ ์
Array.from(['te','st'], (item,idx) => console.log(item)) // return te st
Array.from์ผ๋ก ์์ฝ๊ฒ 2,3 ์ฐจ ๋ฐฐ์ด์ ์์ฑํ ์ ์๋ค.
Array.forEach๋ฅผ ์ฌ๋ฌ๊ฒน์ผ๋ก ์ฌ์ฉํด์ ์์ ํ์์ ํ๋ฉด ๋งค์ฐ ํธ๋ฆฌํ๋ค