Rearrange Even and Odd Index Elements in K Operations

Given an array arr[] of size N (N is even) and a positive integer K, the task is to apply an operation to the array arr[] for K times. Applying the operation once will shift all the even indexed numbers to the beginning and all the odd indexed numbers to the end, maintaining their relative order.

Examples:

Input: K = 1, N = 6, arr[] = {1, 2, 3, 4, 5, 6}
Output: {1, 3, 5, 2, 4, 6}
Explanation: Applying the operation once would be equal to arr'[] = {arr[0], arr[2], arr[4], arr[1], arr[3], arr[5]} = {1, 3, 5, 2, 4, 6}

Input: K = 2, N = 10, arr[]= {20, 123, 23, 21, 33, 13, 55, 65, 90, 100}
Output: {20, 33, 90, 21, 65, 23, 55, 123, 13, 100}
Explanation: Applying the operation once would be equal to arr'[] = {arr[0], arr[2], arr[4], arr[6], arr[8], arr[1], arr[3], arr[5], arr[7], arr[9]} = {20, 23, 33, 55, 90, 123, 21, 13, 65, 100} and applying it again would be equal to arr''[] = {20, 33, 90, 21, 65, 23, 55, 123, 13, 100}

Approach: The problem can be solved using the following approach:

If we observe carefully, shifting all the even indexed numbers to the beginning and odd indexed integers to the end is same as applying a permutation P to S where P = [0, 2, 4, 6, ... N-2, 1, 3, 5, ...N-1]. So we can get our answer by simply applying the permutation P to S for K times. This can be simply done in log₂(K) time using Binary Exponentiation.

Step-by-step approach:

• Declare a permutation P = [0, 2, 4, 6, ... N-2, 1, 3, 5, ...N-1].
• Initialise a function apply(S, P) which applies the permutation P to the array arr[], and stores it back to arr[].
• Use Binary exponentiation to reduce the number of operations to log₂K time.
  • If K is odd, apply permutation P to array arr[], apply(arr, P)
  • Then apply permutation P to itself, apply(P, P)
  • Reduce K to half
  • Keep doing the above steps till K is greater than 0
• Return the answer as arr[].

Below is the implementation of the above approach:

#include <bits/stdc++.h>
#define ll long long int

using namespace std;

// function to apply a permutation P to a Sequence arr
void apply(vector<ll>& arr, vector<ll>& P)
{
    vector<ll> temp(arr.size());
    for (int i = 1; i < arr.size(); i++) {
        temp[i] = arr[P[i]];
    }
    for (int i = 1; i < arr.size(); i++)
        arr[i] = temp[i];
}

// Function to perform the operation to Sequence arr
// K number of times
void solve(ll N, ll K, vector<ll>& arr)
{
    // vector to store the permutation
    vector<ll> P;
    for (int i = 0; i < N; i += 2)
        P.push_back(i);
    for (int i = 1; i < N; i += 2)
        P.push_back(i);
    // binary exponentiation
    while (K) {
        if (K & 1)
            apply(arr, P);
        apply(P, P);
        K >>= 1;
    }
    // Printing the final sequence
    for (int i = 0; i < N; i++)
        cout << arr[i] << " ";
    cout << "\n";
}

int main()
{

    ll N = 10, K = 2;
    vector<ll> arr
        = { 20, 123, 23, 21, 33, 13, 55, 65, 90, 100 };

    solve(N, K, arr);
    // your code goes here
    return 0;
}

import java.util.ArrayList;

public class Main {
    // Function to apply permutation P to the array arr
    static void apply(ArrayList<Long> arr, ArrayList<Long> P) {
        ArrayList<Long> temp = new ArrayList<>(arr.size());
        // Create a temporary array to store the permuted values
        for (int i = 0; i < arr.size(); i++) {
            temp.add(arr.get((int) (long) P.get(i)));
        }
        // Copy values from temp back to arr
        for (int i = 0; i < arr.size(); i++) {
            arr.set(i, temp.get(i));
        }
    }

    // Function to solve the problem
    static void solve(long N, long K, ArrayList<Long> arr) {
        // Generate permutation P for swapping even and odd indices
        ArrayList<Long> P = new ArrayList<>();
        for (int i = 0; i < N; i += 2) {
            P.add((long) i);
        }
        for (int i = 1; i < N; i += 2) {
            P.add((long) i);
        }

        // Apply the permutation P K times
        while (K > 0) {
            if ((K & 1) == 1) {
                apply(arr, P);
            }
            apply(P, P);
            K >>= 1; // Right shift K to divide by 2
        }

        // Print the final array
        for (int i = 0; i < N; i++) {
            System.out.print(arr.get(i) + " ");
        }
        System.out.println();
    }

    // Main function
    public static void main(String[] args) {
        // Example usage
        long N = 10, K = 2;
        ArrayList<Long> arr = new ArrayList<>();
        arr.add(20L);
        arr.add(123L);
        arr.add(23L);
        arr.add(21L);
        arr.add(33L);
        arr.add(13L);
        arr.add(55L);
        arr.add(65L);
        arr.add(90L);
        arr.add(100L);

        solve(N, K, arr);
    }
}

def apply(arr, P):
    # Function to apply permutation P to the sequence arr
    temp = [0] * len(arr)
    for i in range(1, len(arr)):
        temp[i] = arr[P[i]]
    for i in range(1, len(arr)):
        arr[i] = temp[i]

def solve(N, K, arr):
    # Function to perform the operation on sequence arr K times
    
    # Vector to store the permutation P
    P = []
    for i in range(0, N, 2):
        P.append(i)
    for i in range(1, N, 2):
        P.append(i)

    # Binary exponentiation
    while K:
        if K & 1:
            # If the least significant bit of K is set, apply permutation to arr
            apply(arr, P)
        # Square the permutation P
        apply(P, P)
        # Right shift K to divide it by 2
        K >>= 1

    # Printing the final sequence
    print(*arr)

# Driver code
if __name__ == "__main__":
    N = 10
    K = 2
    arr = [20, 123, 23, 21, 33, 13, 55, 65, 90, 100]

    # Function call
    solve(N, K, arr)

using System;
using System.Collections.Generic;

public class Program
{
    // function to apply a permutation P to a Sequence arr
    private static void Apply(List<long> arr, List<long> P)
    {
        List<long> temp = new List<long>(arr.Count);
        for (int i = 0; i < arr.Count; i++)
        {
            temp.Add(arr[(int)P[i]]);
        }
        for (int i = 0; i < arr.Count; i++)
        {
            arr[i] = temp[i];
        }
    }

    // Function to perform the operation to Sequence arr
    // K number of times
    private static void Solve(long N, long K, List<long> arr)
    {
        // vector to store the permutation
        List<long> P = new List<long>();
        for (int i = 0; i < N; i += 2)
        {
            P.Add(i);
        }
        for (int i = 1; i < N; i += 2)
        {
            P.Add(i);
        }
        // binary exponentiation
        while (K > 0)
        {
            if ((K & 1) == 1)
            {
                Apply(arr, P);
            }
            Apply(P, P);
            K >>= 1;
        }
        // Printing the final sequence
        foreach (long num in arr)
        {
            Console.Write(num + " ");
        }
        Console.WriteLine();
    }

    public static void Main(string[] args)
    {
        long N = 10, K = 2;
        List<long> arr = new List<long> { 20, 123, 23, 21, 33, 13, 55, 65, 90, 100 };

        Solve(N, K, arr);
    }
}
//This code is contributed by adarsh

function apply(arr, P) {
    // Function to apply permutation P to the sequence arr
    const temp = Array(arr.length).fill(0);
    for (let i = 1; i < arr.length; i++) {
        temp[i] = arr[P[i]];
    }
    for (let i = 1; i < arr.length; i++) {
        arr[i] = temp[i];
    }
}

function solve(N, K, arr) {
    // Function to perform the operation on sequence arr K times

    // Vector to store the permutation P
    const P = [];
    for (let i = 0; i < N; i += 2) {
        P.push(i);
    }
    for (let i = 1; i < N; i += 2) {
        P.push(i);
    }

    // Binary exponentiation
    while (K) {
        if (K & 1) {
            // If the least significant bit of K is set, 
            // apply permutation to arr
            apply(arr, P);
        }
        // Square the permutation P
        apply(P, P);
        // Right shift K to divide it by 2
        K >>= 1;
    }

    // Printing the final sequence
    console.log(...arr);
}

// Driver code
const N = 10;
const K = 2;
const arr = [20, 123, 23, 21, 33, 13, 55, 65, 90, 100];

// Function call
solve(N, K, arr);

20 33 90 21 65 23 55 123 13 100 

Time Complexity: O(N * log₂K) where N is the length of the input sequence S and K is the number of operations to be performed
Auxiliary Space: O(N) to store the permutation