# Maximum difference between group of k-elements and rest of the array.

• Difficulty Level : Easy
• Last Updated : 19 Jul, 2022

You are given an array of n elements. You have to divide the given array into two group such that one group consists exactly k elements and second group consists rest of elements. Your result must be maximum possible difference of sum of elements of these two group.

Examples:

```Input : arr[n] = {1, 5, 2, 6, 3}  , k = 2
Output : Maximum Difference = 11
Explanation : group1 = 1+2 , group2 = 3+5+6
Maximum Difference = 14 - 3 = 11

Input : arr[n] = {1, -1, 3, -2, -3} , k = 2
Output : Maximum Difference = 10
Explanation : group1 = -1-2-3 , group2 = 1+3
Maximum Difference = 4 - (-6) = 10```

For finding the maximum group difference we have two possibilities. For the first case k-smallest elements belongs to one group and rest elements to other group. For second case k-largest elements belongs to one group and rest elements to other group.
So, first of all sort the whole array and find group difference for both cases explained as above and then finally find the maximum difference among them.

Algorithm :

```    sort the arrayfind sum of whole array
case-1    -> find sum of first k-smallest elements
-> differece1 = abs( arraySum - 2*k_Smallest)
case-2    -> find sum of first k-largest elements
-> differece2 = abs( arraySum - 2*k_largest)
print max(difference1, difference2)```

Implementation:

## C++

 `// CPP to find maximum group difference` `#include` `using` `namespace` `std;`   `// utility function for array sum` `long` `long` `int` `arraySum(``int` `arr[], ``int` `n)` `{` `    ``long` `long` `int` `sum = 0;` `    ``for` `(``int` `i=0; i

## Java

 `// java to find maximum group difference` `import` `java.util.Arrays;`   `public` `class` `GFG {` `    `  `    ``// utility function for array sum` `    ``static` `long` `arraySum(``int` `arr[], ``int` `n)` `    ``{` `        ``long` `sum = ``0``;` `        ``for` `(``int` `i = ``0``; i < n; i++)` `            ``sum = sum + arr[i];` `            `  `        ``return` `sum;` `    ``}` `    `  `    ``// function for finding maximum group` `    ``// difference of array` `    ``static` `long` `maxDiff (``int` `arr[], ``int` `n, ``int` `k)` `    ``{` `        `  `        ``// sort the array` `        ``Arrays.sort(arr);` `    `  `        ``// find array sum` `        ``long` `arraysum = arraySum(arr, n);` `        `  `        ``// difference for k-smallest` `        ``// diff1 = (arraysum-k_smallest)-k_smallest` `        ``long` `diff1 = Math.abs(arraysum -` `                            ``2` `* arraySum(arr, k));` `        `  `        ``// reverse array for finding sum of` `        ``// 1st k-largest` `        ``int` `end = arr.length - ``1``;` `        ``int` `start = ``0``;` `        ``while` `(start < end)` `        ``{` `            ``int` `temp = arr[start]; ` `            ``arr[start] = arr[end];` `            ``arr[end] = temp;` `            ``start++;` `            ``end--;` `        ``} `   `        ``// difference for k-largest` `        ``// diff2 = (arraysum-k_largest)-k_largest` `        ``long` `diff2 = Math.abs(arraysum -` `                            ``2` `* arraySum(arr, k));` `        `  `        ``// return maximum difference value` `        ``return``(Math.max(diff1, diff2));` `    `  `    ``}` `    `  `    ``public` `static` `void` `main(String args[]) {` `        ``int` `arr[] = {``1``, ``7``, ``4``, ``8``, -``1``, ``5``, ``2``, ``1``};` `        ``int` `n = arr.length;` `        ``int` `k = ``3``;` `        `  `        ``System.out.println(``"Maximum Difference = "` `                            ``+ maxDiff(arr, n, k));`   `    ``}` `}`   `// This code is contributed by Sam007.`

## Python3

 `# Python3 to find maximum group difference`   `# utility function for array sum` `def` `arraySum(arr, n):`   `    ``sum` `=` `0` `    ``for` `i ``in` `range``(n):` `        ``sum` `=` `sum` `+` `arr[i]` `    ``return` `sum`   `# function for finding` `# maximum group difference of array` `def` `maxDiff (arr, n, k):` `    `  `    ``# sort the array` `    ``arr.sort()`   `    ``# find array sum` `    ``arraysum ``=` `arraySum(arr, n)` `    `  `    ``# difference for k-smallest` `    ``# diff1 = (arraysum-k_smallest)-k_smallest` `    ``diff1 ``=` `abs``(arraysum ``-` `2` `*` `arraySum(arr, k))` `    `  `    ``# reverse array for finding sum ` `    ``# 0f 1st k-largest` `    ``arr.reverse()` `    `  `    ``# difference for k-largest` `    ``# diff2 = (arraysum-k_largest)-k_largest` `    ``diff2 ``=` `abs``(arraysum ``-` `2` `*` `arraySum(arr, k))` `    `  `    ``# return maximum difference value` `    ``return``(``max``(diff1, diff2))`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``1``, ``7``, ``4``, ``8``, ``-``1``, ``5``, ``2``, ``1``]` `    ``n ``=` `len``(arr)` `    ``k ``=` `3` `    ``print` `(``"Maximum Difference ="``, ` `               ``maxDiff(arr, n, k))` `    `  `# This code is contributed by ita_c`

## C#

 `// C# to find maximum group difference` `using` `System;`   `public` `class` `GFG {` `    `  `    ``// utility function for array sum` `    ``static` `long` `arraySum(``int` `[]arr, ``int` `n)` `    ``{` `        ``long` `sum = 0;` `        ``for` `(``int` `i = 0; i < n; i++)` `            ``sum = sum + arr[i];` `            `  `        ``return` `sum;` `    ``}` `    `  `    ``// function for finding maximum group` `    ``// difference of array` `    ``static` `long` `maxDiff (``int` `[]arr, ``int` `n, ``int` `k)` `    ``{` `        `  `        ``// sort the array` `        ``Array.Sort(arr);` `    `  `        ``// find array sum` `        ``long` `arraysum = arraySum(arr, n);` `        `  `        ``// difference for k-smallest` `        ``// diff1 = (arraysum-k_smallest)-k_smallest` `        ``long` `diff1 = Math.Abs(arraysum -` `                             ``2 * arraySum(arr, k));` `        `  `        ``// reverse array for finding sum of` `        ``// 1st k-largest` `        ``Array.Reverse(arr);` `        `  `        ``// difference for k-largest` `        ``// diff2 = (arraysum-k_largest)-k_largest` `        ``long` `diff2 = Math.Abs(arraysum -` `                            ``2 * arraySum(arr, k));` `        `  `        ``// return maximum difference value` `        ``return``(Math.Max(diff1, diff2));` `    `  `    ``}` `    `  `    ``// Driver program` `    ``static` `public` `void` `Main ()` `    ``{` `        ``int` `[]arr = {1, 7, 4, 8, -1, 5, 2, 1};` `        ``int` `n = arr.Length;` `        ``int` `k = 3;` `        `  `        ``Console.WriteLine(``"Maximum Difference = "` `                           ``+ maxDiff(arr, n, k));` `    ``}` `}`   `// This Code is contributed by vt_m.`

## PHP

 ``

## Javascript

 ``

Output

`Maximum Difference = 25`

Time Complexity: O(n log n)
Auxiliary Space: O(1)

Optimizations to above solution :

1. We can avoid reversing the array and find sum k elements from end using a different loop.
2. We can also find sum of k largest and smallest elements more efficiently using methods discussed in below posts.

This article is contributed by Shivam Pradhan (anuj_charm). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up
Recommended Articles
Page :