Open In App

Reduce the array to atmost one element by the given operations

Improve
Improve
Like Article
Like
Save
Share
Report

Given an array of integers arr[], the task is to find the remaining element in the array after performing the following operations:
 

  • In each turn, choose the two maximum integers X and Y from the array.
  • If X == Y, remove both elements from the array.
  • If X != Y, insert an element into the array equal to abs(X – Y).

Note: If no element remains, print 0. 
Examples: 
 

Input: arr[] = [3, 4, 6, 2, 7, 1] 
Output:
Explanation: 
Elements 7 and 6 are reduced to 1 so the array converts to [3, 4, 2, 1, 1] 
Elements 3 and 4 are reduced to 2 so the array converts to [2, 1, 1, 1] 
Elements 2 and 1 are reduced to 1 so the array converts to [1, 1, 1] 
Element 1 is completely destroyed by another 1 so array is [1] at the end.
Input: arr[] = [1, 2, 3, 4, 5] 
Output:
Explanation: 
Elements 4 and 5 are reduced to 1 so the array converts to [1, 2, 3, 1] 
Elements 2 and 3 are reduced to 1 so the array converts to [1, 1, 1] 
Element 1 is completely destroyed by another 1 so array is [1] at the end. 
 

Approach: 
To solve the problem mentioned above, we need to use Heap Data Structure. Heaps are used because we only require the current maximum element for every instant and are not concerned about the rest of the elements. 
 

  • Create a Max Heap from the elements of the given array.
  • Keep extracting the top element twice for every iteration. If their absolute difference is non-zero, push their difference back to the queue.
  • Continue until only one or no elements are remaining.
  • If no elements remain, print 0. Otherwise, print the remaining element.

Below is the implementation of above approach: 
 

C++




// C++ Program to reduce the
// array to almost one element
// by the given operations
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the remaining
// element of array
int reduceArray(vector<int>& arr)
{
    priority_queue<int> p;
 
    // Build a priority queue
    // using the array
    for (int i = 0; i < arr.size(); ++i)
        p.push(arr[i]);
 
    // Continue until the priority
    // queue has one or no elements
    // remaining
    while (p.size() > 1) {
 
        // Top-most integer from heap
        int y = p.top();
        p.pop();
 
        // Second integer from heap
        int x = p.top();
        p.pop();
 
        // Resultant value
        int val = y - x;
        if (val != 0)
            p.push(val);
    }
 
    // Return 0 if no elements are left
    if (p.size() == 0)
        return 0;
 
    // Return top value of the heap
    return p.top();
}
 
// Driver code
int main()
{
 
    vector<int> arr
        = { 3, 4, 6, 2, 7, 1 };
    cout << reduceArray(arr)
         << "\n";
    return 0;
}


Java




// Java program to reduce the
// array to almost one element
// by the given operations
import java.util.*;
 
class GFG{
 
// Function to find the remaining
// element of array
static int reduceArray(int[] arr)
{
    PriorityQueue<Integer> p = new PriorityQueue<>(
        11, Collections.reverseOrder());
 
    // Build a priority queue
    // using the array
    for(int i = 0; i < arr.length; ++i)
        p.add(arr[i]);
         
    // Continue until the priority
    // queue has one or no elements
    // remaining
    while (p.size() > 1)
    {
 
        // Top-most integer from heap
        int y = p.poll();
 
        // Second integer from heap
        int x = p.poll();
         
        // Resultant value
        int val = y - x;
        if (val != 0)
            p.add(val);
    }
     
    // Return 0 if no elements are left
    if (p.size() == 0)
        return 0;
 
    // Return top value of the heap
    return p.poll();
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 3, 4, 6, 2, 7, 1 };
     
    System.out.println(reduceArray(arr));
}
}
 
// This code is contributed by jrishabh99


Python3




# Python3 program to reduce the
# array to almost one element
# by the given operations
 
# Function to find the remaining
# element of array
 
import heapq
 
 
def reduceArray(arr):
    # Build a max heap by heapq module
    # using the array
    heapq._heapify_max(arr)
    # Continue until the priority
    # queue has one or no elements
    # remaining
    while len(arr) > 1:
        # extracting maximum element of the max
        # heap into x
        x = arr[0]
        # assigning last element of the heap to
        # root element of the heap
        arr[0] = arr[-1]
        # reducing max heap size by 1
        arr = arr[:-1]
        # again calling heapify to maintain
        # max heap property
        heapq._heapify_max(arr)
        # now extracting maximum element of the max
        # heap into y
        y = arr[0]
        # assigning last element of the heap to
        # root element of the heap
        arr[0] = arr[-1]
        # reducing max heap size by 1
        arr = arr[:-1]
 
        # finding absolute difference of x and y
        val = abs(x-y)
        # if both x and y are not equal, then
        # inserting their absolute difference
        # back into the heap
        if val != 0:
            arr.append(val)
        # agian maintaining the max heap
        # with the help of heapify()
        heapq._heapify_max(arr)
    if len(arr) == 0:
        return 0
    return arr[0]
 
 
# Driver Code
arr = [3, 4, 6, 2, 7, 1]
print(reduceArray(arr))
'''Code is contributed by Rajat Kumar (GLAU)


C#




using System;
using System.Collections.Generic;
using System.Linq;
 
namespace reduce_array
{
    class Program
    {
        static int reduceArray(List<int> arr)
        {
            // Build a priority queue
            // using the array
            SortedSet<int> p = new SortedSet<int>();
            foreach (int i in arr)
            {
                p.Add(i);
            }
 
            // Continue until the priority
            // queue has one or no elements
            // remaining
            while (p.Count > 1)
            {
 
                // Top-most integer from heap
                int y = p.Max;
                p.Remove(y);
 
                // Second integer from heap
                int x = p.Max;
                p.Remove(x);
 
                // Resultant value
                int val = y - x;
                if (val != 0)
                    p.Add(val);
            }
 
            // Return 0 if no elements are left
            if (p.Count == 0)
                return 0;
 
            // Return top value of the heap
            return p.Max;
        }
 
        static void Main(string[] args)
        {
            List<int> arr
                = new List<int> {3, 4, 6, 2, 7, 1 };
            Console.WriteLine(reduceArray(arr));
        }
    }
}


Javascript




<script>
 
// JavaScript program to reduce the
// array to almost one element
// by the given operations
 
// Function to find the remaining
// element of array
function reduceArray(arr){
     
    let p = []
 
    // Build a priority queue
    // using the array
    for(let i = 0; i < arr.length; i++)
        p.push(arr[i])
    p.sort().reverse()
 
    // Continue until the priority
    // queue has one or no elements
    // remaining
    while (p.length > 1){
         
        // Top-most integer from heap
        let y = p[0]
        p.splice(0,1)
 
        // Second integer from heap
        let x = p[0]
        p.splice(0,1)
 
        // Resultant value
        let val = y - x
         
        if (val != 0)
            p.push(val)
        p.sort().reverse()
    }
 
    // Return 0 if no elements are left
    if (p.length == 0)
        return 0
 
    // Return top value of the heap
    return p[0]
}
 
// Driver code
let arr = [ 3, 4, 6, 2, 7, 1 ]
     
document.write(reduceArray(arr),"</br>")
 
// This code is contributed by Shinjanpatra
 
</script>


Output: 

1

 

Time Complexity: O(N*logN)

We first build a priority queue by iterating over the array which takes O(N) time. Then, we iterate over the priority queue to find the remaining element which takes O(N*logN) time. Thus, the overall time complexity of the algorithm is O(N*logN).

Space Complexity: O(N)

We are using a priority queue to store all the elements of the array. Thus, the space complexity of the algorithm is O(N).



Last Updated : 27 Jan, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads