Maximize the value of the given expression

Given three non-zero integers a, b and c. The task is to find the maximum value possible by putting addition and multiplication signs between them in any order.
Note: Rearrangement of integers is allowed but addition and multiplication sign must be used once. Braces can also be placed between equations as per your need.

Examples:

Input: a = 2, b = 1, c = 4
Output: 12
(1 + 2) * 4 = 3 * 4 = 12

Input: a = 2, b = 2, c = 2
Output: 8
(2 + 2) * 2 = 4 * 2 = 8



Approach: To solve this problem one can opt the method of generating all the possibilities and calculate them to get the maximum value but this approach is not efficient. Take the advantage of given conditions that integers may got rearranged and mandatory use of each mathematical sign (+, *). There are total of four cases to solve which are listed below:

  1. All three integers are non-negative: For this simply add two smaller one and multiply their result by largest integer.
  2. One integer is negative and rest two positive : Multiply the both positive integer and add their result to negative integer.
  3. Two integers are negative and one is positive: As the product of two negative numbers is positive multiply both negative integers and then add their result to positive integer.
  4. All three are negative integers: Multiply the two smallest integers and add them to largest one.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the maximum result
int maximumResult(int a, int b, int c)
{
  
    // To store the count of negative integers
    int countOfNegative = 0;
  
    // Sum of all the three integers
    int sum = a + b + c;
  
    // Product of all the three integers
    int product = a * b * c;
  
    // To store the smallest and the largest
    // among all the three integers
    int largest = (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c);
    int smallest;
  
    // Calculate the count of negative integers
    if (a < 0)
        countOfNegative++;
    if (b < 0)
        countOfNegative++;
    if (c < 0)
        countOfNegative++;
  
    // Depending upon count of negatives
    switch (countOfNegative) {
  
    // When all three are positive integers
    case 0:
        return (sum - largest) * largest;
  
    // For single negative integer
    case 1:
        return (product / smallest) + smallest;
  
    // For two negative integers
    case 2:
        return (product / largest) + largest;
  
    // For three negative integers
    case 3:
        return (product / largest) + largest;
    }
}
  
// Driver Code
int main()
{
    int a = 2, b = 1, c = 4;
    cout << maximumResult(a, b, c);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
class GFG
      
// Function to return the maximum result
static int maximumResult(int a, int b, int c)
{
  
    // To store the count of negative integers
    int countOfNegative = 0;
  
    // Sum of all the three integers
    int sum = a + b + c;
  
    // Product of all the three integers
    int product = a * b * c;
  
    // To store the smallest and the largest
    // among all the three integers
    int largest = (a > b) ? ((a > c) ? a : c) : 
                            ((b > c) ? b : c);
    int smallest=1;
  
    // Calculate the count of negative integers
    if (a < 0)
        countOfNegative++;
    if (b < 0)
        countOfNegative++;
    if (c < 0)
        countOfNegative++;
  
    // Depending upon count of negatives
    switch (countOfNegative) 
    {
  
        // When all three are positive integers
        case 0:
            return (sum - largest) * largest;
  
        // For single negative integer
        case 1:
            return (product / smallest) + smallest;
  
        // For two negative integers
        case 2:
            return (product / largest) + largest;
  
        // For three negative integers
        case 3:
            return (product / largest) + largest;
    }
    return -1;
}
  
// Driver Code
public static void main(String[] args)
{
    int a = 2, b = 1, c = 4;
    System.out.print(maximumResult(a, b, c));
}
}
  
// This code contributed by Rajput-Ji

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach 
  
# Function to return the maximum result 
def maximumResult(a, b, c): 
  
    # To store the count of negative integers 
    countOfNegative = 0
  
    # Sum of all the three integers 
    Sum = a + b +
  
    # Product of all the three integers 
    product = a * b *
  
    # To store the smallest and the 
    # largest among all the three integers 
    largest = max(a, b, c)
    smallest = min(a, b, c) 
  
    # Calculate the count of negative integers 
    if a < 0:
        countOfNegative += 1
    if b < 0:
        countOfNegative += 1
    if c < 0:
        countOfNegative += 1
  
    # When all three are positive integers 
    if countOfNegative == 0
        return (Sum - largest) * largest 
  
    # For single negative integer 
    elif countOfNegative == 1
        return (product // smallest) + smallest 
  
    # For two negative integers 
    elif countOfNegative == 2
        return (product // largest) + largest 
  
    # For three negative integers 
    elif countOfNegative == 3
        return (product // largest) + largest 
  
# Driver Code 
if __name__ == "__main__":
  
    a, b, c = 2, 1, 4
    print(maximumResult(a, b, c)) 
  
# This code is contributed by Rituraj Jain

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using System;
  
class GFG
{
      
// Function to return the maximum result
static int maximumResult(int a, int b, int c)
{
  
    // To store the count of negative integers
    int countOfNegative = 0;
  
    // Sum of all the three integers
    int sum = a + b + c;
  
    // Product of all the three integers
    int product = a * b * c;
  
    // To store the smallest and the largest
    // among all the three integers
    int largest = (a > b) ? ((a > c) ? a : c) : 
                            ((b > c) ? b : c);
    int smallest=1;
  
    // Calculate the count of negative integers
    if (a < 0)
        countOfNegative++;
    if (b < 0)
        countOfNegative++;
    if (c < 0)
        countOfNegative++;
  
    // Depending upon count of negatives
    switch (countOfNegative) 
    {
  
        // When all three are positive integers
        case 0:
            return (sum - largest) * largest;
  
        // For single negative integer
        case 1:
            return (product / smallest) + smallest;
  
        // For two negative integers
        case 2:
            return (product / largest) + largest;
  
        // For three negative integers
        case 3:
            return (product / largest) + largest;
    }
    return -1;
}
  
// Driver Code
static void Main()
{
    int a = 2, b = 1, c = 4;
    Console.WriteLine(maximumResult(a, b, c));
}
}
  
// This code is contributed by mits

chevron_right


PHP

Output:

12


My Personal Notes arrow_drop_up

Discovering ways to develop a plane for soaring career goals

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.





Article Tags :
Practice Tags :


2


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.