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 element` `int` `final_element(``int` `arr[], ``int` `n)` `{`   `    ``// Priority queue can be used` `    ``// to construct max-heap` `    ``priority_queue<``int``> 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 Code` `int` `main()` `{` `    ``// Given array arr[]` `    ``int` `arr[] = { 3, 5, 2, 7 };`   `    ``// Size of array arr[]` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``// Function Call` `    ``final_element(arr, n);` `    ``return` `0;` `}`

Java

 `// Java program for the above approach ` `import` `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 code` `public` `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 approach ` `from` `queue ``import` `PriorityQueue`   `# Function to print the remaining element` `def` `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 Code` `if` `__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 approach ` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{` `    `  `// Function to print the remaining element ` `static` `void` `final_element(``int``[] arr, ``int` `n) ` `{ ` `    `  `    ``// Priority queue can be used ` `    ``// to construct max-heap ` `    ``List<``int``> heap = ``new` `List<``int``>();` `  `  `    ``// 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[0]; ` `        ``heap.RemoveAt(0); ` `  `  `        ``// Remove 2nd largest element ` `        ``int` `Y = heap[0]; ` `        ``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[0]); ` `    ``} ` `  `  `    ``// Else print "-1" ` `    ``else` `    ``{ ` `        ``Console.Write(-1); ` `    ``} ` `} `   `// Driver code` `static` `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)