Question

我正在尝试打印一个数组，以便偶数字符串向后打印，但是通常的方式不是偶数字符串。我做错了什么？例如：

1 0 3
9 7 3
5 7 8

我需要它：

1 0 3
3 7 9
5 7 8

但我也有以螺旋方式填充阵列的问题;我该怎么做一个数组的中心？拜托，你能说出一个主意 - 我该怎么做？阵列必须是方形的。例如：

1 2 3
4 5 6
7 8 9

但我需要它：

3 2 9
4 1 8
5 6 7

到目前为止我的代码：

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


int main()
{
    int a[10][10],n,m,i,j;

    printf("Enter m: ");
    scanf("%d",&m);
    printf("Enter n: ");
    scanf("%d",&n);
    for(i=0;i<m;i++){
            for(j=0;j<m;j++){
                    printf("a[%d][%d]: ",i+1,j+1);
       scanf("%d",&a[i][j]);
            }
    }

// in usual order
    for(i=0;i<m;i++){
            for(j=0;j<n;j++){
            printf("%d ",a[i][j]);
                }
                printf("\n");
        }


        for(i=0;i<m;i++){
            for(j=0;j<n;j++){
            if(i%2 != 0){
            printf("%d ",a[i][j]);
            }
              else {
                    printf("%d ",a[n-i+1][j]);
                }
            }
            printf("\n");
        }

    return 0;
}

Answer 1

以螺旋形填充数组的示例

#include <stdio.h>
#include <string.h>

typedef enum {
    N, W, S, E
} Dir;

typedef struct walker {
    int row, col;
    Dir dir;
    int steps;
} Walker;

Walker go_forward(Walker walker){
    switch(walker.dir){
    case N:
        walker.row -= 1;
        break;
    case W:
        walker.col -= 1;
        break;
    case S:
        walker.row += 1;
        break;
    case E:
        walker.col += 1;
        break;
    }
    return walker;
}

Walker proceed_left(Walker walker){
    walker.dir = (walker.dir + 1) % 4;//turn left
    walker = go_forward(walker);
    return walker;
}

int main(void){
    int n;
    for(;;){
        printf("Enter n(0 < n < 10): ");fflush(stdout);
        int ret_s = scanf("%d", &n);
        if(ret_s == 1){
            if(0 < n && n < 10)
                break;
        } else if(ret_s == 0)
            while(getchar() != '\n');//clear input
        else //if(ret_s == EOF)
            return 0;
    }
    int a[n][n];
    memset(a, 0, sizeof(a));//zero clear
    Walker walker = { .row = n / 2, .col = n / 2, .dir = E, .steps = 0 };
    for(;;){
        walker.steps += 1;
        a[walker.row][walker.col] = walker.steps;
        if(walker.steps == n * n)//goal
            break;
        Walker left = proceed_left(walker);
        if(a[left.row][left.col] == 0)//left side is vacant
            walker = left;
        else
            walker = go_forward(walker);
    }
    for(int r = 0; r < n; ++r){
        for(int c = 0; c < n; ++c){
            if(c)
                putchar(' ');
            printf("%2d", a[r][c]);
        }
        puts("");
    }
}

Answer 2

这是一个包含函数spiral_fill()的程序，该函数用顺序int填充方形数组，从中心的1开始，然后以逆时针方向旋转。该函数通过首先在中心存储1，然后在上方和左侧填充L形区域，然后在下方和右侧填充数组来填充数组，并继续直到数组被填充。

#include <stdio.h>

#define ARR_SZ  3

void spiral_fill(size_t arr_sz, int arr[arr_sz][arr_sz]);
void print_arr(size_t rows, size_t cols, int arr[rows][cols]);

int main(void)
{
    int test_arr[ARR_SZ][ARR_SZ];

    spiral_fill(ARR_SZ, test_arr);
    print_arr(ARR_SZ, ARR_SZ, test_arr);

    return 0;
}

void spiral_fill(size_t arr_sz, int arr[arr_sz][arr_sz])
{
    int center = arr_sz / 2;
    int current = center;
    int start_col, stop_col, start_row, stop_row;
    size_t layer = 0;
    int next_val = 1;

    arr[center][center] = next_val++;
    ++layer;

    while (layer < arr_sz) {
        if (layer % 2) {            // For odd layers, fill upper L
            current -= layer;

            start_col = center + layer / 2;
            stop_col = center - (layer + 1) / 2;
            for (int j = start_col; j >= stop_col; j--) {
                arr[current][j] = next_val++;
            }
            start_row = center - layer / 2;
            stop_row = center + layer / 2;
            for (int i = start_row; i <= stop_row; i++) {
                arr[i][current] = next_val++;
            }
            ++layer;
        } else {                    // For even layers, fill lower L
            current += layer;

            start_col = center - layer / 2;
            stop_col = center + layer / 2;
            for (int j = start_col; j <= stop_col; j++) {
                arr[current][j] = next_val++;
            }
            start_row = center + (layer - 1) / 2;
            stop_row = center - layer / 2;
            for (int i = start_row; i >= stop_row ; i--) {
                arr[i][current] = next_val++;
            }
            ++layer;
        }
    }
}

void print_arr(size_t rows, size_t cols, int arr[rows][cols])
{
    for (size_t i = 0; i < rows; i++) {
        for (size_t j = 0; j < cols; j++) {
            printf("%-5d ", arr[i][j]);
        }
        putchar('\n');
    }
}

这是一个3X3阵列：

3     2     9     
4     1     8     
5     6     7

这是一个6X6阵列：

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

甚至是向后排列的数组字符串

2 个答案: