Find original array from given array which is obtained after P prefix reversals | Set-2

Given an array arr[] of size N and an integer P, the task is to find the original array from the array obtained by P prefix reversals where in ith reversal the prefix of size i of the array containing indices in range [0, i-1] was reversed.

Note: P is less than or equal to N

Examples:

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

Approach: The naive approach and two pointer approach is discussed in the Set-1 of this problem.

Mathematical observation based Approach: This approach is based on the mathematical observation shown below.

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.

Follow the steps mentioned below to implement this approach:

• Initialize an array original[] of size N.
• Start iterating in a loop from i = 0 to N to fill the array original[].
• For each i in range [0, P-1] find the position of the ith element of original array in the given array by using the above formula.
• Fill the remaining elements as it is.
• Print the array original[].

Below is the implementation of the above approach.

1 2 3 4 5 6 

Time Complexity: O(N)
Auxiliary Space: O(N)