Question

我希望通过向后递增来遍历数组中所有值的组合所以我们有一个数组

    int array[10] = {0,0,0,0,0,0,0,0,0,0};

我想以这种方式增加它：{0,0,0,0,0,0,0,0,0,1}}＆gt; {0,0,0,0,0,0,0,0,0,2} ... {P-1，P-1，P-1，P-1，P-1，P-1，P -1，p-1，p-1，p-1}。

例如较小的数组，p = 3：{0,0,0}＆gt; {0,0,1}＆gt; {0,0,2}＆gt; {0,1,0}＆gt; {0 ，1,1}＆gt; {0,1,2} ...... {2,2,2}

数组可以sizeof(int)*m大，其中1 <= m <= 10。

有人可以帮我解决这个问题吗？

编辑：对不起，忘了这个..
好抱歉混淆但我还有一个条件..

那个数组不会是那种形式。它将是这样的示例

    int array[10] = {0,0,0,0,0,0,0,0,0,0};
    int help[10] = {3,4,0,1,0,0,3,0,1,0};

我希望得到数组[help []！= 0]中的值组合，在这种情况下 array [0]，array [1]，array [3]，array [6]，array [8] so - ＆gt;

    int array[10] = {0,0,0,0,0,0,0,0,0,0};
    int array[10] = {0,0,0,0,0,0,0,0,1,0};
    int array[10] = {0,0,0,0,0,0,0,0,2,0};
    int array[10] = {0,0,0,0,0,0,1,0,0,0};
    int array[10] = {0,0,0,0,0,0,1,0,1,0};
    int array[10] = {2,2,0,2,0,0,2,0,2,0};

p = 3
像（）循环那样的东西会变成i = 0,1,3,6,8，其中值是i = help [i]！= 0。

Answer 1

以下是一个例子：

void increment(int array[], size_t size, int limit)
{
     do
     {
         if (++array[--size] != limit)
         {
             break;
         }
         array[size] = 0; // value overflow
     }
     while (size);
}

用法：

int array[10];
memset(array, 0, sizeof(array));

increment(array, 10, 3);

编辑：带过滤器的算法

void increment(int array[], int filter[], size_t size, int limit)
{
     do
     {
         if (!filter[--size])
         {
             // skip this position
             continue;
         }
         if (++array[size] != limit)
         {
             break;
         }
         array[size] = 0; // value overflow
     }
     while (size);
}

Answer 2

我看到问题已经发生了一些变化，从向后递增一个数组到向一个基数（n）加一个......这是一个不同的问题。

int base = 3;

for( int i = (sizeof( array ) / sizeof( array[0] ))-1; i >= 0; )
{
    if( ++array[i] < base )
        break;
    else
        array[i--] = 0;
}

Answer 3

这相当于简单地递增自然数，从0到（p + 1）^ arrayLength，在基数p + 1中。

所以对你的例子来说，

for (long i=0; i<4^10; i++)
{
   convert i to string in base (p+1), left- padding with 0s
   convert characters in string to comma separated array format and print 
}

向后递增数组中的值

3 个答案: