Algorithm to rotate an array does not work, whats wrong?

[ad_hoc()]

I'm trying to get a grasp of what this algorithm does such that it rotates an array's elements. For example an array with elements

{1,2,3,4,5,6,7,8,9,10}

is rotated to output

{4,3,2,1,10,9,8,7,6,5}

In particular there is a portion of the array that is XOR'd but done so in a way that is confusing to me. I'll post the code here, could someone please explain what the program is performing when XORing the elements in the array? Thanks!

#include <stdio.h>
void reverse_array(int[], int);
void rotate_array(int[], int, int);
int main(void) {
    int arr[] = {1,2,3,4,5,6,7,8,9,10};
    rotate_array(arr, 10, 2);//reverse array, not sure what parameters to pass here...
    return 0;
}

void rotate_array(int arr[], int n, int k) {
    reverse_array(arr,k);
    reverse_array(&arr[k],n-k);
    reverse_array(arr,n);
}

void reverse_array(int arr[], int n) {
    int j = n-1;
    for(int i = 0;i < j; i++, j--) {

        arr[i]^=arr[j]^=arr[i]^=arr[j];//what is happening here??
    
    }
    
    for(int k = 0; k < 10; k++)
       printf("value = %d\n", arr[k]);
}

[Salem]

> arr[i]^=arr[j]^=arr[i]^=arr[j];
Question 3.3b

It's someone's stupid trick to swap two variables without using a temporary variable.

Except in this case, it screws up badly if you happen to try to swap a variable with itself.

Just do
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;

[algorism]

The code works for me. If it doesn't work for you, it could only be because the xor trick has been written in a way that is UB. It should be split into three lines:

   a ^= b;
   b ^= a;
   a ^= b;

Actually, there's a tad more UB since you print beyond the bounds of the array in the second call to reverse_array (when the input array is actually only 8 ints long). The print code should be moved to main.

The purpose of the xor trick is to avoid a temporary variable, which doesn't save you much. Modern compilers should recognize idiomatic swap code and optimize it anyway. And, as Salem said, it doesn't work if the two variables refer to the same object. So a normal swap should be at least as efficient and more generally useful.

The trick leverages the fact that xoring by the same value twice yields the original value, e.g., 17 ^ 5 ^ 5 == 17. It just does it between two variables. It's also important that it's commutative. Unpacking the combined assignment operators and rearranging slightly makes it clearer:

   a = a ^ b;
   b = a ^ b; // is b = a ^ b ^ b using original values
   a = a ^ b; // is a = a ^ b ^ a using original values