Question

我们有一些长度（例如3）和一些计数序列的数组：0,1,2,3,4,...至无穷大。在该输入序列之外，我们需要生成将在数组中来回移动的序列，例如：0,1,2,1,0,1,2,1,0,...，依此类推，直到length=3。

我认为这项任务在许多编程书籍中都是很常见的，但是我找不到标准的解决方案，因此我创建了自己的解决方案。还有其他更有效，更优雅的解决方案，因为我不喜欢我的解决方案？？？

#define LENGTH 5
int main()
{
   char arr[LENGTH] = {'a','b','c','d','e'};
   int i;
   int base=0;
   for(i=0;i<100;i++){ 
        if(i%(LENGTH-1)==0){ 
            if(base==0) base=LENGTH-1;
            else base =0;
        }
    int j = abs(base-i%(LENGTH-1)); 
    printf("%c ",arr[j]); 
   }
}

Java代码（为方便起见）：

public static void traverse(){
        char arr[] = {'a','b','c','d','e'};
        int base=0;
        for(int i=0;i<100;i++){ 
            if(i%(arr.length-1)==0){ 
            if(base==0) base=arr.length-1;
            else base =0;
            }
        int j = Math.abs(base-i%(arr.length-1)); 
        System.out.println(arr[j]+" ");
        }
    }

Answer 1

也许是这样的：

#define LENGTH 5
int main()
{
    char arr[LENGTH] = { 'a','b','c','d','e' };
    int current = 0;
    int direction = 1;
    for (int i = 0; i < 100; i++) 
    {       
        printf("%c ", arr[current]);
        if (current == 0)
            direction = 1;
        else if (current == LENGTH - 1)
            direction = -1;
        current += direction;
    }
}

Answer 2

此解决方案仅根据arr计算i的索引，从而避免了保持任何状态（例如当前方向）的需要。结果，它有点复杂，但也可以用于i的非连续值。

char arr[] = { '0', '1', '2', '3', '4' };
const int LENGTH = sizeof arr / sizeof(*arr); // not necessary for char
assert(LENGTH > 1); // doesn't work for fewer than 2 elements

const int CYCLE = LENGTH - 1;
for (int i = 0; i < 100; ++i) { 
    printf("%c ", arr[ (i / CYCLE) & 1 ? CYCLE - i % CYCLE : i % CYCLE ]);
}
printf("\n");

说明：i / CYCLE是通过数组的循环数，& 1检查该数的最低有效位以确定方向（该位为1的奇数循环向后，即使循环–从0开始–前进）。 i % CYCLE是转发周期，但是由于CYCLE = LENGTH - 1，它没有到达数组的最后一个索引。 CYCLE - i % CYCLE是倒退周期，从CYCLE - 0开始，这是前进时未到达的最后一个索引，到1结束，从而避免了重复索引{{1} }。当再次前进时。

换句话说，向前和向后周期都省略了一个索引，以避免在改变方向时重复，因此0，这也意味着CYCLE = LENGTH - 1必须至少为LENGTH到避免被零除。

来回遍历数组

2 个答案: