C++ 用连续的数字C+填充Z字形二维数组+；

我被困在这上面了。你能帮帮我吗

编写一个初始化二维数组的函数。数组是正方形的
矩阵（即，其宽度和高度相同。）应在 之字形风格。具体来说，我们从左上角开始向下，然后放置一个
从1开始的数字。一旦我们到达底部，我们进入下一列并填写
从下到上的数字。我们将数字向下填入第三个
列，在第四列向上，依此类推。当所有 数组中的元素已填充

However, How do I get my output like this?
1 10 11 20 21
2 9 12 19 22
3 8 13 18 23
4 7 14 17 24
5 6 15 16 25

#include <iomanip>
#include <iostream>
using namespace std;
const int SIZE = 5; // Note SIZE can be anything between 1 to 9
void initGrid(int grid[SIZE][SIZE]);
void printGrid(int grid[SIZE][SIZE]);
int main() {
    int grid[SIZE][SIZE];
    initGrid(grid);
    printGrid(grid);
}
void initGrid(int grid[SIZE][SIZE]) {
    int inc = 1;
    for (int j = 0; j < SIZE; j++) {
        for (int i = 0; i < SIZE; i++) {
             grid[i][j] = inc;
             inc++;
        }
    }
}
void printGrid(int grid[SIZE][SIZE]) {
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            // setw() function handles the printing format.
            cout << setw(2) << grid[i][j] << " ";
        }
        cout << endl;
    }
}

但是，如何获得这样的输出？
1 10 11 20 21
2 9 12 19 22
3 8 13 18 23
4 7 14 17 24
5 6 15 16 25
#包括
#包括
使用名称空间std；
常量int SIZE=5；//注释大小可以是1到9之间的任何值
void initGrid（int grid[SIZE][SIZE]）；
void printGrid（int grid[SIZE][SIZE]）；
int main（）{
整数网格[大小][大小]；
initGrid（grid）；
打印网格（网格）；
}
void initGrid（int grid[SIZE][SIZE]）{
int inc=1；
对于（int j=0；jcout首先，如果我在写这个程序，我会用不同的方式表示我的数据。也就是说，我可能会使用一个向量并避免全局大小常量。也就是说，我会这样做。让我们写出索引所遵循的顺序，试着看看我们是否可以创建某种序列

1 4 7
2 5 8
3 6 9

是创建阵列后阵列中的内容，我们希望

1 6 7
2 5 8
3 4 9

原始数组的索引如下所示

(0, 0) (2, 1) (0, 2)
(1, 0) (1, 1) (1, 2)
(2, 0) (0, 1) (2, 2)

我们的j分量很简单，它只是一个简单的算术序列，你加1，即1，2，3，4，5

for (int j = 0; j < 3; j++){
  ...
}

for（int j=0；j<3；j++）{
...
}

现在我们需要一个序列，遵循模式0，1，2，2，1，0，0，1，2，…重复。因为我们有重复的数字，我想用时钟算术或模运算。让我们从序列0，1，2，0，1，2…重复开始。也就是整数mod 3（Z mod 3）。对于第一列，我们希望标记按原样向上（Z mod 3）。然后对于反向列，假设我们给定了这个序列，我们从0到2进行迭代。我们可以巧妙地使用模运算得到我们的反向序列。例如，如果我们有（2 mod 3），（4 mod 3），（6 mod 3），我们将有2，1，0。我们如何得到0，1，2到2，4，6？像这样f（x）：（x+1）*2

bool reversed=false；
对于（int i=0；i<3；i++）{
int-idx=i；
如果（反向）{
整数偏移=（i+1）*2；
idx=（偏移量）%3；
}
}
反向=！反向；

现在我们只需要把它们放在一起。这应该是我们新的init网格，因为print函数很好

for (int j = 0; j < SIZE; j++){
  bool reversed = false;
  for (int i = 0; i < SIZE; i++){
    int idx = i;
    if(reversed){
      int offset = (i + 1) * (SIZE - 1);
      idx = (offset) % SIZE;
    }
    arr[idx][j] = inc;
    inc++;
  }
  reversed = !reversed;
}

for（int j=0；j

应该可以了。我让它在repl.it中工作，希望这会有所帮助。
网格中的每两列共享相同的填充模式，奇数列按升序填充，偶数列按降序填充。您所要做的就是将其转换为代码：

template<size_t Rows, size_t Cols>
void initGrid(int (&grid)[Rows][Cols]) {
    int value = 1;
    for (size_t j = 0; j < Cols; ++j) {
        // first fill the odd column in descending order
        for (size_t i = 0; i < Rows; ++i, ++value) {
            grid[i][j] = value;
        }
        // then, if there is one, fill the even column
        ++j;
        if (j == Cols )
            break;
        for (size_t i = Rows; i > 0; ++value) {
            --i;   // size_t is unsigned, so I have to check i before decrementing
            grid[i][j] = value;
        }
    }
}

模板
void initGrid（整型（&grid）[行][Cols]）{
int值=1；
对于（尺寸j=0；j0；++值）{
--i、 //size\u t是无符号的，因此我必须在递减之前检查i
网格[i][j]=值；
}
}
}

我使用了与您使用的相同的数据结构（但不同的函数签名），只是为了专注于算法，但我会使用一个类

如果不希望按列遍历数组（对于大型数组，这可能会由于缓存未命中而导致性能下降），可以计算每行中值之间的差异：

template<size_t Rows, size_t Cols>
void zig_zag_fill(int (&grid)[Rows][Cols])
{
    int diff_up = 1;
    int diff_down = Rows * 2 - 1;
    for (size_t i = 0; i < Rows; ++i, diff_down -= 2, diff_up += 2)
    {
        int value = i + 1;
        size_t j = 0;
        while ( j < Cols )
        {
            grid[i][j] = value;
            value += diff_down;
            ++j;
            if ( j == Cols )
                break;
            grid[i][j] = value;
            value += diff_up;
            ++j;
        }
    }
}

模板
空心之字形填充（整型和栅格）[行][Cols]）
{
int diff_up=1；
int diff_down=行*2-1；
对于（大小i=0；i

完整的测试程序如下：

#include <iostream>
#include <iomanip>

template<size_t Rows, size_t Cols>
void zig_zag_fill(int (&grid)[Rows][Cols]);

template<size_t Rows, size_t Cols>
void printGrid(int (&grid)[Rows][Cols]);

int main() {
    int grid[5][6];
    zig_zag_fill(grid);
    printGrid(grid);
    std::cout << '\n';
    int grid2[6][5];
    zig_zag_fill(grid2);
    printGrid(grid2);
    std::cout << '\n';
    int grid3[5][5];
    zig_zag_fill(grid3);
    printGrid(grid3);
    std::cout << '\n';
    int grid4[6][6];
    zig_zag_fill(grid4);
    printGrid(grid4);
    std::cout << '\n';
}

template<size_t Rows, size_t Cols>
void initGrid(int (&grid)[Rows][Cols]) {
    int value = 1;
    for (size_t j = 0; j < Cols; ++j) {
        for (size_t i = 0; i < Rows; ++i, ++value) {
            grid[i][j] = value;
        }
        ++j;
        if (j == Cols )
            break;
        for (size_t i = Rows; i > 0; ++value) {
            --i;
            grid[i][j] = value;
        }
    }
}

template<size_t Rows, size_t Cols>
void zig_zag_fill(int (&grid)[Rows][Cols])
{
    int diff_up = 1;
    int diff_down = Rows * 2 - 1;
    for (size_t i = 0; i < Rows; ++i, diff_down -= 2, diff_up += 2)
    {
        int value = i + 1;
        size_t j = 0;
        while ( j < Cols )
        {
            grid[i][j] = value;
            value += diff_down;
            ++j;
            if ( j == Cols )
                break;
            grid[i][j] = value;
            value += diff_up;
            ++j;
        }
    }
}


template<size_t Rows, size_t Cols>
void printGrid(int (&grid)[Rows][Cols]) {
    for (size_t i = 0; i < Rows; ++i) {
        for (size_t j = 0; j < Cols; ++j) {
            std::cout << std::setw(2) << grid[i][j] << " ";
        }
        std::cout << '\n';
    }
}

#包括
#包括
模板
空心之字形填充（整型和网格）[行][Cols]；
模板
void printGrid（int和grid）[Rows][Cols]）；
int main（）{
国际网格[5][6]；
锯齿形填充（网格）；
打印网格（网格）；
标准：：cout
#include <iostream>
#include <iomanip>

template<size_t Rows, size_t Cols>
void zig_zag_fill(int (&grid)[Rows][Cols]);

template<size_t Rows, size_t Cols>
void printGrid(int (&grid)[Rows][Cols]);

int main() {
    int grid[5][6];
    zig_zag_fill(grid);
    printGrid(grid);
    std::cout << '\n';
    int grid2[6][5];
    zig_zag_fill(grid2);
    printGrid(grid2);
    std::cout << '\n';
    int grid3[5][5];
    zig_zag_fill(grid3);
    printGrid(grid3);
    std::cout << '\n';
    int grid4[6][6];
    zig_zag_fill(grid4);
    printGrid(grid4);
    std::cout << '\n';
}

template<size_t Rows, size_t Cols>
void initGrid(int (&grid)[Rows][Cols]) {
    int value = 1;
    for (size_t j = 0; j < Cols; ++j) {
        for (size_t i = 0; i < Rows; ++i, ++value) {
            grid[i][j] = value;
        }
        ++j;
        if (j == Cols )
            break;
        for (size_t i = Rows; i > 0; ++value) {
            --i;
            grid[i][j] = value;
        }
    }
}

template<size_t Rows, size_t Cols>
void zig_zag_fill(int (&grid)[Rows][Cols])
{
    int diff_up = 1;
    int diff_down = Rows * 2 - 1;
    for (size_t i = 0; i < Rows; ++i, diff_down -= 2, diff_up += 2)
    {
        int value = i + 1;
        size_t j = 0;
        while ( j < Cols )
        {
            grid[i][j] = value;
            value += diff_down;
            ++j;
            if ( j == Cols )
                break;
            grid[i][j] = value;
            value += diff_up;
            ++j;
        }
    }
}


template<size_t Rows, size_t Cols>
void printGrid(int (&grid)[Rows][Cols]) {
    for (size_t i = 0; i < Rows; ++i) {
        for (size_t j = 0; j < Cols; ++j) {
            std::cout << std::setw(2) << grid[i][j] << " ";
        }
        std::cout << '\n';
    }
}

1 10 11 20 21 30 
 2  9 12 19 22 29 
 3  8 13 18 23 28 
 4  7 14 17 24 27 
 5  6 15 16 25 26 

 1 12 13 24 25 
 2 11 14 23 26 
 3 10 15 22 27 
 4  9 16 21 28 
 5  8 17 20 29 
 6  7 18 19 30 

 1 10 11 20 21 
 2  9 12 19 22 
 3  8 13 18 23 
 4  7 14 17 24 
 5  6 15 16 25 

 1 12 13 24 25 36 
 2 11 14 23 26 35 
 3 10 15 22 27 34 
 4  9 16 21 28 33 
 5  8 17 20 29 32 
 6  7 18 19 30 31