Related Articles
Largest triplet product in a stream
• Difficulty Level : Medium
• Last Updated : 27 Oct, 2020

Given a stream of integers represented as arr[]. For each index i from 0 to n-1, print the multiplication of largest, second largest, third largest element of the subarray arr[0…i]. If i < 2 print -1.

Examples:

```Input : arr[] = {1, 2, 3, 4, 5}
Output :-1
-1
6
24
60
Explanation : for i = 2 only three elements
are there {1, 2, 3} so answer is 6. For i = 3
largest three elements are {2, 3, 4} their
product is 2*3*4 = 24 ....so on

```

We will use priority queue here.

1. Insert arr[i] in the priority queue
2. As the top element in priority queue is largest so pop it and store it as x. Now the top element in the priority queue will be the second largest element in subarray arr[0…i] pop it and store as y. Now the top element is third largest element in subarray arr[0…i] so pop it and store it as z.
3. Print x*y*z
4. Reinsert x, y, z.

## C++

 `// C++ implementation of largest triplet` `// multiplication` `#include ` `using` `namespace` `std;`   `// Prints the product of three largest numbers` `// in subarray arr[0..i]` `void` `LargestTripletMultiplication(``int` `arr[], ``int` `n)` `{` `    ``// call a priority queue` `    ``priority_queue<``int``> q;`   `    ``// traversing the array` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// pushing arr[i] in the array` `        ``q.push(arr[i]);`   `        ``// if less than three elements are present` `        ``// in array print -1` `        ``if` `(q.size() < 3)` `            ``cout << ``"-1"` `<< endl;` `        ``else` `{` `            ``// pop three largest elements` `            ``int` `x = q.top();` `            ``q.pop();` `            ``int` `y = q.top();` `            ``q.pop();` `            ``int` `z = q.top();` `            ``q.pop();`   `            ``// Reinsert x, y, z in priority_queue` `            ``int` `ans = x * y * z;` `            ``cout << ans << endl;` `            ``q.push(x);` `            ``q.push(y);` `            ``q.push(z);` `        ``}` `    ``}` `    ``return``;` `}`   `// Driver Function` `int` `main()` `{` `    ``int` `arr[] = { 1, 2, 3, 4, 5 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``LargestTripletMultiplication(arr, n);` `    ``return` `0;` `}`

## Java

 `// Java implementation of largest triplet` `// multiplication` `import` `java.util.Collections;` `import` `java.util.PriorityQueue;`   `class` `GFG {`   `    ``// Prints the product of three largest numbers` `    ``// in subarray arr[0..i]` `    ``static` `void` `LargestTripletMultiplication(``int` `arr[], ``int` `n)` `    ``{` `        ``// call a priority queue` `        ``PriorityQueue q = ``new` `PriorityQueue(Collections.reverseOrder());`   `        ``// traversing the array` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// pushing arr[i] in array` `            ``q.add(arr[i]);`   `            ``// if less than three elements are present` `            ``// in array print -1` `            ``if` `(q.size() < ``3``)` `                ``System.out.println(``"-1"``);` `            ``else` `{` `                ``// pop three largest elements` `                ``int` `x = q.poll();` `                ``int` `y = q.poll();` `                ``int` `z = q.poll();`   `                ``// Reinsert x, y, z in priority_queue` `                ``int` `ans = x * y * z;` `                ``System.out.println(ans);` `                ``q.add(x);` `                ``q.add(y);` `                ``q.add(z);` `            ``}` `        ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = { ``1``, ``2``, ``3``, ``4``, ``5` `};` `        ``int` `n = arr.length;` `        ``LargestTripletMultiplication(arr, n);` `    ``}` `}`   `// This code is contributed by shubham96301`

## Python3

 `# Python3 implementation of largest triplet` `# multiplication` `from` `queue ``import` `PriorityQueue`   `# Prints the product of three largest ` `# numbers in subarray arr[0..i]` `def` `LargestTripletMultiplication(arr, n):` `    `  `    ``# Call a priority queue` `    ``q ``=` `PriorityQueue()`   `    ``# Traversing the array` `    ``for` `i ``in` `range``(n): ` `        `  `        ``# Pushing -arr[i] in array` `        ``# to get max PriorityQueue` `        ``q.put(``-``arr[i])`   `        ``# If less than three elements ` `        ``# are present in array print -1` `        ``if` `(q.qsize() < ``3``):` `            ``print``(``-``1``)` `        ``else``:` `            `  `            ``# pop three largest elements` `            ``x ``=` `q.get()` `            ``y ``=` `q.get()` `            ``z ``=` `q.get()`   `            ``# Reinsert x, y, z in` `            ``# priority_queue` `            ``ans ``=` `x ``*` `y ``*` `z` `            `  `            ``print``(``-``ans)` `            `  `            ``q.put(x);` `            ``q.put(y);` `            ``q.put(z);`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` ` `  `    ``arr ``=` `[ ``1``, ``2``, ``3``, ``4``, ``5` `]` `    ``n ``=` `len``(arr)` `    `  `    ``LargestTripletMultiplication(arr, n)` `    `  `# This code is contributed by math_lover`

Output:

```-1
-1
6
24
60

```

This article is contributed by Ayush Jha. 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.