如何实现二维数组的坐标轴翻转？附示例与代码片段

咱们一步步拆解你的问题，先把初始数组和目标数组的内容明确列出来，再分析翻转操作的可能性：

初始数组（4行6列） #

• 第0行：0 1 2 2 1 0
• 第1行：1 0 0 0 0 1
• 第2行：1 0 0 0 0 1
• 第3行：0 1 1 1 1 0

目标数组 #

• 第0行：0 1 1 0 1 0
• 第1行：0 1 2 0 0 1
• 第2行：2 0 0 1 1 0
• 第3行：0 1 0 1 1 0

先明确翻转的定义 #

首先得搞清楚两种翻转的实际效果：

• X轴翻转（水平翻转）：把每一行的元素左右颠倒，比如行a b c d会变成d c b a
• Y轴翻转（垂直翻转）：把整个数组的行顺序上下颠倒，比如4行数组的第0行和第3行交换，第1行和第2行交换

逐一验证所有翻转组合 #

因为翻转两次就会回到原状态，所以总共只有4种可能的有效组合：无翻转、仅X轴翻转、仅Y轴翻转、X+Y轴翻转，咱们挨个对比：

1. 无翻转：直接对比初始和目标数组，显然每一行都对不上，排除。
2. 仅X轴翻转：你看初始数组的每一行都是对称的（比如第0行左右颠倒后还是自己），所以翻转后的数组和初始完全一样，自然和目标不匹配，排除。
3. 仅Y轴翻转：把初始数组的行上下颠倒后，得到的结果是：
   • 第0行：0 1 1 1 1 0（原第3行）
   • 第1行：1 0 0 0 0 1（原第2行）
   • 第2行：1 0 0 0 0 1（原第1行）
   • 第3行：0 1 2 2 1 0（原第0行）
     对比目标数组，所有行都不匹配，排除。
4. X+Y轴翻转：不管是先X再Y还是先Y再X，结果和仅Y轴翻转的数组一样（因为初始数组X翻转后不变），同样和目标对不上。

所以结论很明确：仅通过X轴和Y轴的翻转操作，没办法把你的初始数组转换成目标数组。

附：验证用的代码实现 #

结合你给出的代码片段，我写了一段完整的验证代码，你可以运行它来确认这个结论：

#include <stdio.h>
#include <stdbool.h>

#define MAX_HEIGHT 100
#define MAX_WIDTH 100

// 打印数组，方便查看结果
void print_board(int board[][MAX_WIDTH], int height, int width) {
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            printf("%d ", board[i][j]);
        }
        printf("\n");
    }
}

// 执行X轴水平翻转
void flip_x(int board[][MAX_WIDTH], int height, int width) {
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width / 2; j++) {
            int temp = board[i][j];
            board[i][j] = board[i][width - 1 - j];
            board[i][width - 1 - j] = temp;
        }
    }
}

// 执行Y轴垂直翻转
void flip_y(int board[][MAX_WIDTH], int height, int width) {
    for (int i = 0; i < height / 2; i++) {
        for (int j = 0; j < width; j++) {
            int temp = board[i][j];
            board[i][j] = board[height - 1 - i][j];
            board[height - 1 - i][j] = temp;
        }
    }
}

// 对比两个数组是否完全一致
bool is_equal(int a[][MAX_WIDTH], int b[][MAX_WIDTH], int height, int width) {
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            if (a[i][j] != b[i][j]) {
                return false;
            }
        }
    }
    return true;
}

int main() {
    int width = 6, height = 4;
    // 你给出的初始数组
    int initial[MAX_HEIGHT][MAX_WIDTH] = {
        {0,1,2,2,1,0},
        {1,0,0,0,0,1},
        {1,0,0,0,0,1},
        {0,1,1,1,1,0}
    };
    // 目标数组
    int target[MAX_HEIGHT][MAX_WIDTH] = {
        {0,1,1,0,1,0},
        {0,1,2,0,0,1},
        {2,0,0,1,1,0},
        {0,1,0,1,1,0}
    };
    
    // 复制初始数组用于测试不同翻转组合
    int test[MAX_HEIGHT][MAX_WIDTH];
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            test[i][j] = initial[i][j];
        }
    }
    
    // 测试各种翻转组合
    if (is_equal(test, target, height, width)) {
        printf("无需翻转即可匹配\n");
        return 0;
    }
    
    flip_x(test, height, width);
    if (is_equal(test, target, height, width)) {
        printf("仅X轴翻转即可匹配\n");
        return 0;
    }
    // 恢复初始状态
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            test[i][j] = initial[i][j];
        }
    }
    
    flip_y(test, height, width);
    if (is_equal(test, target, height, width)) {
        printf("仅Y轴翻转即可匹配\n");
        return 0;
    }
    
    flip_x(test, height, width);
    if (is_equal(test, target, height, width)) {
        printf("X轴+Y轴翻转即可匹配\n");
        return 0;
    }
    
    printf("无法通过X轴/Y轴翻转将初始数组转换为目标数组\n");
    return 0;
}

运行这段代码后，会输出无法通过X轴/Y轴翻转将初始数组转换为目标数组，和咱们的分析结果一致。

内容的提问来源于stack exchange，提问作者승기유