Pair formation such that maximum pair sum is minimized

Given an array of size 2 * N integers. Divide the array into N pairs, such that the maximum pair sum is minimized. In other words, the optimal division of array into N pairs should result into a maximum pair sum which is minimum of other maximum pair sum of all possibilities.

Examples:

Input : N = 2 , arr[] = { 5, 8, 3, 9 } 
Output : (3, 9) (5, 8) 

Explanation:
Possible pairs are : 

1. (8, 9) (3, 5) Maximum Sum of a Pair = 17 
2. (5, 9) (3, 8) Maximum Sum of a Pair = 14 
3. (3, 9) (5, 8) Maximum Sum of a Pair = 13 

Thus, in case 3, the maximum pair sum is minimum of all the other cases. Hence, the answer is(3, 9) (5, 8).

Input : N = 2, arr[] = { 9, 6, 5, 1 } 
Output : (1, 9) (5, 6) 

Approach: The idea is to first sort the given array and then iterate over the loop to form pairs (i, j) where i would start from 0 and j would start from end of array correspondingly. Increment i and Decrement j to form the next pair and so on.

Below is the implementation of above approach. 

C++

// CPP Program to divide the array into
// N pairs such that maximum pair is minimized
#include <bits/stdc++.h>

using namespace std;

void findOptimalPairs(int arr[], int N)
{
    sort(arr, arr + N);

    // After Sorting Maintain two variables i and j
    // pointing to start and end of array Such that
    // smallest element of array pairs with largest
    // element
    for (int i = 0, j = N - 1; i <= j; i++, j--)
        cout << "(" << arr[i] << ", " << arr[j] << ")" << " ";
}

// Driver Code
int main()
{
    int arr[] = { 9, 6, 5, 1 };
    int N = sizeof(arr) / sizeof(arr[0]);

    findOptimalPairs(arr, N);
    return 0;
}

Java

// Java Program to divide the array into
// N pairs such that maximum pair is minimized
import java.io.*;
import java.util.Arrays;

class GFG {

static void findOptimalPairs(int arr[], int N)
{
    Arrays.sort(arr);

    // After Sorting Maintain two variables i and j
    // pointing to start and end of array Such that
    // smallest element of array pairs with largest
    // element
    for (int i = 0, j = N - 1; i <= j; i++, j--)
        System.out.print( "(" + arr[i] + ", " + arr[j] + ")" + " ");
}

    // Driver Code
    public static void main (String[] args)
    {
        int arr[] = {9, 6, 5, 1};
        int N = arr.length;

        findOptimalPairs(arr, N);
    }
}

// This code is contributed by anuj_67.

Python3

# Python 3 Program to divide the array into
# N pairs such that maximum pair is minimized

def findOptimalPairs(arr, N):
    arr.sort(reverse = False)

    # After Sorting Maintain two variables
    # i and j pointing to start and end of
    # array Such that smallest element of
    # array pairs with largest element
    i = 0
    j = N - 1
    while(i <= j):
        print("(", arr[i], ",",
                   arr[j], ")", end = " ")
        i += 1
        j -= 1

# Driver Code
if __name__ == '__main__':
    arr = [9, 6, 5, 1]
    N = len(arr)

    findOptimalPairs(arr, N)

# This code is contributed by
# Sahil_Shelangia

C#

// C# Program to divide the array into
// N pairs such that maximum pair is minimized

using System;

public class GFG{
    static void findOptimalPairs(int []arr, int N)
{
    Array.Sort(arr);

    // After Sorting Maintain two variables i and j
    // pointing to start and end of array Such that
    // smallest element of array pairs with largest
    // element
    for (int i = 0, j = N - 1; i <= j; i++, j--)
        Console.Write( "(" + arr[i] + ", " + arr[j] + ")" + " ");
}

    // Driver Code
    static public void Main (){

        int []arr = {9, 6, 5, 1};
        int N = arr.Length;
        findOptimalPairs(arr, N);


// This code is contributed by ajit.

    }
}

PHP

<?php
// PHP Program to divide the array into
// N pairs such that maximum pair is minimized

function findOptimalPairs($arr, $N)
{
    sort($arr);

    // After Sorting Maintain two variables
    // i and j pointing to start and end of
    // array Such that smallest element of
    // array pairs with largest element
    for ($i = 0, $j = $N - 1; $i <= $j; $i++, $j--)
            echo "(", $arr[$i],
                 ", ", $arr[$j], ")", " ";
}

// Driver Code
$arr = array( 9, 6, 5, 1 );
$N = sizeof($arr);

findOptimalPairs($arr, $N);

// This code is contributed by jit_t
?>

Javascript

<script>

/// Javascript Program to divide the array into
// N pairs such that maximum pair is minimized
function findOptimalPairs(arr, N)
{
    arr.sort(function(a,b){ return a-b;});

    // After Sorting Maintain two variables i and j
    // pointing to start and end of array Such that
    // smallest element of array pairs with largest
    // element
    for (var i = 0, j = N - 1; i <= j; i++, j--)
        document.write("(" + arr[i] + ", " + arr[j] + ")" + " ");
}

// Driver Code
var arr = [ 9, 6, 5, 1 ];
var N = arr.length;
findOptimalPairs(arr, N);

</script>

Output

(1, 9) (5, 6) 

Complexity Analysis:

• Time Complexity: O(n*log n) where n is the size of the array.
• Auxiliary Space: O(1)