Last element remaining by deleting two largest elements and replacing by their absolute difference if they are unequal

• Last Updated : 29 Oct, 2021

Given an array arr[] of N elements, the task is to perform the following operation:

• Pick the two largest element from the array and remove these element. If the elements are unequal then insert the absolute difference of the elements into the array.
• Perform the above operations until array has 1 or no element in it. If the array has only one element left then print that element, else print “-1”.

Examples:

Input: arr[] = { 3, 5, 2, 7 }
Output:
Explanation:
The two largest elements are 7 and 5. Discard them. Since both are not equal, insert 7 – 5 = 2 into the array. Hence, arr[] = { 3, 2, 2 }
The two largest elements are 3 and 2. Discard them. Since both are not equal, insert 3 – 2 = 1 into the array. Hence, arr[] = { 1, 2 }
The two largest elements are 2 and 1. Discard them. Since both are not equal, insert 2 – 1 = 1 into the array. Hence, arr[] = { 1 }
The only element left is 1. Print the value of the only element left.

Input: arr[] = { 3, 3 }
Output: -1
Explanation:
The two largest elements are 3 and 3. Discard them. Now the array has no elements. So, print -1.

Approach: To solve the above problem we will use Priority Queue Data Structure. Below are the steps:

1. Insert all the array elements in the Priority Queue.
2. As priority queue is based on the implementation of Max-Heap. Therefore removing element from it gives the maximum element.
3. Till the size of priority queue is not less than 2, remove two elements(say X & Y) from it and do the following:
• If X and Y are not same then insert the absolute value of X and Y into the priority queue.
4. If the heap has only one element then print that element.
5. Else print “-1”.

Below is the implementation of the above approach:

C++

 // C++ program for the above approach#include using namespace std; // Function to print the remaining elementint final_element(int arr[], int n){     // Priority queue can be used    // to construct max-heap    priority_queue heap;     // Insert all element of arr[]    // into priority queue    for (int i = 0; i < n; i++)        heap.push(arr[i]);     // Perform operation until heap    // size becomes 0 or 1    while (heap.size() > 1) {         // Remove largest element        int X = heap.top();        heap.pop();         // Remove 2nd largest element        int Y = heap.top();        heap.pop();         // If extracted element        // are not equal        if (X != Y) {             // Find X - Y and push            // it to heap            int diff = abs(X - Y);            heap.push(diff);        }    }     // If heap size is 1, then    // print the remaining element    if (heap.size() == 1) {         cout << heap.top();    }     // Else print "-1"    else {        cout << "-1";    }} // Driver Codeint main(){    // Given array arr[]    int arr[] = { 3, 5, 2, 7 };     // Size of array arr[]    int n = sizeof(arr) / sizeof(arr);     // Function Call    final_element(arr, n);    return 0;}

Java

 // Java program for the above approachimport java.io.*;import java.util.Collections;import java.util.*; class GFG{     // Function to print the remaining element    static public int final_element(Integer[] arr, int n){    if(arr == null)    {        return 0;    }         // Priority queue can be used    // to construct max-heap    PriorityQueue heap = new    PriorityQueue(Collections.reverseOrder());         // Insert all element of arr[]    // into priority queue    for(int i = 0; i < n; i++)    {       heap.offer(arr[i]);    }         // Perform operation until heap    // size becomes 0 or 1    while (heap.size() > 1)    {                 // Remove largest element        int X = heap.poll();                 // Remove 2nd largest element        int Y = heap.poll();                 // If extracted element        // are not equal        if (X != Y)        {            // Find X - Y and push            // it to heap            int diff = Math.abs(X - Y);            heap.offer(diff);        }    }         // If heap size is 1, then    // print the remaining element    // Else print "-1"    return heap.size() == 1 ? heap.poll() : -1;} // Driver codepublic static void main (String[] args){    // Given array arr[]    Integer arr[] = new Integer[] { 3, 5, 2, 7};         // Size of array arr[]    int n = arr.length;         // Function Call    System.out.println(final_element(arr, n)); }} // This code is contributed by deepika_sharma

Python3

 # Python3 program for the above approachfrom queue import PriorityQueue # Function to print the remaining elementdef final_element(arr, n):         # Priority queue can be used    # to construct max-heap    heap = PriorityQueue()         # Insert all element of    # arr[] into priority queue.    # Default priority queue in Python    # is min-heap so use -1*arr[i]    for i in range(n):        heap.put(-1 * arr[i])         # Perform operation until heap    # size becomes 0 or 1    while (heap.qsize() > 1):         # Remove largest element        X = -1 * heap.get()         # Remove 2nd largest element        Y = -1 * heap.get()         # If extracted elements        # are not equal        if (X != Y):             # Find X - Y and push            # it to heap            diff = abs(X - Y)            heap.put(-1 * diff)     # If heap size is 1, then    # print the remaining element    if (heap.qsize() == 1):        print(-1 * heap.get())     # Else print "-1"    else:        print("-1") # Driver Codeif __name__ == '__main__':         # Given array arr[]    arr = [ 3, 5, 2, 7 ]     # Size of array arr[]    n = len(arr)     # Function call    final_element(arr, n) # This code is contributed by himanshu77

C#

 // C# program for the above approachusing System;using System.Collections.Generic; class GFG{     // Function to print the remaining elementstatic void final_element(int[] arr, int n){         // Priority queue can be used    // to construct max-heap    List heap = new List();       // Insert all element of arr[]    // into priority queue    for(int i = 0; i < n; i++)        heap.Add(arr[i]);       // Perform operation until heap    // size becomes 0 or 1    while (heap.Count > 1)    {                 // Remove largest element        heap.Sort();        heap.Reverse();        int X = heap;        heap.RemoveAt(0);           // Remove 2nd largest element        int Y = heap;        heap.RemoveAt(0);           // If extracted element        // are not equal        if (X != Y)        {                         // Find X - Y and push            // it to heap            int diff = Math.Abs(X - Y);            heap.Add(diff);        }    }       // If heap size is 1, then    // print the remaining element    if (heap.Count == 1)    {        heap.Sort();        heap.Reverse();        Console.Write(heap);    }       // Else print "-1"    else    {        Console.Write(-1);    }} // Driver codestatic void Main(){         // Given array arr[]    int[] arr = { 3, 5, 2, 7 };         // Size of array arr[]    int n = arr.Length;         // Function Call    final_element(arr, n);}} // This code is contributed by divyeshrabadiya07

Javascript


Output:
1

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

My Personal Notes arrow_drop_up