Given an array arr[] of N integers, where N > 2, the task is to find the second largest product pair from the given array.
Examples:
Input: arr[] = {10, 20, 12, 40, 50}
Output: 20 50
Explanation:
A pair of array elements = [(10, 20), (10, 12), (10, 40), (10, 50), (20, 12), (20, 40), (20, 50), (12, 40), (12, 50), (40, 50)]
If do product of each pair will get the largest pair as (40, 50) and second largest pair (20, 50)
Input: arr[] = {5, 2, 67, 45, 160, 78}
Output: 67 160
Naive Approach: The naive approach is to generate all possible pairs from the given array and insert the product with the pair into the set of pairs. After inserting all the pair products in the set print the second last product of the set. Below are the steps:
- Make a set of pairs and their products by the given array.
- Insert all the pairs in vector of pairs.
- If vector size is 1 then print this pair otherwise print the pair at (total vector size – 2)th position of vector.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void secondLargerstPair(int arr[], int N)
{
if (N < 3)
return;
set<pair<int, pair<int, int> > > s;
vector<pair<int, int> > v;
for (int i = 0; i < N; ++i) {
for (int j = i + 1; j < N; ++j) {
s.insert(make_pair(arr[i] * arr[j],
make_pair(arr[i],
arr[j])));
}
}
for (auto i : s) {
v.push_back(
make_pair((i.second).first,
(i.second).second));
}
int vsize = v.size();
cout << v[vsize - 2].first << " "
<< v[vsize - 2].second << endl;
}
int main()
{
int arr[] = { 5, 2, 67, 45, 160, 78 };
int N = sizeof(arr) / sizeof(arr[0]);
secondLargerstPair(arr, N);
return 0;
}
|
Java
import java.util.*;
public class GFG
{
static class Tuple<K,V>{
K key;
V val;
Tuple(K k, V v){
key = k;
val = v;
}
}
static void secondLargerstPair(int[] arr, int N)
{
if (N < 3)
return;
TreeSet<Tuple<Integer, Tuple<Integer, Integer>>> s = new TreeSet<>((t1,t2)->{
int a1 = t1.key, a2 = t1.val.key, a3 = t1.val.val;
int b1 = t2.key, b2 = t2.val.key, b3 = t2.val.val;
if (a1 < b1)
return -1;
if (a1 > b1)
return 1;
if (a2 < b2)
return -1;
if (a2 > b2)
return 1;
if (a3 < b3)
return -1;
if (a3 > b3)
return 1;
return 0;
});
List<Tuple<Integer, Integer> > v = new ArrayList<>();
for (int i = 0; i < N; ++i) {
for (int j = i + 1; j < N; ++j) {
s.add(new Tuple(arr[i] * arr[j], new Tuple(arr[i],arr[j])));
}
}
for(var i : s){
v.add(new Tuple((i.val).key,(i.val).val));
}
Collections.sort(v,(a,b)->a.key - b.key);
int vsize = v.size();
System.out.println(v.get(vsize - 2).key + " " + v.get(vsize - 2).val);
}
public static void main(String[] args)
{
int[] arr = { 5, 2, 67, 45, 160, 78 };
int N = arr.length;
secondLargerstPair(arr, N);
}
}
|
Python3
def secondLargerstPair(arr, N):
if (N < 3):
return;
s = set()
v = [];
for i in range(N):
for j in range(i + 1, N):
s.add((arr[i] * arr[j], (arr[i], arr[j])))
for i in sorted(s):
v.append((i[1][0], i[1][1]));
vsize = len(v)
print(v[vsize - 2][0], v[vsize - 2][1]);
arr = [5, 2, 67, 45, 160, 78];
N = len(arr)
secondLargerstPair(arr, N);
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static void secondLargerstPair(int[] arr, int N)
{
if (N < 3)
return;
HashSet<Tuple<int, Tuple<int, int> > > s = new HashSet<Tuple<int, Tuple<int, int> > >();
List<Tuple<int, int> > v = new List<Tuple<int, int> >();
for (int i = 0; i < N; ++i) {
for (int j = i + 1; j < N; ++j) {
s.Add(Tuple.Create(arr[i] * arr[j], Tuple.Create(arr[i],
arr[j])));
}
}
foreach (var i in s) {
v.Add(
Tuple.Create((i.Item2).Item1,
(i.Item2).Item2));
}
v.Sort();
int vsize = v.Count;
Console.WriteLine(v[vsize - 2].Item1 + " "
+ v[vsize - 2].Item2);
}
public static void Main(string[] args)
{
int[] arr = { 5, 2, 67, 45, 160, 78 };
int N = arr.Length;
secondLargerstPair(arr, N);
}
}
|
Javascript
function secondLargerstPair(arr, N)
{
if (N < 3)
return;
let s = new Set()
let v = [];
for (var i = 0; i < N; i++)
for (var j = i + 1; j < N; j++)
s.add([arr[i] * arr[j], arr[i], arr[j]].join('#'))
s = Array.from(s)
s.sort(function(a, b)
{
a = a.split('#')
b = b.split('#')
let a1 = parseInt(a[0]), a2 = parseInt(a[1]), a3 = parseInt(a[2])
let b1 = parseInt(b[0]), b2 = parseInt(b[1]), b3 = parseInt(b[2])
if (a1 < b1)
return -1
if (a1 > b1)
return 1
if (a2 < b2)
return -1
if (a2 > b2)
return 1
if (a3 < b3)
return -1
if (a3 > b3)
return 1
return 0
})
for (let i of s)
{
i = i.split('#')
v.push([i[1], i[2]])
}
let vsize = v.length
console.log(v[vsize - 2].join(' '))
}
let arr = [5, 2, 67, 45, 160, 78];
let N = arr.length
secondLargerstPair(arr, N);
|
Time Complexity: O(N2)
Auxiliary Space: O(N), since n extra space has been taken.
Better Solution: A better solution is to traverse all the pairs of the array and while traversing store the largest and second-largest product pairs. After traversal print the pairs with second-largest pairs stored.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void maxProduct(int arr[], int N)
{
if (N < 3) {
return;
}
int a = arr[0], b = arr[1];
int c = 0, d = 0;
for (int i = 0; i < N; i++)
for (int j = i + 1; j < N; j++) {
if (arr[i] * arr[j] > a * b) {
c = a, d = b;
a = arr[i], b = arr[j];
}
if (arr[i] * arr[j] < a * b
&& arr[i] * arr[j] > c * d)
c = arr[i], d = arr[j];
}
cout << c << " " << d;
}
int main()
{
int arr[] = { 5, 2, 67, 45, 160, 78 };
int N = sizeof(arr) / sizeof(arr[0]);
maxProduct(arr, N);
return 0;
}
|
Java
class GFG{
static void maxProduct(int arr[], int N)
{
if (N < 3)
{
return;
}
int a = arr[0], b = arr[1];
int c = 0, d = 0;
for (int i = 0; i < N; i++)
for (int j = i + 1; j < N-1; j++)
{
if (arr[i] * arr[j] > a * b)
{
c = a;
d = b;
a = arr[i];
b = arr[j];
}
if (arr[i] * arr[j] < a * b &&
arr[i] * arr[j] > c * d)
c = arr[i];
d = arr[j];
}
System.out.println(c + " " + d);
}
public static void main(String[] args)
{
int arr[] = { 5, 2, 67, 45, 160, 78 };
int N = arr.length;
maxProduct(arr, N);
}
}
|
Python3
def maxProduct(arr, N):
if (N < 3):
return;
a = arr[0]; b = arr[1];
c = 0; d = 0;
for i in range(0, N, 1):
for j in range(i + 1, N - 1, 1):
if (arr[i] * arr[j] > a * b):
c = a;
d = b;
a = arr[i];
b = arr[j];
if (arr[i] * arr[j] < a * b and
arr[i] * arr[j] > c * d):
c = arr[i];
d = arr[j];
print(c, " ", d);
if __name__ == '__main__':
arr = [ 5, 2, 67, 45, 160, 78];
N = len(arr);
maxProduct(arr, N);
|
C#
using System;
class GFG{
static void maxProduct(int []arr, int N)
{
if (N < 3)
{
return;
}
int a = arr[0], b = arr[1];
int c = 0, d = 0;
for(int i = 0; i < N; i++)
for(int j = i + 1; j < N - 1; j++)
{
if (arr[i] * arr[j] > a * b)
{
c = a;
d = b;
a = arr[i];
b = arr[j];
}
if (arr[i] * arr[j] < a * b &&
arr[i] * arr[j] > c * d)
c = arr[i];
d = arr[j];
}
Console.WriteLine(c + " " + d);
}
public static void Main(String[] args)
{
int []arr = { 5, 2, 67, 45, 160, 78 };
int N = arr.Length;
maxProduct(arr, N);
}
}
|
Javascript
<script>
function maxProduct(arr, N)
{
if (N < 3) {
return;
}
let a = arr[0], b = arr[1];
let c = 0, d = 0;
for (let i = 0; i < N; i++)
for (let j = i + 1; j < N; j++) {
if (arr[i] * arr[j] > a * b) {
c = a, d = b;
a = arr[i], b = arr[j];
}
if (arr[i] * arr[j] < a * b
&& arr[i] * arr[j] > c * d)
c = arr[i], d = arr[j];
}
document.write(c + " " + d);
}
let arr = [ 5, 2, 67, 45, 160, 78 ];
let N = arr.length;
maxProduct(arr, N);
</script>
|
Time Complexity: O(N2)
Auxiliary Space: O(N)
Efficient Approach:
- Sort the array.
- Find first and third smallest elements for handling negative numbers.
- Find the first and third largest elements for handling positive numbers.
- Compare the product of the smallest pair and largest pair.
- Return the largest one of them.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void maxProduct(int arr[], int N)
{
if (N < 3) {
return;
}
sort(arr, arr + N);
int smallest1 = arr[0];
int smallest3 = arr[2];
int largest1 = arr[N - 1];
int largest3 = arr[N - 3];
if (smallest1 * smallest3
>= largest1 * largest3) {
cout << smallest1 << " " << smallest3;
}
else {
cout << largest1 << " " << largest3;
}
}
int main()
{
int arr[] = { 5, 2, 67, 45, 160, 78 };
int N = sizeof(arr) / sizeof(arr[0]);
maxProduct(arr, N);
return 0;
}
|
Java
import java.util.*;
class GFG{
static void maxProduct(int arr[], int N)
{
if (N < 3)
{
return;
}
Arrays.sort(arr);
int smallest1 = arr[0];
int smallest3 = arr[2];
int largest1 = arr[N - 1];
int largest3 = arr[N - 3];
if (smallest1 * smallest3 >=
largest1 * largest3)
{
System.out.print(smallest1 + " " +
smallest3);
}
else
{
System.out.print(largest1 + " " +
largest3);
}
}
public static void main(String[] args)
{
int arr[] = { 5, 2, 67, 45, 160, 78 };
int N = arr.length;
maxProduct(arr, N);
}
}
|
Python3
def maxProduct(arr, N):
if (N < 3):
return;
arr.sort();
smallest1 = arr[0];
smallest3 = arr[2];
largest1 = arr[N - 1];
largest3 = arr[N - 3];
if (smallest1 *
smallest3 >= largest1 *
largest3):
print(smallest1 , " " , smallest3);
else:
print(largest1 , " " , largest3);
if __name__ == '__main__':
arr = [5, 2, 67, 45, 160, 78];
N = len(arr);
maxProduct(arr, N);
|
C#
using System;
class GFG{
static void maxProduct(int []arr, int N)
{
if (N < 3)
{
return;
}
Array.Sort(arr);
int smallest1 = arr[0];
int smallest3 = arr[2];
int largest1 = arr[N - 1];
int largest3 = arr[N - 3];
if (smallest1 * smallest3 >=
largest1 * largest3)
{
Console.Write(smallest1 + " " +
smallest3);
}
else
{
Console.Write(largest1 + " " +
largest3);
}
}
public static void Main(String[] args)
{
int []arr = { 5, 2, 67, 45, 160, 78 };
int N = arr.Length;
maxProduct(arr, N);
}
}
|
Javascript
<script>
function maxProduct(arr, N)
{
if (N < 3)
{
return;
}
arr.sort((a, b) => a - b)
let smallest1 = arr[0];
let smallest3 = arr[2];
let largest1 = arr[N - 1];
let largest3 = arr[N - 3];
if (smallest1 * smallest3 >=
largest1 * largest3)
{
document.write(smallest1 + " " +
smallest3);
}
else
{
document.write(largest1 + " " +
largest3);
}
}
let arr = [ 5, 2, 67, 45, 160, 78 ];
let N = arr.length;
maxProduct(arr, N);
</script>
|
Time Complexity: O(N*log N)
Auxiliary Space: O(1), since no extra space has been taken.