# 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:**

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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.

Input:arr[] = { 1, 2, 3 }Output: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:26Explanation:

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 first and the second-largest array element and insert their average. Finally, print the smallest element left in the array.

- Initialize a priority_queue, say
**PQ**, to store the array elements such that the largest element is always present at the top of**PQ**. - Traverse the array and store all the array elements in
**PQ**. - Iterate over the elements of the
**priority_queue**while count of elements in the**priority_queue**is greater than**1**. In every iteration, pop the top two elements from**PQ**and insert the**Ceil value**of their average. - Finally, print the element left in
**PQ**.

Below is the implementation of the above approach:

## C++

`// C++ program to implement` `// the above approach` `#include <bits/stdc++.h>` `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<Integer> PQ = ` `new` `PriorityQueue<Integer>((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

`<script>` `// Javascript program to implement` `// the above approach` `// Function to find the smallest element` `// left in the array by removing pairs` `// and inserting their average` `function` `findSmallestNumLeft(arr, N)` `{` ` ` `// Stores array elements such that the` ` ` `// largest element present at top of PQ` ` ` `let PQ = [];` ` ` ` ` `// Traverse the array` ` ` `for` `(let i = 0; i < N; i++)` ` ` `{` ` ` ` ` `// Insert arr[i] into PQ` ` ` `PQ.push(arr[i]);` ` ` `}` ` ` ` ` `PQ.sort(` `function` `(a,b){` `return` `b-a;});` ` ` ` ` `// Iterate over elements of PQ while count` ` ` `// of elements in PQ greater than 1` ` ` `while` `(PQ.length > 1)` ` ` `{` ` ` ` ` `// Stores largest element of PQ` ` ` `let top1 = PQ[0];` ` ` ` ` `// Pop the largest element of PQ` ` ` `PQ.shift();` ` ` ` ` `// Stores largest element of PQ` ` ` `let top2 = PQ[0];` ` ` ` ` `// Pop the largest element of PQ` ` ` `PQ.shift();` ` ` ` ` `// Insert the ceil value of average` ` ` `// of top1 and top2` ` ` `PQ.push(Math.floor((top1 + top2 + 1) / 2));` ` ` `PQ.sort(` `function` `(a,b){` `return` `b-a;});` ` ` `}` ` ` ` ` `return` `PQ[0];` `}` `// Driver Code` `let arr = [ 30, 16, 40];` `let N = arr.length;` `document.write(findSmallestNumLeft(` ` ` `arr, N));` `// This code is contributed by unknown2108` `</script>` |

**Output:**

26

* Time Complexity:* O(N * log(N))

*O(N)*

**Auxiliary Space:**