用c语言实现，素数幻方 求四阶的素数幻方。即在一个4*4的矩阵中，每一个格填入一个数字，使每一行、每一列和两条对角线上的四个数字所组成的四位数，均为可逆素数（改数逆序后仍是素数）。 提示：这样的矩阵有很多。 **输出提示信息："There are magic aquares with invertable primes as follow:\n" **输出格式要求："No.%d\n" "%6d" 程序运行示例如下： There are magic aquares with invertable primes as follow: No.1 1 1 9 3 1 0 0 9 9 2 2 1 3 1 9 1 No.2 1 1 9 3 1 0 2 1 9 0 2 9 3 9 1 1 ......

好的，以下是用C语言实现的代码：

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

#define N 4

bool is_prime(int n) {
    if (n <= 1) {
        return false;
    }
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}

bool is_invertible_prime(int n) {
    if (!is_prime(n)) {
        return false;
    }
    int m = 0;
    while (n > 0) {
        m = m * 10 + n % 10;
        n /= 10;
    }
    return is_prime(m);
}

int magic[N][N];

void print_magic(int count) {
    printf("No.%d\n", count);
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("%6d", magic[i][j]);
        }
        printf("\n");
    }
}

void search(int i, int j, int count) {
    for (int k = 1; k <= N * N; k++) {
        if (is_invertible_prime(k)) {
            bool ok = true;
            for (int l = 0; l < i && ok; l++) {
                if (magic[l][j] == k) {
                    ok = false;
                }
            }
            for (int l = 0; l < j && ok; l++) {
                if (magic[i][l] == k) {
                    ok = false;
                }
            }
            if (i == j) {
                for (int l = 0; l < i && ok; l++) {
                    if (magic[l][l] == k) {
                        ok = false;
                    }
                }
            }
            if (i + j == N - 1) {
                for (int l = 0; l < i && ok; l++) {
                    if (magic[l][N - 1 - l] == k) {
                        ok = false;
                    }
                }
            }
            if (ok) {
                magic[i][j] = k;
                if (i == N - 1 && j == N - 1) {
                    bool is_magic = true;
                    for (int l = 0; l < N && is_magic; l++) {
                        int row = magic[l][0] * 1000 + magic[l][1] * 100 + magic[l][2] * 10 + magic[l][3];
                        int col = magic[0][l] * 1000 + magic[1][l] * 100 + magic[2][l] * 10 + magic[3][l];
                        if (!is_invertible_prime(row) || !is_invertible_prime(col)) {
                            is_magic = false;
                        }
                    }
                    int diag1 = magic[0][0] * 1000 + magic[1][1] * 100 + magic[2][2] * 10 + magic[3][3];
                    int diag2 = magic[0][3] * 1000 + magic[1][2] * 100 + magic[2][1] * 10 + magic[3][0];
                    if (!is_invertible_prime(diag1) || !is_invertible_prime(diag2)) {
                        is_magic = false;
                    }
                    if (is_magic) {
                        print_magic(count);
                        count++;
                    }
                } else {
                    if (j == N - 1) {
                        search(i + 1, 0, count);
                    } else {
                        search(i, j + 1, count);
                    }
                }
                magic[i][j] = 0;
            }
        }
    }
}

int main() {
    printf("There are magic aquares with invertable primes as follow:\n");
    int count = 1;
    search(0, 0, count);
    return 0;
}

该代码的思路和前面的Python代码类似，不过有一些细节需要注意：

- 使用了递归函数 `search` 来实现回溯算法。
- 使用一个计数器 `count` 来记录找到的素数幻方的数量。
- 在找到一个素数幻方后，使用函数 `print_magic` 来输出该幻方。
- 在判断一个数是否是可逆素数时，使用了一个循环来将该数的数字逆序排列。