Индекс манипулирования массивом в C

Question

Начиная с упорядоченного массива

 [1, 2, 3, 4, 5, 6, 8, 9, 10]

Как можно было бы получить для каждой итерации следующие результаты?

1   2   3   4   5   6   7   8   9   10
1   3   4   5   6   7   8   9   10   2
1   4   5   6   7   8   9   10   2   3
1   5   6   7   8   9   10   2   3   4
1   6   7   8   9   10   2   3   4   5
1   7   8   9   10   2   3   4   5   6
1   8   9   10   2   3   4   5   6   7
1   9   10   2   3   4   5   6   7   8
1   10   2   3   4   5   6   7   8   9


#include <stdio.h>    
#define MAX 10 
int a[MAX], i,j,cnt=2;
main (){
    for (i=0; i<MAX; i++){
       a[i]= i+1;
    }
    for (i=0; i<MAX; i++) {
        printf ("%d   ", a[i]);
    }
    printf ("\n");

    for (j=0; j < MAX-2;j++){
           a[0]=1;
           for (i=1; i < MAX-1; i++){
                if (a[i]%MAX != 0){
                       a[i]= a[i] + 1;
                }else{
                     if (a[i]==10) {
                     //printf ("a[%d]: %d \t ** %d\n", i , a[i] ,cnt);
                     //a[i-1]= i;
                    a[i]  = cnt;
                }
            }
        }
        for (i=0; i<MAX; i++)    {
                printf ("%d   ", a[i]);
         }

        printf ("\n");
       }
  }

Теперь я почти получаю, но последний столбец неправильно, что мне делать?

1   2   3   4   5   6   7   8   9   10   
1   3   4   5   6   7   8   9   10   10   
1   4   5   6   7   8   9   10   2   10   
1   5   6   7   8   9   10   2   3   10   
1   6   7   8   9   10   2   3   4   10   
1   7   8   9   10   2   3   4   5   10   
1   8   9   10   2   3   4   5   6   10   
1   9   10   2   3   4   5   6   7   10   
1   10   2   3   4   5   6   7   8   10 

Answer 1

C массивы индексируются от 0. Поэтому, когда вы обращаетесь к элементам от 1 до MAX, вы запускаете конец массива.

Ваши циклы должны быть от 0 до MAX-1. Обычный способ написать это

for (i=0 ; i < MAX ; ++i)

... так что любой, кто читает ваш код, может сразу доказать, что индекс массива никогда не равен MAX.

Answer 2

Ну, как минимум, массивы в C основаны на нуле, поэтому вы пишете после конца массива. Для объявленного массива int foo[MAX] допустимые элементы из foo[0]…foo[MAX-1]

В частности, [MAX] вполне может ссылаться на область памяти, которую использует переменная i, вызывая сброс цикла при попытке перезаписать [MAX].

Либо сдвиньте все на единицу, либо объявите ваш массив MAX + 1 и проигнорируйте нулевой бит.

О, и вам не нужно устанавливать a [1] = 1; каждый раз.