Переключение элементов массива в C

Question

Поэтому я хочу переключить элементы массива с 32 целыми числами "n" раз.

Все элементы должны быть на следующей позиции, а последний должен быть на первой.

Я пробовал что-то вроде этого:

while(scanf("%d", &n) != EOF)
{
    for(int j=0; j<n; j++)
    for(int i=1; i<31; i++)
    {
        t[0]=t[31];
        tmp=t[i];
        t[i]=t[i+1];
    }
}

Я не уверен, как я могу использовать переменную tmp для решения этой проблемы.

это элемент массива:

1 23 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

и это должно выглядеть так, если n = 1:

32 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

Answer 1

Ниже приведено не редактирование кода, а более эффективное решение со временем выполнения O (n):

void rightshift(char array[LENGTH])
{
    int i, next = array[0];

    for (i = 1; i < LENGTH; i++)
    {
        char temp = array[i];
        array[i] = next;
        next = temp;
    }

    array[0] = next;
}

Answer 2

Ваш своп неверный, он должен выглядеть так:

char temp = t[i];
t[i] = t[i + 1];
t[i + 1] = temp;

Кроме того, если вам нужен такой бесконечный цикл, я рекомендую пропустить пробел в scanf, например:

while (scanf(" %d", &n) == 1) // note the space before %d

В целом, вот как это может выглядеть:

int main(int argc, char** argv) {
    char t[33] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456"; // 33 elements to leave space for '\0'
    int n;
    while (scanf(" %d", &n) == 1)
    {
        for (int j = 0; j < n; j++)
            for (int i = 0; i < 31; i++)
            {
                char temp = t[i];
                t[i] = t[i + 1];
                t[i + 1] = temp;
            }
        printf("string: %s\n", t);
    }
    return 0;
}

Answer 3

Во-первых, обратите внимание, что для поворота массива с 32 элементами n раз вам нужно только повернуть его n % 32 раз. В качестве альтернативы, которая может оказаться не самой быстрой, по сравнению с уже представленными решениями, приведенный ниже код копирует два фрагмента памяти исходного массива в обратном порядке, который равен смещению прав массива n раз.

#define LEN 32
#define NUMBER_OF_ROTATIONS 56

int array_to_rotate[LEN];

int* tmp = malloc(sizeof(int) * LEN);

int n = NUMBER_OF_ROTATIONS % LEN;

// copying the last n elements of array_to_rotate to the beginning of tmp array
memcpy(tmp, (array_to_rotate + LEN - n), n * sizeof(int));

// copying first (LEN - n) elements of array_to_rotate behind the elements already copied to tmp array
memcpy((tmp + n), array, (LEN - n) * sizeof(int));

//replacing the original array with the one obtained after rotation n times
memcpy(array, tmp, sizeof(int) * LEN));

free(tmp);

Answer 4

Поскольку элементы смещаются на 1 позицию каждый раз, вы можете сделать это более эффективным. Вам не нужно использовать временную переменную для каждого элемента, но только для первого / последнего. Вам не нужно менять местами каждую пару смежных элементов.

void rotate_by_1(char array[], size_t elem)
{
    int i;

#ifdef ROTATE_LEFT
    // Rotate in one direction...
    char tmp = array[0];
    for (i = 0; i < elem-1; i++)
    {
        array[i] = array[i+1];
    }
    array[elem-1] = tmp;
#endif

#ifdef ROTATE_RIGHT
    // Rotate in the other direction...
    char tmp = array[elem-1];
    for (i = elem-1; i > 0; i--)
    {
        array[i] = array[i-1];
    }
    array[0] = tmp;
#endif
}

Не проверено ...