Maximize the value of the given expression - GeeksforGeeks

07 Mar, 2022
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:  
All three integers are non-negative: For this simply add two smaller one and multiply their result by largest integer.One integer is negative and rest two positive : Multiply the both positive integer and add their result to negative integer.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.All three are negative integers: add the two largest integers and multiply them to smallest one. case 3-: (sum – smallest) * smallest
All three integers are non-negative: For this simply add two smaller one and multiply their result by largest integer.
One integer is negative and rest two positive : Multiply the both positive integer and add their result to negative integer.
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.
All three are negative integers: add the two largest integers and multiply them to smallest one. case 3-: (sum – smallest) * smallest
Below is the implementation of the above approach:  
C++
Java
Python3
C#
PHP
Javascript
// C++ implementation of the approach#include <bits/stdc++.h>using namespace std; // Function to return the maximum resultint 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 = max(a,max(b,c));    int smallest = min(a,min(b,c) );                // 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 (sum - smallest) * smallest;    }} // Driver Codeint main(){    int a=-2,b=-1,c=-4;    cout << maximumResult(a, b, c);     return 0;}// This code contributed by Nikhil
// Java implementation of the approachclass GFG{     // Function to return the maximum resultstatic 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= (a<b)?((a<c)? a : c):((b<c) ? b : c);    // 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 (sum - smallest) * smallest;    }    return -1;} // Driver Codepublic static void main(String[] args){    int a=-2,b=-1,c=-4;    System.out.print(maximumResult(a, b, c));}} // This code contributed by Nikhil
# Python3 implementation of the approach # Function to return the maximum result# Python3 implementation of the approach # Function to return the maximum resultdef maximumResult(a, b, c):     # To store the count of negative integers    countOfNegative = 0     # Sum of all the three integers    Sum = a + b + c     # Product of all the three integers    product = a * b * c     # 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 (Sum - smallest) * smallest # Driver Codeif __name__ == "__main__":     a, b, c = -2, -1, -4    print(maximumResult(a, b, c))
// C# implementation of the approachusing System; class GFG{     // Function to return the maximum resultstatic 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=(a<b)?((a<c)? a : c):((b<c) ? b : c);     // 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 (sum - smallest) * smallest;    }    return -1;} // Driver Codestatic void Main(){    int a = -2, b = -1, c = -4;    Console.WriteLine(maximumResult(a, b, c));}} // This code is contributed by mits & Nikhil
<?php// PHP implementation of the approach // Function to return the maximum resultfunction maximumResult($a, $b, $c){     // To store the count of    // negative integers    $countOfNegative = 0;     // Sum of all the three integers    $sum = $a + $b + $c;     // Product of all the three integers    $product = $a * $b * $c;     // 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++;    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 ($sum - $smallest) *                           $smallest;    }} // Driver Code$a = -2;$b = -1;$c = -4;echo maximumResult($a, $b, $c); // This code is contributed by ihritik?>
<script>// JavaScript implementation of the approach // Function to return the maximum resultfunction maximumResult(a, b, c){     // To store the count of negative integers    let countOfNegative = 0;     // Sum of all the three integers    let sum = a + b + c;     // Product of all the three integers    let product = a * b * c;         // To store the smallest and the largest    // among all the three integers    let largest = Math.max(a,Math.max(b,c));    let smallest = Math.min(a,Math.min(b,c) );             // 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 (sum - smallest) * smallest;    }} // Driver Code     let a = -2, b = -1, c = -4;    document.write(maximumResult(a, b, c)); // This code is contributed by Surbhi Tyagi.</script>
12
 
Time Complexity: O(1)
Auxiliary Space: O(1)
Mithun Kumar
rituraj_jain
Rajput-Ji
ihritik
Nikhil_Mishra
surbhityagi15
simranarora5sos
prophet1999
Greedy
Mathematical
Greedy
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Huffman Coding | Greedy Algo-3
Coin Change | DP-7
Activity Selection Problem | Greedy Algo-1
Fractional Knapsack Problem
Program for Shortest Job First (or SJF) CPU Scheduling | Set 1 (Non- preemptive)
Program for Fibonacci numbers
C++ Data Types
Set in C++ Standard Template Library (STL)
Coin Change | DP-7
Merge two sorted arrays