如何在javascript中旋转数组中的矩阵

（坦白说，我基本上不懂数学）

我有一个以下格式的数组：

var grid = [
  [0,0], [0,1], [0,2], [0,3],
  [1,0], [1,1], [1,2], [1,3],
  [2,0], [2,1], [2,2], [2,3],
  [3,0], [3,1], [3,2], [3,3]
];

我需要以90度的增量“旋转”它，所以它是这样的：

var grid = [
  [3,0], [2,0], [1,0], [0,0], 
  [3,1], [2,1], [1,1], [0,1], 
  [3,2], [2,2], [1,2], [0,2], 
  [3,3], [2,3], [1,3], [0,3] 
];

如何在Javascript中实现这一点？

实际的轮换方法要归功于

我的方法很简单。只需确定行长度是多少，然后迭代每个项目，将数组索引转换为x/y等效值，然后应用链接答案中使用的方法进行旋转。最后，我将旋转的X/Y坐标转换回数组索引

var grid = [
  [0,0], [0,1], [0,2], [0,3],
  [1,0], [1,1], [1,2], [1,3],
  [2,0], [2,1], [2,2], [2,3],
  [3,0], [3,1], [3,2], [3,3]
]; 

var newGrid = [];
var rowLength = Math.sqrt(grid.length);
newGrid.length = grid.length

for (var i = 0; i < grid.length; i++)
{
    //convert to x/y
    var x = i % rowLength;
    var y = Math.floor(i / rowLength);

    //find new x/y
    var newX = rowLength - y - 1;
    var newY = x;

    //convert back to index
    var newPosition = newY * rowLength + newX;
    newGrid[newPosition] = grid[i];
}

for (var i = 0; i < newGrid.length; i++)
{   
    console.log(newGrid[i])
}

---

给懒惰的人。为了证明算法适用于N个网格大小，只要它们是正方形。

我真的不需要处理索引，因为我可以将值从一个地方复制到另一个地方，这稍微简化了答案：

var grid = [
  [0,0], [0,1], [0,2], [0,3], [0,4],
  [1,0], [1,1], [1,2], [1,3], [1,4],
  [2,0], [2,1], [2,2], [2,3], [2,4],
  [3,0], [3,1], [3,2], [3,3], [3,4],
  [4,0], [4,1], [4,2], [4,3], [4,4]
]; 

var side = Math.sqrt(grid.length);

var rotate = function(d,i){
   return [Math.abs(i % side - side+1), Math.floor(i/side)]
}
grid = grid.map(rotate);

---

您可以在这里看到一个JSFIDLE:

这是两个用于顺时针和逆时针90度旋转的功能：

    function rotateCounterClockwise(a){
        var n=a.length;
        for (var i=0; i<n/2; i++) {
            for (var j=i; j<n-i-1; j++) {
                var tmp=a[i][j];
                a[i][j]=a[j][n-i-1];
                a[j][n-i-1]=a[n-i-1][n-j-1];
                a[n-i-1][n-j-1]=a[n-j-1][i];
                a[n-j-1][i]=tmp;
            }
        }
        return a;
    }

    function rotateClockwise(a) {
        var n=a.length;
        for (var i=0; i<n/2; i++) {
            for (var j=i; j<n-i-1; j++) {
                var tmp=a[i][j];
                a[i][j]=a[n-j-1][i];
                a[n-j-1][i]=a[n-i-1][n-j-1];
                a[n-i-1][n-j-1]=a[j][n-i-1];
                a[j][n-i-1]=tmp;
            }
        }
        return a;
    }

函数逆时针旋转（a）{
var n=a.长度；
对于（var i=0；旋转二维m x n矩阵
那些寻找旋转二维矩阵的人（更一般的情况）这里是如何做到的

例如：
原始矩阵：

[
  [1,2,3],
  [4,5,6], 
  [7,8,9]
]

旋转90度：

[
    [7,4,1]
    [8,5,2]
    [9,6,3]
]

这是通过以下方式完成的：

matrix[0].map((val, index) => matrix.map(row => row[index]).reverse())

你是专门针对4x4矩阵还是任意维的矩阵来做这件事的？@Blender:我已经尝试了
grid.map（函数（d，I）{return[Math.abs（d[1]-3），d[0]}）
这是一个增量，但从数学角度看显然是错误的。@ultranaut我需要它来处理任意维度。最后一行的输出网格有错误吗？它应该是var grid=[[3,0]、[2,0]、[1,0]、[0,0]、[3,1]、[2,1]、[3,1]、[2,2]、[0,2]、[3,3]、[2,3]、[1,3]、[0,3]].对吗？@rab ahhh是的，你是对的。更新了问题。当我用这个解决方案更改初始网格中的任何值时，输出不会改变，你真的不想让输入变得重要吗？是的，这些只是网格的坐标，但你的答案在大多数情况下更相关，所以我会接受它。这是一个非常漂亮的解决方案，清理一个网格d最小。（必须是一个正方形矩阵）“必须是一个正方形矩阵”对我来说是个问题…如果我想旋转一个2x8矩阵，你会怎么做？哇，这太棒了！我希望达到这个完美的水平。
matrix[0].map((val, index) => matrix.map(row => row[index]).reverse())