Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Maximize sum of product and difference between any pair of array elements possible

  • Difficulty Level : Expert
  • Last Updated : 10 Jun, 2021

Given an array arr[] of size N, the task is to find the maximum value of arr[i] ∗ arr[j] + arr[i] − arr[j] for any pair (arr[i], arr[j]) from the given array, where i != j and 0 < i, j < N – 1.

Examples:

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.

Input: arr[] = {1, 2, 3, 4, 5}
Output: 21
Explanation:
Among all the pairs of the array, the maximum value is obtained for the pair (arr[4], arr[3]), which is equal to
=> arr[4] * arr[3] + arr[4] – arr[3] = 5 * 4 + 5 – 4 = 20 + 1 = 21. 



Input: {-4, -5, 0, 1, 3}
Output: 21
Explanation:
Among all the pairs of the array, the maximum value is obtained for the pair (arr[0], arr[1]), which is equal to
=> arr[0] * arr[1] + arr[0] – arr[1] = (-4) * (-5) + (-4) – (-5) = 20 + 1 = 21. 

 

Naive Approach: The simplest approach to solve the problem is to traverse the array and generate all possible pairs (arr[i], arr[j]) (i != j) from the array and evaluate the expression for all the pairs. Finally, print the maximum of all the pairs.
Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: The optimal idea is based on the observation that the value of the expression can be maximum for the following 2 cases:

Follow the steps below to solve the problem:

  • Sort the array arr[] in ascending order.
  • Evaluate the expression for the pair arr[N – 1] and arr[N – 2] and store it in a variable, say max1.
  • Similarly, evaluate the expression for the pair arr[1] and arr[0] and store it in a variable, say max2.
  • Store the maximum of max1 and max2 in a variable, say ans.
  • Print the value of ans as the result.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to evaluate given expression
int compute(int a, int b)
{
    // Store the result
    int ans = a * b + a - b;
    return ans;
}
 
// Function to find the maximum value of
// the given expression possible for any
// unique pair from the given array
void findMaxValue(int arr[], int N)
{
    // Sort the array in ascending order
    sort(arr, arr + N);
 
    // Evaluate the expression for
    // the two largest elements
    int maxm = compute(arr[N - 1], arr[N - 2]);
 
    // Evaluate the expression for
    // the two smallest elements
    maxm = max(maxm, compute(arr[1], arr[0]));
 
    // Print the maximum
    cout << maxm;
}
 
// Driver Code
int main()
{
    // Given array
    int arr[] = { -4, -5, 0, 1, 3 };
 
    // Store the size of the array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    findMaxValue(arr, N);
 
    return 0;
}
Java



// Java program for the above approach
import java.io.*;
import java.util.*;
class GFG
{
 
  // Function to evaluate given expression
  static int compute(int a, int b)
  {
    // Store the result
    int ans = a * b + a - b;
    return ans;
  }
 
  // Function to find the maximum value of
  // the given expression possible for any
  // unique pair from the given array
  static void findMaxValue(int arr[], int N)
  {
    // Sort the array in ascending order
    Arrays.sort(arr);
 
    // Evaluate the expression for
    // the two largest elements
    int maxm = compute(arr[N - 1], arr[N - 2]);
 
    // Evaluate the expression for
    // the two smallest elements
    maxm = Math.max(maxm, compute(arr[1], arr[0]));
 
    // Print the maximum
    System.out.print(maxm);
  }
 
 
  // Driver Code
  public static void main(String[] args)
  {
    // Given array
    int arr[] = { -4, -5, 0, 1, 3 };
 
    // Store the size of the array
    int N = arr.length;
 
    findMaxValue(arr, N);
  }
}
 
// This code is contributed by saanjoy_62
Python3



# Python Program for the above approach
# Function to evaluate given expression
def compute(a, b):
   
    # Store the result
    res = (a * b) + (a - b)
    return res
   
# Function to find the maximum value of
# the given expression possible for any
# unique pair from the given array
def findMaxValue(arr, N):
   
    # Sort the list in ascending order
    arr.sort()
     
    # Evaluate the expression for
    # the two largest elements
    maxm = compute(arr[N - 1], arr[N - 2])
     
    # Evaluate the expression for
    # the two smallest elements
    maxm = max(maxm, compute(arr[1], arr[0]));
    print(maxm)
     
# Driver code
# given list
arr = [-4, -5, 0, 1, 3]
 
# store the size of the list
N = len(arr)
findMaxValue(arr, N)
 
# This code is contributed by santhoshcharan.
C#



// C# program for above approach
using System;
public class GFG
{
 
  // Function to evaluate given expression
  static int compute(int a, int b)
  {
    // Store the result
    int ans = a * b + a - b;
    return ans;
  }
  
  // Function to find the maximum value of
  // the given expression possible for any
  // unique pair from the given array
  static void findMaxValue(int[] arr, int N)
  {
    // Sort the array in ascending order
    Array.Sort(arr);
  
    // Evaluate the expression for
    // the two largest elements
    int maxm = compute(arr[N - 1], arr[N - 2]);
  
    // Evaluate the expression for
    // the two smallest elements
    maxm = Math.Max(maxm, compute(arr[1], arr[0]));
  
    // Print the maximum
    Console.WriteLine(maxm);
  }
 
// Driver code
public static void Main(String[] args)
{
 
    // Given array
    int[] arr = { -4, -5, 0, 1, 3 };
  
    // Store the size of the array
    int N = arr.Length;
  
    findMaxValue(arr, N);
}
}
 
// This code is contributed by susmitakundugoaldanga.
Javascript



<script>
// Javascript implementation of the above approach
 
// Function to evaluate given expression
function compute(a, b)
{
    // Store the result
    var ans = a * b + a - b;
    return ans;
}
 
// Function to find the maximum value of
// the given expression possible for any
// unique pair from the given array
function findMaxValue(arr, N)
{
    // Sort the array in ascending order
    arr.sort(function(a,b){return a - b});
 
    // Evaluate the expression for
    // the two largest elements
    var maxm = compute(arr[N - 1], arr[N - 2]);
 
    // Evaluate the expression for
    // the two smallest elements
    maxm = Math.max(maxm, compute(arr[1], arr[0]));
 
    // Print the maximum
    document.write(maxm);
}
 
 
// Driver Code
var arr = [-4, -5, 0, 1, 3];
var N = arr.length;
findMaxValue(arr, N);
 
// This code is contributed by Shubhamsingh10
</script>
Output
21
Time Complexity: O(N*log(N))
Auxiliary Space: O(1)
 



My Personal Notes
arrow_drop_up
Previous
LTI (Larsen & Toubro Infotech) Interview Experience (On-Campus 2021)
Next

Reliance Jio Interview Experience (On-Campus)
Recommended Articles
Page :
Minimize count of array elements to be removed to maximize difference between any pair up to K
31, Jul 20
Maximize the minimum difference between any element pair by selecting K elements from given Array
15, Sep 21
Maximize product of array by replacing array elements with its sum or product with element from another array
27, Oct 20
Maximize array product by changing any array element arr[i] to (-1)*arr[i] - 1 any number of times
16, Feb 21
Pair with given product | Set 1 (Find if any pair exists)
03, Jun 16
Count of quadruples with product of a pair equal to the product of the remaining pair
08, Feb 21
Minimize product of first 2^K–1 Natural Numbers by swapping bits for any pair any number of times
29, Sep 21
Minimum product modulo N possible for any pair from a given range
30, Apr 21
Make all array elements even by replacing any pair of array elements with their sum
21, Dec 20
Smallest number that can replace all -1s in an array such that maximum absolute difference between any pair of adjacent elements is minimum
28, Jun 21
Minimize maximum difference between any pair of array elements by exactly one removal
11, Jun 21
Minimize the maximum difference of any pair by doubling odd elements and reducing even elements by half
20, Dec 20
Maximize sum possible from an array by jumps of length i + K * arr[i] from any ith index
17, Feb 21
Queries to check if any pair exists in an array having values at most equal to the given pair
04, Dec 20
Maximize sum of absolute difference between adjacent elements in Array with sum K
20, Jun 20
Maximize sum of squares of array elements possible by replacing pairs with their Bitwise AND and Bitwise OR
12, Oct 20
Maximize remainder of sum of a pair of array elements with different parity modulo K
18, Mar 21
Maximize maximum possible subarray sum of an array by swapping with elements from another array
03, Jan 21
Maximize sum of given array by rearranging array such that the difference between adjacent elements is atmost 1
25, Oct 20
Maximum value of (arr[i] * arr[j]) + (arr[j] - arr[i])) possible for any pair in an array
21, Apr 21
Number of indices pair such that element pair sum from first Array is greater than second Array
25, Mar 20
Possible values of Q such that, for any value of R, their product is equal to X times their sum
09, Aug 20
Maximize the product of sum and least power by choosing at most K elements from given value and power Arrays
28, Oct 21
Maximize difference between sum of prime and non-prime array elements by left shifting of digits minimum number of times
05, Mar 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
santhoshcharan
@santhoshcharan
Vote for difficulty
Current difficulty :
Expert





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!