使用二维数组的灰色代码（C）

我的任务是使用递归打印灰色代码。用户在

0-8

之间输入一个位值，因此

字符串的最大数量为256（2^8）

我已经完成了基本情况，但我不知道我会为其他部分做什么

到目前为止，我的代码是：

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

void gcodes (int n) {
    char bits[256][8];
    int i, j;
    int x = pow (2, n);

    if (n == 1) {
        bits[0][0] = '0';
        bits[1][0] = '1';
    } else {
        gcodes (n-1);
    }

    for (i=0; i<x; i++) {
        for (j=0; j<n; j++) {
            printf("%c", reverse[i][j]);
        }
    printf("\n");
    }
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        printf("Invalid number of arguments\n");
        return 0;
    }

    int n;
    n = atoi (argv[1]);

    if (n > 8 || n <= 0) {
        printf("Invalid integer\n");
        return 0;
    }

    gcodes (n);
}

#包括
#包括
#包括
无效gcodes（int n）{
字符位[256][8]；
int i，j；
int x=功率（2，n）；
如果（n==1）{
位[0][0]=“0”；
位[1][0]=“1”；
}否则{
gcodes（n-1）；
}
对于（i=0；i而言，一个格雷码从一个数字到下一个连续数字只能有一个位的变化。在整个序列中，没有重复值

根据该标准，有几种可能的格雷码实现

有几个死区序列，其中值从ok开始，然后失败

通过代码计算格雷码需要大量的实验

实际上，从网络中简单地找到一个有效的格雷码序列，并将其粘贴到任何需要格雷码序列的程序中，要容易得多

通常，输入是一个灰色编码的轮子，读取该轮子以确定轮子是否移动，而不是代码中生成的东西

但是，如果我正在实现一个格雷码生成器，我希望它在最后生成的值和建议的新/下一个值之间执行异或，如果该值有效（仅更改了一位），我将搜索现有的值表以确保它不是重复的

这个问题提出了一个可能的算法：


答案重复如下：

所有四个问题的答案都是，该算法不是从较低的n值开始的。它生成的所有字符串都具有相同的长度，第i个（对于i=1，…，2n-1）字符串是从第（i-1）个字符串生成的

以下是n=4的前几个步骤：

从G0=0000开始

要生成G1，请翻转G0中的第0位，因为0是二进制表示法1=0001b中最低有效1的位置。G1=0001

要生成G2，请翻转G1中的第一位，因为1是二进制表示形式2=0010b中最低有效1的位置。G2=0011

要生成G3，请翻转G2中的第0位，因为0是二进制表示法3=0011b中最低有效1的位置。G3=0010

要生成G4，请翻转G3中的第2位，因为2是二进制表示法4=0100b中最低有效1的位置。G4=0110

要生成G5，请翻转G4中的第0位，因为0是5=0101b的二进制表示中最低有效1的位置。G5=0111。
因为您定义了

    char bits[256][8];

由于函数
gcodes（）
中的自动存储持续时间，数组的生存期在从函数返回时结束，因此您将丢失递归调用的结果。因此，至少要定义它

    static char bits[256][8];

或者，如果要保留生成的
位
，以便在
gcodes（）
之外使用，则可以全局使用


由于在标准格雷码中，最低有效位（位0）遵循0110的重复模式，因此即使n＝1不需要完整模式，也可以方便地在基本情况下设置完整模式

对于第i个代码的位j，其中j>0，其值可取自代码i/2的位j-1

这将导致完成功能：

void gcodes(int n)
{
    static char bits[256][8];
    int i, j, x = pow(2, n);

    if (n == 1)
    {
        bits[0][0] = '0';
        bits[1][0] = '1';
        bits[2][0] = '1';
        bits[3][0] = '0';
    }
    else
    {
        gcodes(n-1);
        // generate bit j (from n-1 down to 1) for codes up to x-1
        for (i=0, j=n; --j; i=x/2)
            for (; i<x; i++)
                bits[i][j] = bits[i/2][j-1];
        // replicate bit 0 for codes up to x-1
        for (; i<x; i++)
            bits[i][0] = bits[i%4][0];
    }

    for (i=0; i<x; i++, printf("\n"))
        for (j=n; j--; )
            printf("%c", bits[i][j]);
}

void gcodes（int n）
{
静态字符位[256][8]；
int i，j，x=功率（2，n）；
如果（n==1）
{
位[0][0]=“0”；
位[1][0]=“1”；
位[2][0]=“1”；
位[3][0]=“0”；
}
其他的
{
gcodes（n-1）；
//为高达x-1的代码生成位j（从n-1到1）
对于（i=0，j=n；--j；i=x/2）
为了