Java 如何在矩阵中生成同心层

我需要生成一个具有以下方面的矩阵：

但是有更多的层，我找不到一个方法来做。 要理解，每种颜色都有

n

层（在本例中，

n=2

），并且可以有

m

颜色（在本例中，

m=3

）。内部矩阵，绿色矩阵，应该遵循与其他矩阵相同的螺旋模式，在图像中是错误的。下一种颜色（本例中为黄色）需要从左上角开始“包围”上一个矩阵，填充一层，并在左上角继续下一层，依此类推。 颜色本身并不重要，重要的是每个单元格中的数字

有什么想法吗

PS：忘记绿色的10和34，这些只是修改

---

PS2：这个例子是手工填充的，对于这种大小的矩阵我可以这样做，但是对于256x256是不可能的。

一个策略是从最内层开始，在向外填充的同时填充它们。这样，核心循环变得特别简单，因为您可以遍历矩阵的相关部分，只填充尚未填充的字段

矩阵的“相关”部分可以在一层颜色的循环中轻松计算：每一层，一层覆盖的矩形的总大小（宽度和高度）增加2。填充所需层数后，用于填充矩阵的“计数器”将重置为零，以指示新颜色开始

例如：

public class LayeredMatrix
{
    public static void main(String[] args)
    {
        test(1,1);
        test(2,2);
        test(3,3);
        test(2,3);
    }

    private static void test(int layers, int colors)
    {
        System.out.println(layers+" layers, "+colors+" colors");
        print(generate(layers, colors));
    }

    private static int[][] generate(int layers, int colors)
    {
        int size = layers * colors * 2;
        int matrix[][] = new int[size][size];
        int layerSize = 2;
        for (int color=0; color<colors; color++)
        {
            int colorOffset = (colors - color - 1) * layers;
            int counter = 1;
            for (int layer = 0; layer < layers; layer++)
            {
                int layerOffset = layers - layer - 1;
                int r0 = colorOffset + layerOffset;
                int c0 = colorOffset + layerOffset;
                int r1 = r0 + layerSize;
                int c1 = c0 + layerSize;
                for (int r=r0; r<r1; r++)
                {
                    for (int c=c0; c<c1; c++)
                    {
                        if (matrix[r][c] == 0)
                        {
                            matrix[r][c] = counter;
                            counter++;
                        }
                    }
                }
                layerSize += 2;
            }
        }
        return matrix;
    }

    private static void print(int matrix[][])
    {
        for (int r=0; r<matrix.length; r++)
        {
            for (int c=0; c<matrix[r].length; c++)
            {
                System.out.printf("%4d", matrix[r][c]);
            }
            System.out.println();
        }
        System.out.println();
    }

}

---

不，那实际上是一个我没有注意到的错误。他们应该遵循同样的规则。

2 layers, 3 colors
  37  38  39  40  41  42  43  44  45  46  47  48
  49   1   2   3   4   5   6   7   8   9  10  50
  51  11  21  22  23  24  25  26  27  28  12  52
  53  13  29   1   2   3   4   5   6  30  14  54
  55  15  31   7   5   6   7   8   8  32  16  56
  57  17  33   9   9   1   2  10  10  34  18  58
  59  19  35  11  11   3   4  12  12  36  20  60
  61  21  37  13  13  14  15  16  14  38  22  62
  63  23  39  15  16  17  18  19  20  40  24  64
  65  25  41  42  43  44  45  46  47  48  26  66
  67  27  28  29  30  31  32  33  34  35  36  68
  69  70  71  72  73  74  75  76  77  78  79  80