# Maximum difference between groups of size two

Given an array of even number of elements, form groups of 2 using these array elements such that the difference between the group with highest sum and the one with lowest sum is maximum.

Note: An element can be a part of one group only and it has to be a part of at least 1 group.

Examples:

```Input : arr[] = {1, 4, 9, 6}
Output : 10
Groups formed will be (1, 4) and (6, 9),
the difference between highest sum group
(6, 9) i.e 15 and lowest sum group (1, 4)
i.e 5 is 10.

Input : arr[] = {6, 7, 1, 11}
Output : 11
Groups formed will be (1, 6) and (7, 11),
the difference between highest sum group
(7, 11) i.e 18 and lowest sum group (1, 6)
i.e 7 is 11.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Simple Approach: We can solve this problem by making all possible combinations and checking each set of combination difference between the group with highest sum and with the lowest sum. A total of n*(n-1)/2 such groups would be formed (nC2).
Time Complexity: O(n^3), because it will take O(n^2) to generate groups and to check against each group n iterations will be needed thus overall it takes O(n^3) time.

Efficient Approach: We can use the greedy approach. Sort the whole array and our result is sum of last two elements minus sum of first two elements.

## C++

 `// CPP program to find minimum difference ` `// between groups of highest and lowest ` `// sums. ` `#include ` `#define ll long long int ` `using` `namespace` `std; ` ` `  `ll CalculateMax(ll arr[], ``int` `n) ` `{ ` `    ``// Sorting the whole array. ` `    ``sort(arr, arr + n); ` `    `  `    ``int` `min_sum = arr[0] + arr[1]; ` `    ``int` `max_sum = arr[n-1] + arr[n-2]; ` ` `  `    ``return` `abs``(max_sum - min_sum); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``ll arr[] = { 6, 7, 1, 11 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ` `    ``cout << CalculateMax(arr, n) << endl; ` `    ``return` `0; ` `} `

## Java

 `// Java program to find minimum difference  ` `// between groups of highest and lowest  ` `// sums.  ` `import` `java.util.Arrays;  ` `import` `java.io.*; ` ` `  `class` `GFG { ` `static` `int`  `CalculateMax(``int`  `arr[], ``int` `n)  ` `{  ` `    ``// Sorting the whole array.  ` `    ``Arrays.sort(arr);  ` `     `  `    ``int` `min_sum = arr[``0``] + arr[``1``];  ` `    ``int` `max_sum = arr[n-``1``] + arr[n-``2``];  ` ` `  `    ``return` `(Math.abs(max_sum - min_sum));  ` `}  ` ` `  `// Driver code ` `     `  `    ``public` `static` `void` `main (String[] args) { ` ` `  `    ``int` `arr[] = { ``6``, ``7``, ``1``, ``11` `};  ` `    ``int` `n = arr.length;  ` `    ``System.out.println (CalculateMax(arr, n));  ` `    ``} ` `} `

## Python3

 `# Python 3 program to find minimum difference  ` `# between groups of highest and lowest  ` `def` `CalculateMax(arr, n): ` ` `  `    ``# Sorting the whole array. ` `    ``arr.sort() ` `    ``min_sum ``=` `arr[``0``] ``+` `arr[``1``] ` `    ``max_sum ``=` `arr[n ``-` `1``] ``+` `arr[n ``-` `2``] ` `    ``return` `abs``(max_sum ``-` `min_sum) ` ` `  `# Driver code ` `arr ``=` `[``6``, ``7``, ``1``, ``11``] ` `n ``=` `len``(arr) ` `print``(CalculateMax(arr, n)) ` ` `  `# This code is contributed ` `# by Shrikant13 `

## C#

 `// C# program to find minimum difference  ` `// between groups of highest and lowest  ` `// sums. ` `using` `System; ` ` `  `public` `class` `GFG{ ` ` `  `static` `int` `CalculateMax(``int` `[]arr, ``int` `n)  ` `{  ` `    ``// Sorting the whole array.  ` `    ``Array.Sort(arr);  ` `     `  `    ``int` `min_sum = arr[0] + arr[1];  ` `    ``int` `max_sum = arr[n-1] + arr[n-2];  ` ` `  `    ``return` `(Math.Abs(max_sum - min_sum));  ` `}  ` ` `  `// Driver code ` `     `  `    ``static` `public` `void` `Main (){ ` `    ``int` `[]arr = { 6, 7, 1, 11 };  ` `    ``int` `n = arr.Length;  ` `    ``Console.WriteLine(CalculateMax(arr, n));  ` `    ``} ` `//This code is contributed by Sachin.     ` `} `

## PHP

 ` `

Output:

```11
```

Time Complexity: O (n * log n)

Further Optimization :
Instead of sorting, we can find maximum two and minimum two in linear time and reduce time complexity to O(n).

My Personal Notes arrow_drop_up