
ํด๋น ๊ฒ์๋ฌผ์ leego ๋์ ํฐ์คํ ๋ฆฌ ๋ธ๋ก๊ทธ๋ฅผ ์ฐธ๊ณ ํ์ฌ ์์ฑ๋์์์ ๋ฏธ๋ฆฌ ๋ฐํ๋๋ค.
โป 2๋จ๊ณ ๋ฌธ์ ์ด๋ฉฐ ๊ฐ์ฅ ์ด๋ ค์
ํด๋น ๋ฌธ์ ๋ ์ง๋ฌธ์ ์ฝ์ผ๋ฉด์๋ ๋ฉํ์ด ๋๋ฌด ๋๊ฐ์ ์์ธํ ์ค๋ช ์ ์๋ตํ๊ณ ๊ผญ ํ์ํ ๋ถ๋ถ๋ง ์ฃผ์์ ๋ฌ๊ณ ์ฒดํฌํ๊ฒ ์

์ถ์ฒ ) leego๋์ ํฐ์คํ ๋ฆฌ ๋ธ๋ก๊ทธ
๋ฌธ์  ์์
Ax + By + C = 0์ผ๋ก ํํํ ์ ์๋ n๊ฐ์ ์ง์ ์ด ์ฃผ์ด์ง ๋, ์ด ์ง์ ์ ๊ต์  ์ค ์ ์ ์ขํ์ ๋ณ์ ๊ทธ๋ฆฌ๋ ค ํฉ๋๋ค.
์๋ฅผ ๋ค์ด, ๋ค์๊ณผ ๊ฐ์ ์ง์ 5๊ฐ๋ฅผ
2x - y + 4 = 0
-2x - y + 4 = 0
-y + 1 = 0
5x - 8y - 12 = 0
5x + 8y + 12 = 0
์ขํ ํ๋ฉด ์์ ๊ทธ๋ฆฌ๋ฉด ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ต๋๋ค.

์ด๋, ๋ชจ๋ ๊ต์ ์ ์ขํ๋ (4, 1), (4, -4), (-4, -4), (-4, 1), (0, 4), (1.5, 1.0), (2.1, -0.19), (0, -1.5), (-2.1, -0.19), (-1.5, 1.0)์ ๋๋ค. ์ด ์ค ์ ์๋ก๋ง ํํ๋๋ ์ขํ๋ (4, 1), (4, -4), (-4, -4), (-4, 1), (0, 4)์ ๋๋ค.
๋ง์ฝ ์ ์๋ก ํํ๋๋ ๊ต์ ์ ๋ณ์ ๊ทธ๋ฆฌ๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.

์์ ๊ทธ๋ฆผ์ ๋ฌธ์์ด๋ก ๋ํ๋ผ ๋, ๋ณ์ด ๊ทธ๋ ค์ง ๋ถ๋ถ์ *, ๋น ๊ณต๊ฐ(๊ฒฉ์์ ์ด ๊ต์ฐจํ๋ ์ง์ )์ .์ผ๋ก ํํํ๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
"..........."  
".....*....."  
"..........."  
"..........."  
".*.......*."  
"..........."  
"..........."  
"..........."  
"..........."  
".*.......*."  
"..........."  
์ด๋ ๊ฒฉ์ํ์ ๋ฌดํํ ๋์ผ๋ ๋ชจ๋ ๋ณ์ ํฌํจํ๋ ์ต์ํ์ ํฌ๊ธฐ๋ง ๋ํ๋ด๋ฉด ๋ฉ๋๋ค.
๋ฐ๋ผ์ ์ ๋ต์
"....*...."  
"........."  
"........."  
"*.......*"  
"........."  
"........."  
"........."  
"........."  
"*.......*"  
์ ๋๋ค.
์ง์ A, B, C์ ๋ํ ์ ๋ณด๊ฐ ๋ด๊ธด ๋ฐฐ์ด line์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์ด๋ ๋ชจ๋ ๋ณ์ ํฌํจํ๋ ์ต์ ์ฌ๊ฐํ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ฝ๋ฉ ์์
function solution(line) {
    // ์ ์์ ๊ต์ ์ ๋ชจ๋ ์ฐพ๋๋ค
    function findInterSectionPoints() {
        const meetPoints = []
        
        for(let i = 0 ; i < line.length ; i ++) {
            for(let j = i+1 ; j < line.length ; j ++) {
                // ํ์ฌ ์ขํ ๋ฐ ๋ค์ ์ขํ์ x์ , y์ , ๊ธฐ์ธ๊ธฐ๋ฅผ ๊ตฌํ๋ค.
                const [curX,curY,curInc] = line[i]
                const [nextX,nextY,nextInc] = line[j] 
                
                // ๊ธฐ์ธ๊ธฐ๊ฐ ๊ฐ๋ค๋ฉด ํํํ๊ธฐ ๋๋ฌธ์ ๊ต์ ์ด ์๊ธฐ์ง ์๋๋ค. 0 = ํํ
                const Inclination = curX*nextY - curY*nextX
                
                if(Inclination) {
                    const meetX = (curY*nextInc - curInc*nextY) / Inclination
                    const meetY = (curInc*nextX - curX*nextInc) / Inclination
                    
                    if(Number.isInteger(meetX) && Number.isInteger(meetY)) {
                        meetPoints.push([meetX,meetY])
                    }
                }
            }
        }
        return meetPoints
    }
    
    // ์ฐพ์ ๊ต์ ์ ๋ณ๋ก ์ ํํ๋ฉฐ ์ต์์ ๋ณด๋ ์์ญ์ ๊ทธ๋ฆผ
    function drawBoardAndFindStar(meetPoints) {
        // ๊ต์ ์ ๊ธฐ์ค์ผ๋ก ์ต์์์ญ์ ๊ต์ ์ ๋ฃ๋๋ค.
        const [maxX, maxY, minX, minY] = meetPoints.reduce(
            ([maxX, maxY, minX, minY], [x, y]) => [
                Math.max(maxX,x),
                Math.max(maxY,y),
                Math.min(minX,x),
                Math.min(minY,y)
            ],
            [
                Number.MIN_SAFE_INTEGER,
                Number.MIN_SAFE_INTEGER,
                Number.MAX_SAFE_INTEGER,
                Number.MAX_SAFE_INTEGER,
            ]
        )
        
        // ์ต์ํ ํ  ์ ์๋ X, Y ์ขํ๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ณด๋๋ฅผ ๊ทธ๋ฆฐ๋ค.
        let board = Array.from(Array(maxY-minY+1), () => Array(maxX-minX+1).fill('.'))
        // ๊ทธ๋ฆฐ ๋ณด๋์ * ์ ์ฝ์
ํ๋ค
        meetPoints.forEach(([x,y]) => {
            board[maxY-y][x-minX] = '*'
        })
        
        return board.map(x => x.join(""))
    }
    
    return drawBoardAndFindStar(findInterSectionPoints())
}
์ดํดํ๊ธฐ ์กฐ์ฐจ ๋ง์ด ๋ฒ๊ฑฐ์ ๋ ๋ฌธ์ ์ธ๋งํผ ์ค๋ ๊ธฐ์ต์ ๋จ์ ๊ฒ ๊ฐ๋ค.