Given two arrays A[] and B[] of length N. Then your task is to rearrange the elements of both arrays in such a way that the sum (Ai + Bi) for all i (1 <= i <= N) is same. If no such arrangement is possible output -1 instead.
Examples:
Input: N = 3, A[] = {1, 2, 3}, B[] = {1, 2, 3}
Output: A[] = {3, 1, 2}, B[] = {1, 3, 2}
Explanation: Rearranged A[] and B[] are {3, 1, 2} and {1, 3, 2} respectively. Let us see the sum at each index i (1 <= i <= 3):
- 1st index: A1 + B1 = (3 + 1) = 4
- 2nd index: A2 + B2 = (1 + 3) = 4
- 3rd index: A3 + B3 = (2 + 2) = 4
The sum at each index is same . Thus, arrangements are valid and follows the given constraints.
Input: N = 3, A[] = {5, 6, 7}, B[] = {4, 3, 1}
Output: -1
Explanation: It can be verified that no arrangement of elements is possible such that (Ai + Bi) for all pairs.
Approach: To solve the problem, follow the below idea:
The problem can be solved using the HashMap. There are two things to check:
- Possibility of rearrangement
- Final rearrangement
Let us see both of them one by one:
- Possibility of rearrangement:
- As it is mentioned that the sum of (Ai + Bi) over all i for (1 <= i <= N) must be equal. Distributing of a sum over N number of indices is possible only and only if (Sum % N == 0), where Sum is equal to sum of all elements of A[] and B[]. Hence, in this way the possibility of arrangement can be checked.
- Final rearrangement:
- First of all, we need to know the exact average sum let say Avg, so that for each index (Ai + Bi) = Avg.
- As Sum must be distributed over all indices equally, thus Avg will be equal to (Sum/N). Formally, Avg = (Sum/N).
- Now, we need to do pairing between A[]’s and B[]’s element, So that they should provide sum of pair equal to Avg. Consider that any index i, we know one element let say Ai then it must be paired with an element of B[] such that Bi = (Avg – X). So, that sum of both (Ai + Bi) = ((X) + (Avg – X)) gives Avg, which is required sum at that index i. For knowing the presence of such (Avg – X) element in B[], we need to implement a constant check implementation. Which is only possible by putting all elements of B[] into HashMap. Thus, we can iterate over all indices using loop and Ai can be paired with Bi, If Bi is present in Map, At each iteration the frequency of Bi will be reduced by 1.
Step-by-step algorithm:
- Calculate the sum of all elements of A[] and B[].
- If the sum is not divisible by N, then return -1.
- Else calculate the average Avg = Sum/N.
- Store the frequency of all the elements of B[] in a frequency map.
- Iterate over all the elements for A[] and for every index i, search for (Avg – A[i]) in the frequency map.
- If (Avg – A[i]) is not found, return -1.
- Else make B[i] = (Avg – A[i]) and continue.
- After traversing over all the elements, print the B[] array as the final answer.
Below is the implementation of the algorithm:
//code by flutterfly #include <iostream> #include <unordered_map> using namespace std;
// Function prototype void Rearrange( int N, int A[], int B[]);
// Driver Function int main()
{ // Input
int N = 3;
int A[] = {1, 2, 3};
int B[] = {3, 1, 2};
// Function call
Rearrange(N, A, B);
return 0;
} // Function definition void Rearrange( int N, int A[], int B[])
{ // HashMap to store the elements of B[]
unordered_map< int , int > Map;
// Variable to store sum of all elements of A[] and B[]
int Sum = 0;
// Calculating sum and initializing elements in Map
// Simultaneously
for ( int i = 0; i < N; i++)
{
Sum += A[i] + B[i];
if (Map.find(B[i]) != Map.end())
{
Map[B[i]]++;
}
else
{
Map[B[i]] = 1;
}
}
// Boolean variable to store the possibility of
// arrangement as True or False
bool flag = true ;
// If arrangement is possible
if (Sum % N == 0)
{
// Calculating Avg as (Sum/N)
int Avg = Sum / N;
// Looping on elements of A[] to arrange
// elements of B[]
for ( int i = 0; i < N; i++)
{
// Element required to be paired with A[i]
int required = Avg - A[i];
// Checking if required element is available
if (Map.find(required) != Map.end() && Map[required] > 0)
{
// If available then updating B[i] with
// that required element and reducing
// frequency of that element by 1
B[i] = required;
Map[required]--;
}
// If there is no availability of required
// element then mark flag as false
else
{
flag = false ;
}
}
}
// Marking flag as false if (Sum % N != 0), which is
// else case of If(Sum % N == 0)
else
flag = false ;
// If arrangement was possible then printing
// rearranged A[] and B[]
if (flag)
{
for ( int i = 0; i < N; i++)
{
cout << A[i] << " " ;
}
cout << endl;
for ( int i = 0; i < N; i++)
{
cout << B[i] << " " ;
}
cout << endl;
}
// If no arrangement was possible printing -1.
else
cout << -1 << endl;
} |
// Java code to implement the approach import java.util.*;
// Driver Class class Main {
// Driver Function
public static void main(String[] args)
{
// Input
int N = 3 ;
int A[] = { 1 , 2 , 3 };
int B[] = { 3 , 1 , 2 };
// Function_call
Rearrange(N, A, B);
}
public static void Rearrange( int N, int [] A, int [] B)
{
// HashMap to store the elements of B[]
HashMap<Integer, Integer> Map = new HashMap<>();
// Variable to store sum of all elements of A[] and
// B[]
int Sum = 0 ;
// Calculating sum and initializing elements in Map
// Simualtaneously
for ( int i = 0 ; i < N; i++) {
Sum += A[i] + B[i];
if (Map.containsKey(B[i])) {
Map.put(B[i], Map.get(B[i]) + 1 );
}
else
Map.put(B[i], 1 );
}
// Boolean variable to store the possibility of
// arrangement as True or False
boolean flag = true ;
// If arrangement is possible
if (Sum % N == 0 ) {
// Caulating Avg as (Sum/N)
int Avg = Sum / N;
// Looping on elements of A[] to arrange
// elements of B[]
for ( int i = 0 ; i < N; i++) {
// Element required to be pair with A[i]
int required = Avg - A[i];
// Checking if required element is avaiable
if (Map.containsKey(required)) {
// If avaiable then updating B[i] with
// that required element and reducing
// frequency of that element by 1
B[i] = required;
Map.put(required,
Map.get(required) - 1 );
}
// If there is not avaiability of required
// element then mark flag as false
else {
flag = false ;
}
}
}
// Marking flag as false if (Sum % N != 0), which is
// else case of If(Sum % N == 0)
else
flag = false ;
// If arrangement was possible then printing
// rearranged A[] and B[]
if (flag) {
for ( int i = 0 ; i < N; i++) {
System.out.print(A[i] + " ");
}
System.out.println();
for ( int i = 0 ; i < N; i++) {
System.out.print(B[i] + " ");
}
System.out.println();
}
// If no arranegement was possible priting -1.
else
System.out.println(- 1 );
}
} |
# code by flutterfly # Function definition def rearrange(N, A, B):
# Dictionary to store the elements of B[]
Map = {}
# Variable to store sum of all elements of A[] and B[]
Sum = 0
# Calculating sum and initializing elements in Map
# Simultaneously
for i in range (N):
Sum + = A[i] + B[i]
if B[i] in Map :
Map [B[i]] + = 1
else :
Map [B[i]] = 1
# Boolean variable to store the possibility of
# arrangement as True or False
flag = True
# If arrangement is possible
if Sum % N = = 0 :
# Calculating Avg as (Sum/N)
Avg = Sum / / N
# Looping on elements of A[] to arrange
# elements of B[]
for i in range (N):
# Element required to be paired with A[i]
required = Avg - A[i]
# Checking if required element is available
if required in Map and Map [required] > 0 :
# If available then updating B[i] with
# that required element and reducing
# frequency of that element by 1
B[i] = required
Map [required] - = 1
# If there is no availability of required
# element then mark flag as false
else :
flag = False
# Marking flag as false if (Sum % N != 0), which is
# else case of If(Sum % N == 0)
else :
flag = False
# If arrangement was possible then printing
# rearranged A[] and B[]
if flag:
print ( * A)
print ( * B)
# If no arrangement was possible printing -1.
else :
print ( - 1 )
# Driver Function if __name__ = = "__main__" :
# Input
N = 3
A = [ 1 , 2 , 3 ]
B = [ 3 , 1 , 2 ]
# Function call
rearrange(N, A, B)
|
//code by flutterfly using System;
using System.Collections.Generic;
class Program
{ // Function definition
static void Rearrange( int N, int [] A, int [] B)
{
// Dictionary to store the elements of B[]
Dictionary< int , int > Map = new Dictionary< int , int >();
// Variable to store sum of all elements of A[] and B[]
int Sum = 0;
// Calculating sum and initializing elements in Map
// Simultaneously
for ( int i = 0; i < N; i++)
{
Sum += A[i] + B[i];
if (Map.ContainsKey(B[i]))
{
Map[B[i]] += 1;
}
else
{
Map[B[i]] = 1;
}
}
// Boolean variable to store the possibility of
// arrangement as True or False
bool flag = true ;
// If arrangement is possible
if (Sum % N == 0)
{
// Calculating Avg as (Sum/N)
int Avg = Sum / N;
// Looping on elements of A[] to arrange
// elements of B[]
for ( int i = 0; i < N; i++)
{
// Element required to be paired with A[i]
int required = Avg - A[i];
// Checking if required element is available
if (Map.ContainsKey(required) && Map[required] > 0)
{
// If available then updating B[i] with
// that required element and reducing
// frequency of that element by 1
B[i] = required;
Map[required] -= 1;
}
// If there is no availability of required
// element then mark flag as false
else
{
flag = false ;
}
}
}
// Marking flag as false if (Sum % N != 0), which is
// else case of If(Sum % N == 0)
else
{
flag = false ;
}
// If arrangement was possible then printing
// rearranged A[] and B[]
if (flag)
{
Console.WriteLine( string .Join( " " , A));
Console.WriteLine( string .Join( " " , B));
}
// If no arrangement was possible printing -1.
else
{
Console.WriteLine(-1);
}
}
// Driver Function
static void Main()
{
// Input
int N = 3;
int [] A = { 1, 2, 3 };
int [] B = { 3, 1, 2 };
// Function call
Rearrange(N, A, B);
}
} |
// code by flutterfly // Function definition function rearrange(N, A, B) {
// Map to store the elements of B[]
let Map = new Map();
// Variable to store sum of all elements of A[] and B[]
let Sum = 0;
// Calculating sum and initializing elements in Map
// Simultaneously
for (let i = 0; i < N; i++) {
Sum += A[i] + B[i];
if (Map.has(B[i])) {
Map.set(B[i], Map.get(B[i]) + 1);
} else {
Map.set(B[i], 1);
}
}
// Boolean variable to store the possibility of
// arrangement as True or False
let flag = true ;
// If arrangement is possible
if (Sum % N === 0) {
// Calculating Avg as (Sum/N)
let Avg = Sum / N;
// Looping on elements of A[] to arrange
// elements of B[]
for (let i = 0; i < N; i++) {
// Element required to be paired with A[i]
let required = Avg - A[i];
// Checking if required element is available
if (Map.has(required) && Map.get(required) > 0) {
// If available then updating B[i] with
// that required element and reducing
// frequency of that element by 1
B[i] = required;
Map.set(required, Map.get(required) - 1);
}
// If there is no availability of required
// element then mark flag as false
else {
flag = false ;
}
}
}
// Marking flag as false if (Sum % N != 0), which is
// else case of If(Sum % N == 0)
else {
flag = false ;
}
// If arrangement was possible then printing
// rearranged A[] and B[]
if (flag) {
console.log(A.join( " " ));
console.log(B.join( " " ));
}
// If no arrangement was possible printing -1.
else {
console.log(-1);
}
} // Driver Function // Input let N = 3; let A = [1, 2, 3]; let B = [3, 1, 2]; // Function call rearrange(N, A, B); |
1 2 3 3 2 1
Time Complexity: O(N), where N is the size of input array A[] or B[].
Auxiliary Space: O(N)