Skip to content
Related Articles

Related Articles

Minimize remaining array element by removing pairs and replacing them with their average
  • Last Updated : 10 Feb, 2021

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: 
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 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++

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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output: 

26

 

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

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 :