对角循环通过 2-dim 矩阵，但反过来

Question

我无法以另一种方式循环遍历 NxM 矩阵。

这可能不是我可以尝试的所有内容，但我已经尝试在 google 上找到它，并使用各种不同的边框值，还尝试一遍又一遍地减去另一个索引，但我似乎无法掌握它。我做的最后一件事是创建矩阵的副本，并通过 for 循环交换行，直到最后一个是第一个，第一个是最后一个。这可行，但不是我想要的。

那里的循环从矩阵的左上角开始，从左下角到右上角。我希望另一个人从左下角开始，从右下角到左上角，或者从左上角到右下角。

循环：

for(int i = 0; i + 1 < ROWCOUNT + COLCOUNT; i++) {
    printf("\n");
    for(int j = 0; j - 1 < i; j++) {
        int n = i - j;
        int m = j;
        if(n < ROWCOUNT && m < COLCOUNT) {
            printf("  %d %d  ", n, m);
        }
    }
}
Output:
  0 0
  1 0    0 1
  2 0    1 1    0 2
  3 0    2 1    1 2    0 3
  4 0    3 1    2 2    1 3    0 4
  5 0    4 1    3 2    2 3    1 4    0 5
  5 1    4 2    3 3    2 4    1 5
  5 2    4 3    3 4    2 5
  5 3    4 4    3 5
  5 4    4 5
  5 5

编辑：我将尝试向您展示我正在尝试做的事情。

A   B   C   D   E   F
G   H   I   J   K   L
M   N   O   P   Q   R
S   T   U   V   W   X
Y   Z   AA  AB  AC  AD
AE  AF  AG  AH  AI  AJ

我的循环通过以下方式遍历这个 6x6 矩阵：

A
G  B
M  H  C
S  N  I  D
Y  T  O  J  E
AE Z  U  P  K  F
AF AA V  Q  L
AG AB W  R
AH AC X
AI AD
AJ

我正在寻找一个循环以通过另一种方式。基本上是这样的：

AE
AF Y
AG Z  S
AH AA T  M
AI AB U  N  G
AJ AC V  O  H  A
AD W  P  I  B
R  K  D
L  E
F

编辑：@pmg 为我提供了解决方案。谢谢！

Answer 1

不确定您在寻找什么，但只是循环往下看：

#include  "stdio.h"
#define ROWCOUNT  6
#define COLCOUNT 6

int main(void) {
    for(int i = ROWCOUNT - 1; i >= 0; i--) {
        for(int j = 0; j < COLCOUNT; j++) {
            printf("  %d %d  ", i, j);
        }
        printf("\n");
    }
}

输出

5 0    5 1    5 2    5 3    5 4    5 5  
4 0    4 1    4 2    4 3    4 4    4 5  
3 0    3 1    3 2    3 3    3 4    3 5  
2 0    2 1    2 2    2 3    2 4    2 5  
1 0    1 1    1 2    1 3    1 4    1 5  
0 0    0 1    0 2    0 3    0 4    0 5  

Answer 2

两条对角线都具有每个单元格索引添加到一个常数或它们的差是常数的属性。在您的情况下，索引必须添加到常量。只需考虑一个位于您想要的对角线上的单元格（要打印的第一个单元格），然后当您添加到一个索引时，从另一个索引中减去相同的数量，使总和相同。这样你就可以从零开始：

i = 0; j = 0;

然后，将总和加一并遵循：

pru.c:

#include <stdio.h>
#include <getopt.h>
#include <stdlib.h>

int N = 10;

int main(int argc, char **argv)
{
    int opt;
    while ((opt = getopt(argc, argv, "n:")) != EOF) {
            switch(opt) {
            case 'n': N = atoi(optarg); break;
            }
    } /* while */

    int sum;
    /* maximum value is (N-1) + (N-1) = 2N-2 */
    for (sum = 0; sum <= 2*N - 2; sum++) {
            /* initial values */
            int i = sum < N ? sum : N-1; /* will be decremented */
            int j = sum - i; /* must add to sum, will be incremented */
            char *sep = "";
            for (; i >= 0 && j < N; i--, j++) {
                    printf("%sA[%d, %d]", sep, i, j);
                    sep = " -> ";
            }
            printf("\n");
    }
}

示例代码打印要打印的索引序列：

$ pru -n 5
A[0, 0]
A[1, 0] -> A[0, 1]
A[2, 0] -> A[1, 1] -> A[0, 2]
A[3, 0] -> A[2, 1] -> A[1, 2] -> A[0, 3]
A[4, 0] -> A[3, 1] -> A[2, 2] -> A[1, 3] -> A[0, 4]
A[4, 1] -> A[3, 2] -> A[2, 3] -> A[1, 4]
A[4, 2] -> A[3, 3] -> A[2, 4]
A[4, 3] -> A[3, 4]
A[4, 4]

---

在指数不同的情况下，您有：

pru2.c

#include <stdio.h>
#include <getopt.h>
#include <stdlib.h>

int N = 10;

int main(int argc, char **argv)
{
    int opt;
    while ((opt = getopt(argc, argv, "n:")) != EOF) {
            switch(opt) {
            case 'n': N = atoi(optarg); break;
            }
    } /* while */

    int dif;
    /* difference ranges from -(N-1) to +(N-1) */
    for (dif = -N+1; dif <= N-1; dif++) {
            /* initial values, dif = i - j */
            int i = dif > 0 ?    0 : dif; /* will be incremented */
            int j = dif > 0 ? -dif :   0; /* will be incremented */
            char *sep = "";
            for (; i < N && j < N; i++, j++) {
                    printf("%sA[%d, %d]", sep, i, j);
                    sep = " -> ";
            }
            printf("\n");
    }
}

这将给：

A[4, 0]
A[3, 0] -> A[4, 1]
A[2, 0] -> A[3, 1] -> A[4, 2]
A[1, 0] -> A[2, 1] -> A[3, 2] -> A[4, 3]
A[0, 0] -> A[1, 1] -> A[2, 2] -> A[3, 3] -> A[4, 4]
A[0, 1] -> A[1, 2] -> A[2, 3] -> A[3, 4]
A[0, 2] -> A[1, 3] -> A[2, 4]
A[0, 3] -> A[1, 4]
A[0, 4]