Question

所以我有一个4x16的多维数组。我需要按特定顺序访问它，分为4x4部分：

阵列：

[  ][  ][  ][  ]
[  ][  ][  ][  ]
[  ][  ][  ][  ]
[  ][  ][  ][  ]

[  ][  ][  ][  ]
[  ][  ][  ][  ]
[  ][  ][  ][  ]
[  ][  ][  ][  ]

[  ][  ][  ][  ]
[  ][  ][  ][  ]
[  ][  ][  ][  ]
[  ][  ][  ][  ]

[  ][  ][  ][  ]
[  ][  ][  ][  ]
[  ][  ][  ][  ]
[  ][  ][  ][  ]

访问路线：

 1.
    [00]
                [03]
            [02]
        [01]    

 2.
        [05]
    [04]
                [07]
            [06]

 3.
            [10]
        [09]
    [08]
                [11]

 4.
                [15]
            [14]
        [13]
    [12]

 5.
    Repeat for next 4x4 block

生成的访问模式：

[00][05][10][15]
[04][09][14][03]
[08][13][02][07]
[12][01][06][11]

[16][21][26][31]
[20][25][30][19]
[24][29][18][23]
[28][17][22][27]

[32][37][42][47]
[36][41][46][35]
[40][45][34][39]
[44][33][38][43]

[48][53][58][63]
[52][57][62][51]
[56][61][50][55]
[60][49][54][59]

现在，我想以四点为一组访问这些内容，如上所示，我也希望看到预先访问的内容，所以我写了这个：

#define MAX(x, y) (((x) > (y)) ? (x) : (y))
#define MIN(x, y) (((x) < (y)) ? (x) : (y))

void main (void) {
    int m;
    int n;

    const int h = 16;
    const int w = 4;
    int skip;

    int x, y;

    // ABCD
    // BCDA
    // CDAB
    // DABC
    // ABCD

    // 0 => [0,0][3,1][2,2][1,3]
    // 1 => [1,0][0,1][3,2][2,3]
    // 2 => [2,0][

    for (x = 0; x < h; x++) {
        for (y = 0; y < w; y++) {
            m = w - ((x + y) % w);
            n = x + m;
            printf ("[%i,%i]", ((x + y)), n);
        }

        printf ("\n");

    }

    return;
}

当它运行时，我想得到一个输出：

[r,c][r,c][r,c][r,c]    (Group 0)
[r,c][r,c][r,c][r,c]    (Group 1)
...

例如：

0组＆amp; 1

[0,0][3,1][2,2][1,3]
[1,0][0,1][3,2][2,3]

...

第5组＆amp; 6

[5,0][4,1][7,2][6,3]
[6,0][5,1][4,2][7,3]

等等。

但是，我得到的输出是：

[0,4][1,3][2,2][3,1]
[1,4][2,3][3,2][4,5]
[2,4][3,3][4,6][5,5]
[3,4][4,7][5,6][6,5]
[4,8][5,7][6,6][7,5]
[5,8][6,7][7,6][8,9]
[6,8][7,7][8,10][9,9]
[7,8][8,11][9,10][10,9]
[8,12][9,11][10,10][11,9]
[9,12][10,11][11,10][12,13]
[10,12][11,11][12,14][13,13]
[11,12][12,15][13,14][14,13]
[12,16][13,15][14,14][15,13]
[13,16][14,15][15,14][16,17]
[14,16][15,15][16,18][17,17]
[15,16][16,19][17,18][18,17]

如何获得上述输出？

注意：

我知道我可以使用查找表，但之后我将它扩展为256x4096多维数组，因此查找表太大了。

Answer 1

GCC 4.8.2：gcc -Wall -Wextra main.c：

#include <stdio.h>

int main() {
  const int w = 4; // 256
  int i = 0;

  for (i = 0; i < w * w * 4 ; ++i) { // 16
    // Column calculation is trivial.
    int c = i % w;
    // Row calculation.
    int section_offset = (w * (i / (w * w)));
    int first_pass = ((w - i % w) % w);
    int shift = i / w;
    int r = (first_pass + shift) % w  + section_offset;
    printf("[%2i,%2i]", r, c);

    if (!((i + 1) % w)) {
      printf("    (Group %2i)\n", i / w); } }

  return 0; }

输出：

[ 0, 0][ 3, 1][ 2, 2][ 1, 3]    (Group  0)
[ 1, 0][ 0, 1][ 3, 2][ 2, 3]    (Group  1)
[ 2, 0][ 1, 1][ 0, 2][ 3, 3]    (Group  2)
[ 3, 0][ 2, 1][ 1, 2][ 0, 3]    (Group  3)
[ 4, 0][ 7, 1][ 6, 2][ 5, 3]    (Group  4)
[ 5, 0][ 4, 1][ 7, 2][ 6, 3]    (Group  5)
[ 6, 0][ 5, 1][ 4, 2][ 7, 3]    (Group  6)
[ 7, 0][ 6, 1][ 5, 2][ 4, 3]    (Group  7)
[ 8, 0][11, 1][10, 2][ 9, 3]    (Group  8)
[ 9, 0][ 8, 1][11, 2][10, 3]    (Group  9)
[10, 0][ 9, 1][ 8, 2][11, 3]    (Group 10)
[11, 0][10, 1][ 9, 2][ 8, 3]    (Group 11)
[12, 0][15, 1][14, 2][13, 3]    (Group 12)
[13, 0][12, 1][15, 2][14, 3]    (Group 13)
[14, 0][13, 1][12, 2][15, 3]    (Group 14)
[15, 0][14, 1][13, 2][12, 3]    (Group 15)

洞察力（如果有的话）是(i + X) % N旋转序列[0..N-1]，X次。

Answer 2

让我们稍微观察你的小组。一个值得注意的事实;每组以[row，0]开头。第二个事实，组中的每个后续元素都试图向右1-up。第三个事实，当它们达到最高限度时，它们会跌到谷底。这就是全部：

从[x, 0]
无论如何
如果我们不在天花板上，那就去吧，否则三下来

将其放入你的循环中：

...
for ( x = 0; x < h; x++ ) {
    m = x;  // start off with [x, ...
    n = 0;  // ... 0]
    for ( y = 0; y < w; y++ ) {
        printf( "[%i,%i]", m, n );
        m = ( m > x / w * w ) ? m - 1 : m + w - 1;
        // if not at ceiling, decrease m by 1, else increase by 3
        n++;    // increase n regardless
    }

    printf( "\n" );

}
...

我无法回答我的问题，所以如果你需要比这更灵活的东西，我很抱歉。如果您打算在8 256 x 256上使用它，并将它们放在彼此的顶部，这将很有用。

修改

如果您对分支感到不满意，就像您似乎对您的评论一样，那么请使用以下作业，作为上述三元作业的替代：

...
m = ( m + w - 1 ) % w + x / w * w;
...

上面的内容强加了一个带有偏移量x / w * w的模运算。

在数学中，在( mod w )下，m - 1和m - 1 + w都会描述相同的值。事实上，你可以根据需要增加w个，但它们都会融化。

问题是，在C中，%不是模运算符，而是余数运算符。因此，如果m == 0（发生w - 在第一个区块内多次发生）(m - 1) % w;将为负1，并且不会超过w - 1。

所以，我在数学中使用模运算符，我已在上面描述过。

x / w * w仅用于抵消。 ... / w * w将x降低到w的最接近倍数。

如果你打算使用权力为2的维度，那么你可以使用(x & ~(w - 1))同时将x降低到任何w的最接近的倍数是2的力量。像这样：

m = ( m + w - 1 ) % w + (x & ~(w - 1));

它通过清除用于表示w的单个位右侧的位来工作。例如，对于w = 256：

// bit representation of w
0000 ... 0001 0000 0000

// of w - 1
0000 ... 0000 1111 1111

// of ~(w - 1)
1111 ... 1111 0000 0000

& 0将清除&个&的那些位。{{1}} ee。结果将{{1}}减少到256的最接近倍数。

Answer 3

我不确定您要查找的是什么输出，但您可以获得以下输出：

 [0, 0] [3, 1] [2, 2] [1, 3]
 [1, 0] [0, 1] [3, 2] [2, 3]
 [2, 0] [1, 1] [0, 2] [3, 3]
 [3, 0] [2, 1] [1, 2] [0, 3]
 [0, 0] [3, 1] [2, 2] [1, 3]
 [1, 0] [0, 1] [3, 2] [2, 3]
 [2, 0] [1, 1] [0, 2] [3, 3]
 [3, 0] [2, 1] [1, 2] [0, 3]
 [0, 0] [3, 1] [2, 2] [1, 3]
 [1, 0] [0, 1] [3, 2] [2, 3]
 [2, 0] [1, 1] [0, 2] [3, 3]
 [3, 0] [2, 1] [1, 2] [0, 3]
 [0, 0] [3, 1] [2, 2] [1, 3]
 [1, 0] [0, 1] [3, 2] [2, 3]
 [2, 0] [1, 1] [0, 2] [3, 3]
 [3, 0] [2, 1] [1, 2] [0, 3]

使用此代码代替当前的for循环：

for (x = 0; x < h; x++) {
    for (y = 0; y < w; y++) {
        m = w - (x + w - 1 - (y % w)) % w - 1;
        n = x;
        printf ("[%i,%i]", m, n);
    }

    printf ("\n");

}

Answer 4

鉴于你的模式具有许多美丽的对称性，你可以选择结果，如意识结构的果实：

i块中j列的k行中的元素为(4*i+5*j)%16+16*k i，j ，k都在[0,3]范围内。

您希望在输出中看到它的n组包含4对(n/4*4+(n+4-i)%4, i)，i再次出现在[0,3]中。

const int h = 16;
const int w = 4;
int n,i;
for (n = 0; n < h; n++) {
    for (i = 0; i < w; i++) {
        printf ("[%i,%i]", (n/w)*w+(n+w-i)%w, i);
    }
    printf ("\n");
}

~~抱歉，我不确定语法是否正确，我现在没有任何c环境。~~ 编辑：它编译精细并产生所需的输出。

多维阵列图案化访问

4 个答案:

修改