Maximize the Median of Array formed from adjacent maximum of a rearrangement

You are given X[] of length 2*N, Where N will always be odd, the task is to construct an array Y[] of length N from a rearrangement of X[] such that Y[]'s element is equal to max(X_i, X_i+1) and i is always an even index (0 based indexing), and the median of the new array is maximum possible.

Examples: 

Input: N = 1, X[] = {1, 2} 
Output: X[] = {2, 1}, Median = 2
Explanation: Y[] =  { max(X[1],  X[2]) }, Y[] = {2}.
Median of Y[] = 2, 2 is the maximum possible value of median that can achieve by arrange elements of X[].

Input: N = 3,   X[] = {1, 2, 3, 4, 5, 6}
Output: X[] = {3, 1, 2, 5, 6, 4}, Median = 5
Explanation: Y[] = { max(3, 1), max(2, 5), max(6, 4) }, Y[] = {3, 5, 6}.
Median of Y[] = 5,   5 is the maximum possible value of median that can achieve by arrange elements of X[].

Approach: Implement the idea below to solve the problem:

Sort X[], put its left half part on even indices in arrangement and right half elements at odd indices of arrangement. For value of maximum value of median can be get by printing middle element of right half X[] after performing sorting.

Illustration of approach:

Consider N = 3,  X[] = {1, 2, 3, 4, 5, 6}

After sorting X[] will be: {1, 2, 3, 4, 5, 6}. Let the new Arrangement: {A₁, A₂,  A₃, A₄, A₅, A₆}

• Put left half X[] = {1, 2, 3}  on odd indices of new Arrangement, Then Arrangement: {1, A_2, 2, A_4, 3, A₆}
• Put right half X[] = {4, 5, 6}  on even indices of new Arrangement. Then, Arrangement: {1, 4, 2, 5, 3, 6}

Now, It can be verified that Y[] will be = {4, 5, 6}, 5 is maximum possible median and value 5 is at middle of right half of X[] = {4, 5, 6} 

Follow the below steps to implement the idea:

• Sort X[].
• Make a new Array of same length.
• Put left half of X[]  on odd indices of new Arrangement.
• Put right half of X[]  on even indices of new Arrangement.
• Print the arrangement of new Array.
• Return the middle element of the right half of X[] for the maximum possible value.

Below is the implementation of the approach.

// C++ code to implement the approach
#include <bits/stdc++.h>
using namespace std;

// Function to find the maximum median
static int maxValue(int X[], int n)
{
    // Sorting X[] by in-built sort
    // function of Arrays class
    sort(X, X + 2 * n);

    // Start point of right half X[]
    int start = (2 * n) / 2;

    // Loop for printing arrangement
    for (int i = 1; i <= n; i++) {
        cout << X[i - 1] << " " << X[start] << " ";
        start++;
    }

    cout << "\n";

    // Returning maximum possible
    // median value
    return (X[(start + ((2 * n) - 1)) / 2]);
}

// Driver Code
int main()
{
    int N = 5;
    int X[] = { 3, 5, 7, 1, 3, 5, 9, 0, 1, 3 };

    // Function call
    cout << maxValue(X, N);
    return 0;
}

// This code is contributed by Rohit Pradhan

// Java code to implement the approach

import java.io.*;
import java.lang.*;
import java.util.*;

class GFG {

    // Driver function
    public static void main(String[] args)
    {
        int N = 5;
        int[] X = { 3, 5, 7, 1, 3, 5, 9, 0, 1, 3 };

        // Function call
        System.out.println(maxValue(X, N));
    }

    // Function to find the maximum median
    static int maxValue(int X[], int n)
    {
        // Sorting X[] by in-built sort
        // function of Arrays class
        Arrays.sort(X);

        // Start point of right half X[]
        int start = (2 * n) / 2;

        // Loop for printing arrangement
        for (int i = 1; i <= n; i++) {
            System.out.print(X[i - 1] + " " + X[start]
                             + " ");
            start++;
        }

        System.out.println();

        // Returning maximum possible
        // median value
        return (X[(start + ((2 * n) - 1)) / 2]);
    }
}

# Python3 code to implement the approach

# Function to find the maximum median
def maxValue(X, n) :

    # Sorting X[] by in-built sort
    # function of Arrays class
    X.sort()

    # Start point of right half X[]
    start = (2 * n) // 2;

    # Loop for printing arrangement
    for i in range(1, n + 1) :
        print(X[i - 1], " ", X[start], " ", end ="");
        start += 1;

    print()

    # Returning maximum possible
    # median value
    return (X[(start + ((2 * n) - 1)) // 2]);

# Driver Code
if __name__ ==  "__main__" :

    N = 5;
    X = [ 3, 5, 7, 1, 3, 5, 9, 0, 1, 3 ];

    # Function call
    print(maxValue(X, N));

    # This code is contributed by AnkThon

// C# code for the above approach

using System;
using System.Collections;

public class GFG {

    static public void Main()
    {

        // Code
        int N = 5;
        int[] X = { 3, 5, 7, 1, 3, 5, 9, 0, 1, 3 };

        // Function call
        Console.WriteLine(maxValue(X, N));
    }

    // Function to find the maximum median
    static int maxValue(int[] X, int n)
    {
        // Sorting X[] by in-built sort
        // function of Arrays class
        Array.Sort(X);

        // Start point of right half X[]
        int start = (2 * n) / 2;

        // Loop for printing arrangement
        for (int i = 1; i <= n; i++) {
            Console.Write(X[i - 1] + " " + X[start] + " ");
            start++;
        }

        Console.WriteLine();

        // Returning maximum possible
        // median value
        return (X[(start + ((2 * n) - 1)) / 2]);
    }
}

// This code is contributed by lokeshmvs21.

// JavaScript code to implement the approach

// Function to find the maximum median
function maxValue(X,  n)
{
    // Sorting X[] by in-built sort
    // function of Arrays class
    X.sort()

    // Start point of right half X[]
    let start = (2 * n) / 2;
    let string = "";
    // Loop for printing arrangement
    for (let i = 1; i <= n; i++) {
        string +=  X[i - 1] + " " + X[start] + " ";
        start++;
    }
    console.log(string);

    // Returning maximum possible
    // median value
    let y = Math.floor((start + ((2 * n) - 1)) / 2);
    return (X[y]);
}

// Driver Code

let N = 5;
let X = [ 3, 5, 7, 1, 3, 5, 9, 0, 1, 3 ];

// Function call
console.log(maxValue(X, N));

// This code is contributed by AnkThon

0 3 1 5 1 5 3 7 3 9 
9

Time Complexity: O(N * log(N))
Auxiliary Space: O(1)

Related Articles:

• Introduction to Arrays – Data Structure and Algorithm Tutorials
• Sorting Algorithms