Input: arr[] = {4, 2, 1, 3, 5, 6}, P = 4.
Output: 1 2 3 4 5 6
Explanation: {1, 2, 3, 4, 5, 6} on prefix reversal P = 1 converts to {1, 2, 3, 4, 5, 6}.
{1, 2, 3, 4, 5, 6} on prefix reversal P = 2 converts to {2, 1, 3, 4, 5, 6}.
{2, 1, 3, 4, 5, 6} on prefix reversal P = 3 converts to {3, 1, 2, 4, 5, 6}
{3, 1, 2, 4, 5, 6} on prefix reversal P = 4 converts to {4, 2, 1, 3, 5, 6}
So answer is {1, 2, 3, 4, 5, 6}
Input: arr[] = {10, 9, 8, 3, 5, 6}, P = 3
Output: 9 8 10 3 5 6
Consider the original array as arr[] and the reversed array after the P prefix reversals is rev[].
Now for an element in index i (0 based indexing):
- This element's position is not affected for the first i moves (As it is the (i+1)th element of the array arr[]).
- So its position is affected (P-i) times in total.
- Now at the first move [i.e. the (i+1)th move ]in which it participates it becomes the first element of the modified array i.e. its index becomes 0. So movement towards left is (i - 0) = i and now it is the first element of the array.
- In the next move it becomes the last element of the (i+2) sized prefix and its index becomes (i+1) having a shift of (i+1) towards right.
- This shift keeps on happening for each alternate steps as it goes on becoming the 2nd element of prefix, then 2nd last of prefix and so on.
So from this it can be clearly seen that an element at ith index moves floor((P-i)/2) times towards right and ceil((P-i)/2) towards left as it starts alternating position with a left shift operation. Say floor((P-i)/2) = x and ceil((P-i)/2) = y
- If (P-i) = even, x = y
- If (P-i) = odd, y = x + 1
So the final position of an element at ith index of arr[] in the array rev[] can be calculated as: pos = i + [x*(i+1) - y*i]
- If (P-i) = even: pos = i + [x*i + x - x*i] = i+x
- If (P-i) = odd: pos = i + [x*i + x - (x + 1)*i] = x
Note: Only the indices in range [0, P-1] is obtained by this formula, the other elements remain as it is.
Below is the implementation of the above approach.