# Minimize remaining array element by removing pairs and replacing them with their average

Given an array arr[] of size N, the task is to find the smallest possible remaining array element by repeatedly removing a pair, say (arr[i], arr[j]) from the array and inserting the Ceil value of their average.

Examples:

Input: arr[] = { 1, 2, 3 }
Output: 2
Explanation:
Removing the pair (arr[1], arr[2]) from arr[] and inserting (arr[1] + arr[2] + 1) / 2 into arr[] modifies arr[] to { 1, 2 }.
Removing the pair (arr[0], arr[1]) from arr[] and inserting (arr[0] + arr[1] + 1) / 2 into arr[] modifies arr[] to { 2 }.
Therefore, the required output is 2.

Input: arr[] = { 30, 16, 40 }
Output: 26
Explanation:
Removing the pair (arr[0], arr[2]) from arr[] and inserting (arr[0] + arr[2] + 1) / 2 into arr[] modifies arr[] to { 16, 35 } .
Removing the pair (arr[0], arr[1]) from arr[] and inserting (arr[0] + arr[1] + 1) / 2 into arr[] modifies arr[] to { 26 } .
Therefore, the required output is 26.

Approach: The problem can be solved using Greedy technique. The idea is to repeatedly remove the maximum and the second-maximum array element and insert their average. Finally, print the smallest element left in the array.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to find the smallest element``// left in the array by removing pairs``// and inserting their average``int` `findSmallestNumLeft(``int` `arr[], ``int` `N)``{``    ``// Stores array elements such that the``    ``// largest element present at top of PQ``    ``priority_queue<``int``> PQ;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Insert arr[i] into PQ``        ``PQ.push(arr[i]);``    ``}` `    ``// Iterate over elements of PQ while count``    ``// of elements in PQ greater than 1``    ``while` `(PQ.size() > 1) {` `        ``// Stores largest element of PQ``        ``int` `top1 = PQ.top();` `        ``// Pop the largest element of PQ``        ``PQ.pop();` `        ``// Stores largest element of PQ``        ``int` `top2 = PQ.top();` `        ``// Pop the largest element of PQ``        ``PQ.pop();` `        ``// Insert the ceil value of average``        ``// of top1 and top2``        ``PQ.push((top1 + top2 + 1) / 2);``    ``}` `    ``return` `PQ.top();``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 30, 16, 40 };``    ``int` `N = ``sizeof``(arr)``            ``/ ``sizeof``(arr[0]);` `    ``cout << findSmallestNumLeft(``        ``arr, N);` `    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.PriorityQueue;` `class` `GFG{` `// Function to find the smallest element``// left in the array by removing pairs``// and inserting their average``static` `int` `findSmallestNumLeft(``int` `arr[], ``int` `N)``{``  ` `    ``// Stores array elements such that the``    ``// largest element present at top of PQ``    ``PriorityQueue PQ = ``new` `PriorityQueue((a,b)->b-a);` `    ``// Traverse the array``    ``for` `(``int` `i = ``0``; i < N; i++) ``    ``{` `        ``// Insert arr[i] into PQ``        ``PQ.add(arr[i]);``    ``}` `    ``// Iterate over elements of PQ while count``    ``// of elements in PQ greater than 1``    ``while` `(PQ.size() > ``1``) ``    ``{` `        ``// Stores largest element of PQ``        ``int` `top1 = PQ.peek();` `        ``// Pop the largest element of PQ``        ``PQ.remove();` `        ``// Stores largest element of PQ``        ``int` `top2 = PQ.peek();` `        ``// Pop the largest element of PQ``        ``PQ.remove();` `        ``// Insert the ceil value of average``        ``// of top1 and top2``        ``PQ.add((top1 + top2 + ``1``) / ``2``);``    ``}` `    ``return` `PQ.peek();``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``30``, ``16``, ``40` `};``    ``int` `N = arr.length;` `    ``System.out.print(findSmallestNumLeft(``        ``arr, N));` `}``}` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to find the smallest element``# left in the array by removing pairs``# and inserting their average``def` `findSmallestNumLeft(arr, N):``    ` `    ``# Stores array elements such that the``    ``# largest element present at top of PQ``    ``PQ ``=` `[]` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):``        ` `        ``# Insert arr[i] into PQ``        ``PQ.append(arr[i])` `    ``# Iterate over elements of PQ while count``    ``# of elements in PQ greater than 1``    ``PQ ``=` `sorted``(PQ)` `    ``while` `(``len``(PQ) > ``1``):` `        ``# Stores largest element of PQ``        ``top1 ``=` `PQ[``-``1``]` `        ``# Pop the largest element of PQ``        ``del` `PQ[``-``1``]` `        ``# Stores largest element of PQ``        ``top2 ``=` `PQ[``-``1``]` `        ``# Pop the largest element of PQ``        ``del` `PQ[``-``1``]` `        ``# Insert the ceil value of average``        ``# of top1 and top2``        ``PQ.append((top1 ``+` `top2 ``+` `1``) ``/``/` `2``)``        ``PQ ``=` `sorted``(PQ)` `    ``return` `PQ[``-``1``]` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``30``, ``16``, ``40` `]``    ``N ``=` `len``(arr)` `    ``print` `(findSmallestNumLeft(arr, N))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;``class` `GfG ``{ ``    ``// Function to find the smallest element``    ``// left in the array by removing pairs``    ``// and inserting their average``    ``static` `int` `findSmallestNumLeft(``int``[] arr, ``int` `N)``    ``{``        ``// Stores array elements such that the``        ``// largest element present at top of PQ``        ``List<``int``> PQ = ``new` `List<``int``>();``     ` `        ``// Traverse the array``        ``for` `(``int` `i = 0; i < N; i++) {``     ` `            ``// Insert arr[i] into PQ``            ``PQ.Add(arr[i]);``        ``}``        ` `        ``PQ.Sort();``        ``PQ.Reverse();``        ` `        ``// Iterate over elements of PQ while count``        ``// of elements in PQ greater than 1``        ``while` `(PQ.Count > 1) {``     ` `            ``// Stores largest element of PQ``            ``int` `top1 = PQ[0];``     ` `            ``// Pop the largest element of PQ``            ``PQ.RemoveAt(0);``     ` `            ``// Stores largest element of PQ``            ``int` `top2 = PQ[0];``     ` `            ``// Pop the largest element of PQ``            ``PQ.RemoveAt(0);``     ` `            ``// Insert the ceil value of average``            ``// of top1 and top2``            ``PQ.Add((top1 + top2 + 1) / 2);``            ` `            ``PQ.Sort();``            ``PQ.Reverse();``        ``}``     ` `        ``return` `PQ[0];``    ``}` `  ``// Driver code``    ``public` `static` `void` `Main() ``    ``{ ``        ``int``[] arr = { 30, 16, 40 };``        ``int` `N = arr.Length;``     ` `        ``Console.Write(findSmallestNumLeft(arr, N));``    ``} ``} ` `// This code is contributed by divyeshrabadiya07.`

## Javascript

 ``

Output:
`26`

Time Complexity: O(N*logN), as we are using a loop to traverse N times and priority queue operation will take logN time.

Auxiliary Space: O(N), as we are using extra space for priority queue.

Previous
Next