# 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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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: 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++

 `// C++ implementation of the approach  ` `#include   ` `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 = 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 Code  ` `int` `main()  ` `{  ` `    ``int` `a=-2,b=-1,c=-4; ` `    ``cout << maximumResult(a, b, c);  ` ` `  `    ``return` `0;  ` `}  ` `// This code contributed by Nikhil  `

## Java

 `// 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= (a

## Python3

 `# Python3 implementation of the approach  ` ` `  `# Function to return the maximum result  ` `# 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 ``+` `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 Code  ` `if` `__name__ ``=``=` `"__main__"``:  ` ` `  `    ``a, b, c ``=` `-``2``, ``-``1``, ``-``4` `    ``print``(maximumResult(a, b, c))  ` ` `

## C#

 `// 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=(a

## PHP

 ` `

Output:

```12
```

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.