Maximum difference between group of k-elements and rest of the array.
Last Updated :
19 Sep, 2023
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++
#include<bits/stdc++.h>
using namespace std;
long long int arraySum( int arr[], int n)
{
long long int sum = 0;
for ( int i=0; i<n; i++)
sum = sum + arr[i];
return sum;
}
long long int maxDiff ( int arr[], int n, int k)
{
sort(arr, arr+n);
long long int arraysum = arraySum(arr, n);
long long int diff1 = abs (arraysum - 2*arraySum(arr, k));
reverse(arr, arr+n);
long long int diff2 = abs (arraysum - 2*arraySum(arr, k));
return (max(diff1,diff2));
}
int main()
{
int arr[] = {1, 7, 4, 8, -1, 5, 2, 1};
int n = sizeof (arr)/ sizeof (arr[0]);
int k = 3;
cout << "Maximum Difference = " << maxDiff(arr,n,k);
return 0;
}
|
Java
import java.util.Arrays;
public class GFG {
static long arraySum( int arr[], int n)
{
long sum = 0 ;
for ( int i = 0 ; i < n; i++)
sum = sum + arr[i];
return sum;
}
static long maxDiff ( int arr[], int n, int k)
{
Arrays.sort(arr);
long arraysum = arraySum(arr, n);
long diff1 = Math.abs(arraysum -
2 * arraySum(arr, k));
int end = arr.length - 1 ;
int start = 0 ;
while (start < end)
{
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
long diff2 = Math.abs(arraysum -
2 * arraySum(arr, k));
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));
}
}
|
Python3
def arraySum(arr, n):
sum = 0
for i in range (n):
sum = sum + arr[i]
return sum
def maxDiff (arr, n, k):
arr.sort()
arraysum = arraySum(arr, n)
diff1 = abs (arraysum - 2 * arraySum(arr, k))
arr.reverse()
diff2 = abs (arraysum - 2 * arraySum(arr, k))
return ( max (diff1, diff2))
if __name__ = = "__main__" :
arr = [ 1 , 7 , 4 , 8 , - 1 , 5 , 2 , 1 ]
n = len (arr)
k = 3
print ( "Maximum Difference =" ,
maxDiff(arr, n, k))
|
C#
using System;
public class GFG {
static long arraySum( int []arr, int n)
{
long sum = 0;
for ( int i = 0; i < n; i++)
sum = sum + arr[i];
return sum;
}
static long maxDiff ( int []arr, int n, int k)
{
Array.Sort(arr);
long arraysum = arraySum(arr, n);
long diff1 = Math.Abs(arraysum -
2 * arraySum(arr, k));
Array.Reverse(arr);
long diff2 = Math.Abs(arraysum -
2 * arraySum(arr, k));
return (Math.Max(diff1, diff2));
}
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));
}
}
|
PHP
<?php
function arraySum( $arr , $n )
{
$sum = 0;
for ( $i = 0; $i < $n ; $i ++)
$sum = $sum + $arr [ $i ];
return $sum ;
}
function maxDiff ( $arr , $n , $k )
{
sort( $arr );
$arraysum = arraySum( $arr , $n );
$diff1 = abs ( $arraysum - 2 *
arraySum( $arr , $k ));
array_reverse ( $arr );
$diff2 = abs ( $arraysum - 2 *
arraySum( $arr , $k ));
return (max( $diff1 , $diff2 ));
}
$arr = array (1, 7, 4, 8, -1, 5, 2, 1);
$n = count ( $arr );
$k = 3;
echo "Maximum Difference = " ,
maxDiff( $arr , $n , $k );
?>
|
Javascript
<script>
function arraySum(arr, n)
{
var sum = 0;
for ( var i=0; i<n; i++)
sum = sum + arr[i];
return sum;
}
function maxDiff (arr, n, k)
{
arr.sort((a,b)=>a-b);
var arraysum = arraySum(arr, n);
var diff1 = Math.abs(arraysum - 2*arraySum(arr, k));
arr.reverse();
var diff2 = Math.abs(arraysum - 2*arraySum(arr, k));
return (Math.max(diff1,diff2));
}
var arr = [1, 7, 4, 8, -1, 5, 2, 1];
var n = arr.length;
var k = 3;
document.write( "Maximum Difference = " + maxDiff(arr,n,k));
</script>
|
Output
Maximum Difference = 25
Time Complexity: O(n log n)
Auxiliary Space: O(1)
Optimizations to above solution :
- We can avoid reversing the array and find sum k elements from end using a different loop.
- We can also find sum of k largest and smallest elements more efficiently using methods discussed in below posts.
K’th Smallest/Largest Element in Unsorted Array | Set 2 (Expected Linear Time)
K’th Smallest/Largest Element in Unsorted Array | Set 3 (Worst Case Linear Time)
Share your thoughts in the comments
Please Login to comment...