# Maximum Possible Product in Array after performing given Operations

Given an array with size N. You are allowed to perform two types of operations on the given array as described below:

1. Choose some position i and j, such that (i is not equlas to j), replace the value of a[j] with a[i]*a[j] and remove the number from the ith cell.
2. Choose some position i and remove the number from the ith cell (This operation can be performed at-most once and at any point of time, not necessarily in the beginning).

The task is to perform exactly N-1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it, print the sequence of operations which leads to this maximum number.

The output should contain exactly N-1 lines:

• If the operation is of the first type then print 1 i j.
• If the operation is of the second type then print 2 i.

Note: The array is considered to have 1-based indexing.

Examples:

```Input : a[] = { 5, -2, 0, 1, -3 }
Output : 2 3
1 1 2
1 2 4
1 4 5
Explanation:
Step 1: a[3] is removed.
Step 2: a[2] = a[2]*a[1] = -10; a[1] is removed.
Step 3: a[4] = a[4]*a[2] = -10; a[2] is removed.
Step 4: a[5] = a[5]*a[4] = 30; a[4] is removed.
So, the maximum product is 30.

Input : a[] = { 0, 0, 0, 0 }
Output : 1 1 2
1 2 3
1 3 4
```

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

Approach : There are several cases in the problem. Let the number of zeroes in the array be cntZero and the number of negative elements be cntNeg. Also let maxNeg be the position of the maximum negative element in the array, or -1 if there are no negative elements in the array.

Let the answer part be the product of all the numbers which will be in the answer and the removed part be the product of all the numbers which will be removed by the second type of operation.

The cases are as follows:

1. The first case is when cntZero=0 and cntNeg=0. Then the answer part is the product of all the numbers in the array. The removed part is empty.
2. The second case is when cntNeg is odd. Then the answer part is the product of all the numbers in the array except all zeroes and a[maxNeg]. The removed part is the product of all zeroes and a[maxNeg].
3. The third case is when cntNeg is even. Then the answer part is the product of all the numbers in the array except all zeroes. The removed part is the product of all zeroes in the array (be careful in case cntNeg=0 and cntZero=n).

Below is the implementation of the above idea:

## C++

 `// CPP program for maximum possible product ` `// with given array of numbers ` `#include ` `using` `namespace` `std; ` ` `  `// Function that prints operations in each step ` `void` `MaximumProduct(``int` `a[], ``int` `n) ` `{ ` `    ``int` `cntneg = 0; ` `    ``int` `cntzero = 0; ` `     `  `    ``int` `used[n] = { 0 }; ` `    ``int` `pos = -1; ` ` `  `    ``// count number of zeros and negative numbers ` `    ``for` `(``int` `i = 0; i < n; ++i) { ` `        ``if` `(a[i] == 0) { ` `            ``used[i] = 1; ` `            ``cntzero++; ` `        ``} ` `         `  `        ``if` `(a[i] < 0) { ` `            ``cntneg++; ` `             `  `            ``// To get negative number which  ` `            ``// is nearest to zero, that is maximum  ` `            ``// negative number  ` `            ``if` `(pos == -1 || ``abs``(a[pos]) > ``abs``(a[i])) ` `                ``pos = i; ` `        ``} ` `    ``} ` `     `  `    ``// if number of negative number are odd then ` `    ``// remove negative number at position pos ` `    ``if` `(cntneg % 2 == 1) ` `        ``used[pos] = 1; ` ` `  `    ``// initial condition ` `    ``if` `(cntzero == n || (cntzero == n - 1 &&  ` `                                    ``cntneg == 1)) { ` `        ``for` `(``int` `i = 0; i < n - 1; ++i) ` `            ``cout << 1 << ``" "` `<< i + 1 << ``" "`  `                                ``<< i + 2 << endl; ` `        ``return``; ` `    ``} ` ` `  `    ``int` `lst = -1; ` `    ``for` `(``int` `i = 0; i < n; ++i) { ` `        ``if` `(used[i]) { ` `            ``if` `(lst != -1) ` `                ``cout << 1 << ``" "` `<< lst + 1 << ``" "`  `                                ``<< i + 1 << endl; ` `            ``lst = i; ` `        ``} ` `    ``} ` `     `  `    ``// perform second type operation ` `    ``if` `(lst != -1) ` `        ``cout << 2 << ``" "` `<< lst + 1 << endl; ` ` `  `    ``lst = -1; ` `     `  `    ``// for reamining numbers ` `    ``for` `(``int` `i = 0; i < n; ++i) { ` `        ``// if it is not removed yet ` `        ``if` `(!used[i]) { ` `            ``if` `(lst != -1) ` `                ``cout << 1 << ``" "` `<< lst + 1 << ``" "`  `                                    ``<< i + 1 << endl; ` `            ``lst = i; ` `        ``} ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `a[] = { 5, -2, 0, 1, -3 }; ` ` `  `    ``int` `n = ``sizeof``(a) / ``sizeof``(a[0]); ` ` `  `    ``MaximumProduct(a, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program for maximum possible product ` `// with given array of numbers ` `class` `GFG { ` ` `  `// Function that prints operations in each step ` `static` `void` `MaximumProduct(``int` `a[], ``int` `n) { ` `    ``int` `cntneg = ``0``; ` `    ``int` `cntzero = ``0``; ` ` `  `    ``int` `used[] = ``new` `int``[n]; ` `    ``int` `pos = -``1``; ` `     `  `    ``// count number of zeros and negative numbers ` `    ``for` `(``int` `i = ``0``; i < n; ++i) { ` `        ``if` `(a[i] == ``0``) ` `        ``{ ` `            ``used[i] = ``1``; ` `            ``cntzero++; ` `             `  `        ``} ` `         `  `        ``if` `(a[i] < ``0``) { ` `            ``cntneg++; ` `             `  `            ``// To get negative number which  ` `            ``// is nearest to zero, that is maximum  ` `            ``// negative number  ` `            ``if` `(pos == -``1` `|| Math.abs(a[pos]) > Math.abs(a[i])) { ` `                ``pos = i; ` `                 `  `            ``} ` `             `  `        ``} ` `         `  `    ``} ` `     `  `    ``// if number of negative number are odd then ` `    ``// remove negative number at position pos ` `    ``if` `(cntneg % ``2` `== ``1``) { ` `        ``used[pos] = ``1``; ` `         `  `    ``} ` `     `  `    ``// initial condition ` `    ``if` `(cntzero == n || (cntzero == n - ``1` `&& cntneg == ``1``)) ` `    ``{               ` `        ``for` `(``int` `i = ``0``; i < n - ``1``; ++i) { ` `            ``System.out.println(``1` `+ ``" "` `+ (i + ``1``) + ``" "` `                        ``+ (i + ``2``)); ` `             `  `        ``} ` `        ``return``; ` `         `  `    ``} ` `     `  `    ``int` `lst = -``1``; ` `    ``for` `(``int` `i = ``0``; i < n; ++i) { ` `        ``if` `(used[i] == ``1``) { ` `            ``if` `(lst != -``1``) { ` `                ``System.out.println(``1` `+ ``" "` `+ (lst + ``1``) + ``" "` `                            ``+ (i + ``1``)); ` `                 `  `            ``} ` `            ``lst = i; ` `             `  `        ``} ` `         `  `    ``} ` `     `  `    ``// perform second type operations ` `    ``if` `(lst != -``1``) { ` `        ``System.out.println(``2` `+ ``" "` `+ (lst + ``1``)); ` `         `  `    ``} ` `    ``lst = -``1``; ` `    ``// for reamining numbers ` `    ``for` `(``int` `i = ``0``; i < n; ++i) ` `    ``{ ` `        ``// if it is not removed yet ` `        ``if` `(used[i] != ``1``)  ` `        ``{ ` `            ``if` `(lst != -``1``)  ` `            ``{ ` `                ``System.out.println(``1` `+ ``" "` `+ (lst + ``1``) + ``" "` `                            ``+ (i + ``1``)); ` `                 `  `            ``} ` `            ``lst = i; ` `        ``} ` `    ``} ` `     `  `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `a[] = {``5``, -``2``, ``0``, ``1``, -``3``}; ` `    ``int` `n = a.length; ` `    ``MaximumProduct(a, n); ` `     `  `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

## Python3

 `# Python3 program for maximum possible product ` `# with given array of numbers ` ` `  `# Function that prints operations  ` `# in each step ` `def` `MaximumProduct(a, n): ` `    ``cntneg ``=` `0` `    ``cntzero ``=` `0` `     `  `    ``used ``=` `[``0``] ``*` `n ` `    ``pos ``=` `-``1` ` `  `    ``# count number of zeros and  ` `    ``# negative numbers ` `    ``for` `i ``in` `range``(n): ` `        ``if` `(a[i] ``=``=` `0``) : ` `            ``used[i] ``=` `1` `            ``cntzero ``+``=` `1` `         `  `        ``if` `(a[i] < ``0``): ` `            ``cntneg ``+``=` `1` `             `  `            ``# To get negative number which  ` `            ``# is nearest to zero, that is maximum  ` `            ``# negative number  ` `            ``if` `(pos ``=``=` `-``1` `or` `abs``(a[pos]) > ``abs``(a[i])): ` `                ``pos ``=` `i ` `     `  `    ``# if number of negative number are odd then ` `    ``# remove negative number at position pos ` `    ``if` `(cntneg ``%` `2` `=``=` `1``): ` `        ``used[pos] ``=` `1` ` `  `    ``# initial condition ` `    ``if` `(cntzero ``=``=` `n ``or` `(cntzero ``=``=` `n ``-` `1` `and` `                         ``cntneg ``=``=` `1``)): ` `        ``for` `i ``in` `range``(n ``-` `1``): ` `            ``print` `(``1``, ``" "``, i ``+` `1``, ``" "``, i ``+` `2``) ` `        ``return` ` `  `    ``lst ``=` `-``1` `    ``for` `i ``in` `range``(n) : ` `        ``if` `(used[i]) : ` `            ``if` `(lst !``=` `-``1``): ` `                ``print` `(``1``, ``" "``, lst ``+` `1``, ``" "``, i ``+` `1``) ` `            ``lst ``=` `i ` `     `  `    ``# perform second type operation ` `    ``if` `(lst !``=` `-``1``): ` `        ``print` `(``2``, ``" "``, lst ``+` `1``) ` ` `  `    ``lst ``=` `-``1` `     `  `    ``# for reamining numbers ` `    ``for` `i ``in` `range``( n) : ` `         `  `        ``# if it is not removed yet ` `        ``if` `(``not` `used[i]) : ` `            ``if` `(lst !``=` `-``1``): ` `                ``print` `(``1``, ``" "``, lst ``+` `1``, ``" "``, i ``+` `1``) ` `            ``lst ``=` `i ` `     `  `# Driver code ` `if` `__name__ ``=``=` `"__main__"``: ` `    ``a ``=` `[ ``5``, ``-``2``, ``0``, ``1``, ``-``3` `] ` ` `  `    ``n ``=` `len``(a) ` ` `  `    ``MaximumProduct(a, n) ` ` `  `# This code is contributed by ita_c `

## C#

 `// C# program for maximum possible product ` `// with given array of numbers ` `using` `System; ` ` `  `class` `GFG ` `{ ` `     `  `// Function that prints  ` `// operations in each step ` `static` `void` `MaximumProduct(``int` `[]a, ``int` `n)  ` `{ ` `    ``int` `cntneg = 0; ` `    ``int` `cntzero = 0; ` ` `  `    ``int` `[]used = ``new` `int``[n]; ` `    ``int` `pos = -1; ` `     `  `    ``// count number of zeros  ` `    ``// and negative numbers ` `    ``for` `(``int` `i = 0; i < n; ++i) ` `    ``{ ` `        ``if` `(a[i] == 0) ` `        ``{ ` `            ``used[i] = 1; ` `            ``cntzero++; ` `             `  `        ``} ` `         `  `        ``if` `(a[i] < 0)  ` `        ``{ ` `            ``cntneg++; ` `             `  `            ``// To get negative number which  ` `            ``// is nearest to zero, that is ` `            ``//  maximum negative number  ` `            ``if` `(pos == -1 || Math.Abs(a[pos]) >  ` `                                ``Math.Abs(a[i])) ` `            ``{ ` `                ``pos = i; ` `                 `  `            ``} ` `             `  `        ``} ` `         `  `    ``} ` `     `  `    ``// if number of negative number are odd then ` `    ``// remove negative number at position pos ` `    ``if` `(cntneg % 2 == 1)  ` `    ``{ ` `        ``used[pos] = 1; ` `         `  `    ``} ` `     `  `    ``// initial condition ` `    ``if` `(cntzero == n || (cntzero == n - 1 && ` `                                ``cntneg == 1)) ` `    ``{          ` `        ``for` `(``int` `i = 0; i < n - 1; ++i)  ` `        ``{ ` `            ``Console.WriteLine(1 + ``" "` `+ (i + 1) + ``" "` `                        ``+ (i + 2)); ` `        ``} ` `        ``return``; ` `         `  `    ``} ` `     `  `    ``int` `lst = -1; ` `    ``for` `(``int` `i = 0; i < n; ++i) ` `    ``{ ` `        ``if` `(used[i] == 1)  ` `        ``{ ` `            ``if` `(lst != -1) ` `            ``{ ` `                ``Console.WriteLine(1 + ``" "` `+ (lst + 1) + ``" "` `                            ``+ (i + 1)); ` `            ``} ` `            ``lst = i; ` `             `  `        ``} ` `         `  `    ``} ` `     `  `    ``// perform second type operations ` `    ``if` `(lst != -1) ` `    ``{ ` `        ``Console.WriteLine(2 + ``" "` `+ (lst + 1)); ` `         `  `    ``} ` `    ``lst = -1; ` `     `  `    ``// for reamining numbers ` `    ``for` `(``int` `i = 0; i < n; ++i) ` `    ``{ ` `        ``// if it is not removed yet ` `        ``if` `(used[i] != 1)  ` `        ``{ ` `            ``if` `(lst != -1)  ` `            ``{ ` `                ``Console.WriteLine(1 + ``" "` `+ (lst + 1) + ``" "` `                            ``+ (i + 1)); ` `            ``} ` `            ``lst = i; ` `        ``} ` `    ``} ` `     `  `} ` ` `  `    ``// Driver code ` `    ``static` `public` `void` `Main () ` `    ``{ ` `        ``int` `[]a = {5, -2, 0, 1, -3}; ` `        ``int` `n = a.Length; ` `        ``MaximumProduct(a, n); ` `    ``} ` `} ` ` `  `// This code is contributed by ajit `

Output:

```2 3
1 1 2
1 2 4
1 4 5
```

Time Complexity:O(n)

My Personal Notes arrow_drop_up

pawanasipugmailcom

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.
{"found_math": false, "script_math_tex": 0, "script_math_asciimath": 0, "math_annotations": 0, "math_alttext": 0, "mathml": 0, "mathjax_tag": 0, "mathjax_inline_tex": 0, "mathjax_display_tex": 0, "mathjax_asciimath": 0, "img_math": 0, "codecogs_latex": 0, "wp_latex": 0, "mimetex.cgi": 0, "/images/math/codecogs": 0, "mathtex.cgi": 0, "katex": 0, "math-container": 0, "wp-katex-eq": 0, "align": 0, "equation": 0, "x-ck12": 0, "texerror": 0, "url": "https://www.geeksforgeeks.org/maximum-possible-product-in-array-after-performing-given-operations/", "fetch_time": 1579790593000000000, "content_mime_type": "text/html", "warc_filename": "crawl-data/CC-MAIN-2020-05/segments/1579250610919.33/warc/CC-MAIN-20200123131001-20200123160001-00130.warc.gz", "warc_record_offset": 884019783, "warc_record_length": 32131, "token_count": 5054, "char_count": 13978, "score": 3.671875, "int_score": 4, "crawl": "CC-MAIN-2020-05", "snapshot_type": "longest", "language": "en", "language_score": 0.8898292183876038, "file_path": "/sailhome/yjruan/project/latent-lm/data/processed/finemath-4plus/finemath-4plus/train-00058-of-00064.parquet"}