C-迭代0和1的数组，就像二进制数一样

我需要迭代n个元素的数组动态大小，例如4，就好像它是一个二进制数一样，从所有零开始{0,0,0,0}。每次它都需要像二进制一样递增，{0,0,0,0}->{0,0,0,1}->{0,0,1,0}->{0,0,0,1,1}->{0,1,0}，等等

我很难用数组值生成这样的算法，我曾考虑过使用递归，但除了ifs中的硬编码之外，找不到这样做的方法。我想我可以生成一个n位数的数字，然后应用中讨论的任何算法，但那将是不雅观的；OP要求打印n位数字，而我需要处理数组

如果有人能给我指出正确的方向那就太好了。 背景：

算法：

从最右边的元素开始。 如果是零，则将其设置为1并退出 它必须是一个；将其设置为零 如果您位于最左边的元素，则退出。 您还不是最左边的元素；向左移动一个元素并重复。

---

很抱歉，我无法提供代码示例。

不需要算法，您可以构建一个函数

如果阵列的大小固定，下面是一个好主意：

构建一个函数来获取数组 为此函数创建一个局部整数 将整数的位值设置为数组的单元格值 递增整数 设置数组值以匹配整数的每个位

---

所有这些过程都可以使用shifts>>完成，您似乎想要实现的是一个二进制计数器，或者更精确地说，它是在CPU的数字电路中使用逻辑门实现的。确切地说，它可以使用逻辑运算nand和xor的组合来完成

但根据我的优雅感，最优雅的方法是利用CPU的固有能力增加数字，并编写一个函数将数字分解为位数组：

void generate_bit_array(unsigned int value, uint8_t *bit_array, unsigned int bit_count) {
    for (unsigned int i=0; i<bit_count; i++) {
        bit_array[i] = value >> (bit_count - i - 1) & 0x01;
    }
}

int main(int argc, void **argv) {
    unsigned int    i;
    uint8_t         my_array[4];

    /* Iterate and regenerate array's content */
    for (i=0; i<4; i++) {
        generate_bit_array(i, my_array, 4);
        /* Do something */
    }

    return 0;
}

---

如果我理解正确，那么你需要的是如下内容

#include <stdio.h>

#define N   4

void next_value( unsigned int a[], size_t n )
{
    unsigned int overflow = 1;

    for ( size_t i = n; i != 0 && overflow; i-- )
    {
        overflow = ( a[i-1] ^= overflow ) == 0;
    }
}

int empty( const unsigned int a[], size_t n )
{
    while ( n && a[n-1] == 0 ) --n;

    return n == 0;
}

int main(void)
{
    unsigned int a[N] = { 0 };

    do 
    {
        for ( size_t i = 0; i < N; i++ ) printf( "%i ", a[i] );
        putchar( '\n' );
        next_value( a, N );
    } while ( !empty( a, N ) );

    return 0;
}

或者，您可以编写计算下一个值的函数，如果下一个值等于0，则函数返回0

比如说

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

int next_value( unsigned int a[], size_t n )
{
    unsigned int overflow = 1;

    for ( ; n != 0 && overflow; n-- )
    {
        overflow = ( a[n-1] ^= overflow ) == 0;
    }

    return  overflow == 0;
}

int main(void)
{
    size_t n;

    printf( "Enter the length of the binary number: " );
    if ( scanf( "%zu", &n ) != 1 ) n = 0;

    unsigned int *a = calloc( n, sizeof( unsigned int ) );

    do 
    {
        for ( size_t i = 0; i < n; i++ ) printf( "%i ", a[i] );
        putchar( '\n' );
    } while ( next_value( a, n ) );

    free( a );

    return 0;
}

算法：

从最右边的元素开始

如果是零，则将其设置为1并退出

它必须是一个；将其设置为零

如果您位于最左边的元素，则退出

您还不是最左边的元素；向左移动一个元素并重复

这是海米的算法，我将尝试用它编写代码：

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

int my_algo(int *arr, int size) {
  for (int i = size - 1; i >= 0; i--) { // Start at the rightmost element
    if (arr[i] == 0) { // If it's a zero, then set it to one and exit
      arr[i] = 1;
      return 1;
    } else if (arr[i] == 1) { // If it's a one, set it to zero and continue
      arr[i] = 0;
    }
  }
  return 0; // stop the algo if you're at the left-most element
}

int main() {
    int n;
    scanf("%d", &n);
    int *arr = calloc(n, sizeof(int));
    do {
      for (int i = 0; i < n; i++) {
        putchar(arr[i] + '0');
      }
      putchar('\n');
    } while (my_algo(arr, n));
    return (0);
}

你可以做：

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

void gen_bit_array(int *numarr, int n, int arr_size) {
        if(n > 0) {
                numarr[arr_size-n] = 0;
                gen_bit_array(numarr, n-1, arr_size);
                numarr[arr_size-n] = 1;
                gen_bit_array(numarr, n-1, arr_size);
        } else {
                int i;
                for(i=0; i<arr_size; i++)
                        printf("%d", numarr[i]);
                printf ("\n");
    }
}

int main() {
        int n,i;
        printf ("Enter array size:\n");
        scanf("%d", &n);
        int *numarr = calloc(n, sizeof(int));
        if (numarr == NULL)
                return -1;
        gen_bit_array(numarr, n, n);
        return 0;
}

---

我想这取决于你的出发点是什么，以及你想如何发飙。例如，您是增加一个int值，然后将其转换为所需的输出，还是需要“解析”数组以找到当前值，然后增加它？@Neil我被您的意思弄糊涂了：每次以二进制增量方式改革数组时，我都会调用一个使用该数组中的值的函数，对于这篇博文，哪些工作被认为是不必要的，难道不只是切换每个值吗？@Isaiah不，它不会。在纸上试试看。如果你用复制其余的数字来代替exit，那么你就完成了，这可能是你在小学学过的加法。我明白了，我被前面使用的术语弄糊涂了：]太好了，谢谢！它是动态的大小，但是，我将更新我的问题，以更清楚地反映这一点

Enter the length of the binary number: 3
0 0 0 
0 0 1 
0 1 0 
0 1 1 
1 0 0 
1 0 1 
1 1 0 
1 1 1 

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

int my_algo(int *arr, int size) {
  for (int i = size - 1; i >= 0; i--) { // Start at the rightmost element
    if (arr[i] == 0) { // If it's a zero, then set it to one and exit
      arr[i] = 1;
      return 1;
    } else if (arr[i] == 1) { // If it's a one, set it to zero and continue
      arr[i] = 0;
    }
  }
  return 0; // stop the algo if you're at the left-most element
}

int main() {
    int n;
    scanf("%d", &n);
    int *arr = calloc(n, sizeof(int));
    do {
      for (int i = 0; i < n; i++) {
        putchar(arr[i] + '0');
      }
      putchar('\n');
    } while (my_algo(arr, n));
    return (0);
}

0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111

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

void gen_bit_array(int *numarr, int n, int arr_size) {
        if(n > 0) {
                numarr[arr_size-n] = 0;
                gen_bit_array(numarr, n-1, arr_size);
                numarr[arr_size-n] = 1;
                gen_bit_array(numarr, n-1, arr_size);
        } else {
                int i;
                for(i=0; i<arr_size; i++)
                        printf("%d", numarr[i]);
                printf ("\n");
    }
}

int main() {
        int n,i;
        printf ("Enter array size:\n");
        scanf("%d", &n);
        int *numarr = calloc(n, sizeof(int));
        if (numarr == NULL)
                return -1;
        gen_bit_array(numarr, n, n);
        return 0;
}

Enter array size:
2
00
01
10
11

Enter array size:
4
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111