โป ์ฃผ์! ๋ ๋ฐธ 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๋ฅผ ์ฌ๋ฌ๊ฒน์ผ๋ก ์ฌ์ฉํด์ ์์ ํ์์ ํ๋ฉด ๋งค์ฐ ํธ๋ฆฌํ๋ค