Question

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

enter image description here

但是有更多的图层，我找不到办法做到这一点。要理解，每种颜色都有n个图层（在此示例中为n=2），并且可以有m个颜色（在此示例中为m=3）。内部矩阵，绿色矩阵，应该遵循与其他矩阵相同的螺旋模式，在图像中是错误的。在这种情况下，下一个颜色（黄色）需要从左上角开始“围绕”前一个矩阵，填充一个图层并继续左上角的下一个“图层”，依此类推。颜色本身并不重要，重要的是每个单元格中的数字。

有什么想法吗？

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

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

Answer 1

一种策略是从最内层开始，然后向外填充它们。这样，核心循环变得特别简单，因为您可以遍历矩阵的相关部分，并仅填充不填充的字段。

＆＃34;相关＆＃34;矩阵的一部分可以在颜色和层的循环内轻松计算：对于每个图层，由一个图层覆盖的矩形的总大小（宽度和高度）增加2.当填充了所需的图层数量时，＆＃34;计数器＆＃34;用于填充矩阵的用于重置为零，以指示新颜色开始。

一个例子：

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

如何在矩阵中生成同心层

1 个答案: