• + 0 comments

    Typescript Pretty straightforward solution, rotM could be optimized avoiding circling through ring per element but i don't care really.

    function matrixRotation(mat: number[][], r: number): void {
        const n = mat.length, m = mat[0].length
        const rot: number[][] = new Array(n).fill(null).map(r => new Array(m).fill(null))
    
        const rotM = (d: number, k: number, rN: number, rM: number, kLen: number): [number, number] => {
            k = k > kLen ? k % kLen : k
    
            let i = d, j = d
            for (let q = 1; q <= k; q++) {
                if (q <= rN - 1) {
                    i++
                } else if (q > rN - 1 && q <= rN + rM - 2) {
                    j++
                } else if (q > rN + rM - 2 && q <= 2 * rN + rM - 3) {
                    i--
                } else {
                    j--
                }
            }
            return [i, j]
        }
    
        const mid = Math.trunc(Math.min(m, n) / 2)
        for (let d = 0; d < mid; d++) {
            const rN = n - 2 * d, rM = m - 2 * d
            const kLen = 2 * (rN + rM - 2)
            for (let k = 1; k <= kLen; k++) {
                const [i, j] = rotM(d, k + r, rN, rM, kLen)
                const [ii, jj] = rotM(d, k, rN, rM, kLen)
                rot[i][j] = mat[ii][jj]
            }
        }
    
        for (let i = 0; i < n; i++) {
            console.log(rot[i].join(' '))
        }
    }