Rearrange arrays such that sum of corresponding elements is same for all equal indices

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 (A_i + B_i) 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: A₁ + B₁ = (3 + 1) = 4
• 2nd index: A₂ + B₂ = (1 + 3) = 4
• 3rd index: A₃ + B₃ = (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 (A_i + B_i) 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:

1. Possibility of rearrangement
2. Final rearrangement

Let us see both of them one by one:

• Possibility of rearrangement:
  • As it is mentioned that the sum of (A_i + B_i) 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 (A_i + B_i) = 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 A_i then it must be paired with an element of B[] such that B_i = (Avg – X). So, that sum of both (A_i + B_i) = ((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 B_i is present in Map, At each iteration the frequency of B_i 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:

C++

//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

// 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);
    }
}

Python3

# 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)

C#

//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);
    }
}

Javascript

// 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);

Output

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)