Related Articles

Related Articles

Rearrange two given arrays to maximize sum of same indexed elements
  • Last Updated : 07 Nov, 2020

Given two arrays A[] and B[] of size N, the task is to find the maximum possible sum of abs(A[i] – B[i]) by rearranging the array elements.

Examples:

Input: A[] = {1, 2, 3, 4, 5}, B[] = {1, 2, 3, 4, 5}
Output: 12
Explanation: 
One of the possible rearrangements of A[] is {5, 4, 3, 2, 1}. 
One of the possible rearrangements of B[] is {1, 2, 3, 4, 4}. 
Therefore, the sum of all possible values of abs(A[i] – B[i]) = { abs(5 – 1) + abs(4 – 2) + abs(3 – 3) + abs(2 – 4) + abs(1 – 5) } = 12 

Input: A[] = {1, 2, 2, 4, 5}, B[] = {5, 5, 5, 6, 6}
Output: 13
Explanation: 
One of the possible rearrangements of A[] is {5, 4, 2, 2, 1}. 
One of the possible rearrangements of B[] is {5, 5, 5, 6, 6}. 
Therefore, the sum of all possible values of abs(A[i] – B[i]) = { abs(5 – 5) + abs(4 – 5) + abs(2 – 5) + abs(2 – 6) + abs(1 – 6) } = 13 
 

Approach: Follow the steps below to solve the problem:



Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the maximum possible sum
// by rearranging the given array elements
int MaxRearrngeSum(int A[], int B[], int N)
{
     
    // Sort the array A[]
    // in ascending order
    sort(A, A + N);
     
     
    // Sort the array B[]
    // in descending order
    sort(B, B + N,
            greater<int>());
     
     
    // Stores maximum possible sum
    // by rearranging array elements        
    int maxSum = 0;
     
     
    // Traverse both the arrays
    for (int i = 0; i < N; i++) {
         
         
        // Update maxSum
        maxSum += abs(A[i] - B[i]);
    }
     
    return maxSum;
 
}
 
// Driver Code
int main()
 
{
 
    int A[] = { 1, 2, 2, 4, 5 };
    int B[] = { 5, 5, 5, 6, 6 };
 
    int N = sizeof(A) / sizeof(A[0]);
 
    cout<< MaxRearrngeSum(A, B, N);
 
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement
// the above approach
import java.lang.Math;
import java.util.Arrays;
import java.util.Collections;
 
class GFG{
     
// Function to find the maximum possible sum
// by rearranging the given array elements
static int MaxRearrngeSum(Integer A[],
                          Integer B[],
                          int N)
{
     
    // Sort the array A[]
    // in ascending order
    Arrays.sort(A);
     
    // Sort the array B[]
    // in descending order
    Arrays.sort(B, Collections.reverseOrder());
     
    // Stores maximum possible sum
    // by rearranging array elements         
    int maxSum = 0;
     
    // Traverse both the arrays
    for(int i = 0; i < N; i++)
    {
        // Update maxSum
        maxSum += Math.abs(A[i] - B[i]);
    }
    return maxSum;
}
   
// Driver code
public static void main (String[] args)
{
    Integer A[] = { 1, 2, 2, 4, 5 };
    Integer B[] = { 5, 5, 5, 6, 6 };
 
    int N = A.length;
   
    System.out.println(MaxRearrngeSum(A, B, N));
}
}
 
// This code is contributed by ujjwalgoel1103

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to implement
# the above approach
 
# Function to find the maximum possible sum
# by rearranging the given array elements
def MaxRearrngeSum(A, B, N):
     
    # Sort the array A[]
    # in ascending order
    A.sort()
 
    # Sort the array B[]
    # in descending order
    B.sort(reverse = True)
 
    # Stores maximum possible sum
    # by rearranging array elements
    maxSum = 0
 
    # Traverse both the arrays
    for i in range(N):
 
        # Update maxSum
        maxSum += abs(A[i] - B[i])
 
    return maxSum
 
# Driver Code
if __name__ == "__main__":
 
    A = [ 1, 2, 2, 4, 5 ]
    B = [ 5, 5, 5, 6, 6 ]
 
    N = len(A)
 
    print(MaxRearrngeSum(A, B, N))
 
# This code is contributed by chitranayal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement
// the above approach
using System;
 
class GFG{
     
// Function to find the maximum possible sum
// by rearranging the given array elements
static int MaxRearrngeSum(int []A, int []B, int N)
{
     
    // Sort the array A[]
    // in ascending order
    Array.Sort(A);
     
    // Sort the array B[]
    // in descending order
    Array.Sort(B);
    Array.Reverse(B);
     
    // Stores maximum possible sum
    // by rearranging array elements         
    int maxSum = 0;
     
    // Traverse both the arrays
    for(int i = 0; i < N; i++)
    {
         
        // Update maxSum
        maxSum += Math.Abs(A[i] - B[i]);
    }
    return maxSum;
}
   
// Driver code
public static void Main()
{
    int []A = { 1, 2, 2, 4, 5 };
    int []B = { 5, 5, 5, 6, 6 };
 
    int N = A.Length;
   
    Console.WriteLine(MaxRearrngeSum(A, B, N));
}
}
 
// This code is contributed by ipg2016107

chevron_right


Output: 

13














 

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up
Recommended Articles
Page :