Related Articles

# Reduce the array to a single integer with the given operation

• Difficulty Level : Easy
• Last Updated : 13 Apr, 2021

Given an array arr[] of N integers from 1 to N. The task is to perform the following operations N – 1 times.

1. Select two elements X and Y from the array.
2. Delete the chosen elements from the array.
3. Add X2 + Y2in the array.

After performing above operations N – 1 times only one integer will be left in the array. The task is to print the maximum possible value of that integer.
Examples:

Input: N = 3
Output: 170
Initial array: arr[] = {1, 2, 3}
Choose 2 and 3 and the array becomes arr[] = {1, 13}
Performing the operation again by choosing the only two elements left,
the array becomes arr[] = {170} which is the maximum possible value.
Input: N = 4
Output: 395642

Approach: To maximize the value of final integer we have to maximize the value of (X2 + Y2). So each time we have to choose the maximum two values from the array. Store all integers in a priority queue. Each time pop top 2 elements and push the result of (X2 + Y2) in the priority queue. The last remaining element will be the maximum possible value of the required integer.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;``#define ll long long int` `// Function to return the maximum``// integer after performing the operations``int` `reduceOne(``int` `N)``{``    ``priority_queue pq;` `    ``// Initialize priority queue with``    ``// 1 to N``    ``for` `(``int` `i = 1; i <= N; i++)``        ``pq.push(i);` `    ``// Perform the operations while``    ``// there are at least 2 elements``    ``while` `(pq.size() > 1) {` `        ``// Get the maximum and``        ``// the second maximum``        ``ll x = pq.top();``        ``pq.pop();``        ``ll y = pq.top();``        ``pq.pop();` `        ``// Push (x^2 + y^2)``        ``pq.push(x * x + y * y);``    ``}` `    ``// Return the only element left``    ``return` `pq.top();``}` `// Driver code``int` `main()``{``    ``int` `N = 3;` `    ``cout << reduceOne(N);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{` `    ``// Function to return the maximum``    ``// integer after performing the operations``    ``static` `long` `reduceOne(``int` `N)``    ``{``        ``// To create Max-Heap``        ``PriorityQueue pq = ``new``        ``PriorityQueue(Collections.reverseOrder());` `        ``// Initialize priority queue with``        ``// 1 to N``        ``for` `(``long` `i = ``1``; i <= N; i++)``            ``pq.add(i);` `        ``// Perform the operations while``        ``// there are at least 2 elements``        ``while` `(pq.size() > ``1``)``        ``{` `            ``// Get the maximum and``            ``// the second maximum``            ``long` `x = pq.poll();``            ``long` `y = pq.poll();` `            ``// Push (x^2 + y^2)``            ``pq.add(x * x + y * y);``        ``}` `        ``// Return the only element left``        ``return` `pq.peek();``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``3``;``        ``System.out.println(reduceOne(N));``    ``}``}` `// This code is contributed by``// sanjeev2552`

## Python3

 `# Python3 implementation of the approach` `# Function to return the maximum``# integer after performing the operations``def` `reduceOne(N) :``    ``pq ``=` `[]``    ` `    ``# Initialize priority queue with``    ``# 1 to N``    ``for` `i ``in` `range``(``1``, N ``+` `1``) :``      ``pq.append(i)``    ``pq.sort()``    ``pq.reverse()``    ` `    ``# Perform the operations while``    ``# there are at least 2 elements``    ``while``(``len``(pq) > ``1``) :``    ` `      ``# Get the maximum and``      ``# the second maximum``      ``x ``=` `pq[``0``]``      ``pq.pop(``0``)``      ``y ``=` `pq[``0``]``      ``pq.pop(``0``)``    ` `      ``# Push (x^2 + y^2)``      ``pq.append(x ``*` `x ``+` `y ``*` `y)``      ``pq.sort()``      ``pq.reverse()``    ` `    ``# Return the only element left``    ``return` `pq[``0``]``    ` `    ``# Driver code``N ``=` `3``print``(reduceOne(N))` `# This code is contributed by divyeshrabadiya07.`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;``class` `GFG {` `  ``// Function to return the maximum``  ``// integer after performing the operations``  ``static` `int` `reduceOne(``int` `N)``  ``{``    ``List<``int``> pq = ``new` `List<``int``>();` `    ``// Initialize priority queue with``    ``// 1 to N``    ``for` `(``int` `i = 1; i <= N; i++)``      ``pq.Add(i);` `    ``pq.Sort();``    ``pq.Reverse();` `    ``// Perform the operations while``    ``// there are at least 2 elements``    ``while` `(pq.Count > 1) {` `      ``// Get the maximum and``      ``// the second maximum``      ``int` `x = pq[0];``      ``pq.RemoveAt(0);``      ``int` `y = pq[0];``      ``pq.RemoveAt(0);` `      ``// Push (x^2 + y^2)``      ``pq.Add(x * x + y * y);``      ``pq.Sort();``      ``pq.Reverse();``    ``}` `    ``// Return the only element left``    ``return` `pq[0];``  ``}` `  ``// Driver code``  ``static` `void` `Main()``  ``{``    ``int` `N = 3;``    ``Console.WriteLine(reduceOne(N));``  ``}``}` `// This code is contributed by divyesh072019.`

## Javascript

 ``
Output:
`170`

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.

My Personal Notes arrow_drop_up