Content Comparison

func diagonalSort(mat [][]int) [][]int {
    m, n := len(mat), len(mat[0])
    diagonals := make(map[int][]int, m+n-1)

    for i := range mat {
        for j, v := range mat[i] {
            diagonals[j-i] = append(diagonals[j-i], v)
        }
    }

    for _, v := range diagonals {
        sort.Slice(v, func(i, j int) bool {
            return v[i] >= v[j]
        })
    }

    for i := range mat {
        for j := range mat[i] {
            v := diagonals[j-i][len(diagonals[j-i])-1]
            diagonals[j-i] = diagonals[j-i][:len(diagonals[j-i])-1]
            
            mat[i][j] = v
        }
    }

    return mat
}

func shiftGrid(grid [][]int, k int) [][]int {
    m, n := len(grid), len(grid[0])

    total := m*n
    all := make([]int, total)

    for i := range grid {
        for j, v := range grid[i] {
            all[(i*n+j+k) % total] = v
        }
    }

    for i := range grid {
        for j := range grid[i] {
            grid[i][j] = all[i*n+j]
        }
    }

    return grid
}

func shiftGrid(grid [][]int, k int) [][]int {
    m, n := len(grid), len(grid[0])

    k = k % (m*n)

    reverse(grid, 0, m*n-1)
    reverse(grid, 0,k-1)
    reverse(grid, k, m*n-1)

    return grid
}

func reverse(grid [][]int, start, end int) {
    i, j := start, end
    for i < j {
        a := get(grid, i)
        b := get(grid, j)
        set(grid, j, a)
        set(grid, i, b)

        i++
        j--
    }
}

func set(grid [][]int, index int, newValue int) {
    n := len(grid[0])
    i, j := index / n, index % n
    grid[i][j] = newValue
}

func get(grid [][]int, index int) int {
    n := len(grid[0])
    i, j := index / n, index % n
    return grid[i][j]
}