Product of all the pairs from the given array
Last Updated :
15 Feb, 2023
Given an array arr[] of N integers, the task is to find the product of all the pairs possible from the given array such as:
- (arr[i], arr[i]) is also considered as a valid pair.
- (arr[i], arr[j]) and (arr[j], arr[i]) are considered as two different pairs.
Print the resultant answer modulus 10^9+7.
Examples:
Input: arr[] = {1, 2}
Output: 16
Explanation:
All valid pairs are (1, 1), (1, 2), (2, 1) and (2, 2).
Hence, 1 * 1 * 1 * 2 * 2 * 1 * 2 * 2 = 16
Input: arr[] = {1, 2, 3}
Output: 46656
Explanation:
All valid pairs are (1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2) and (3, 3).
Hence the product is 1*1*1**2*1*3*2*1*2*2*2*3*3*1*3*2*3*3 = 46656
Naive Approach:
- Initialize the product variable.
- Run a two loops to find all the possible pairs.
- Calculate of the elements of each pair.
- Return the final product.
Below is the implementation of the above approach:
C++
// C++ implementation to find the
// product of all the pairs from
// the given array
#include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
// Function to return the product of
// the elements of all possible pairs
// from the array
int productPairs(int arr[], int n)
{
// To store the required product
int product = 1;
// Nested loop to calculate all
// possible pairs
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
// Multiply the product of
// the elements of the
// current pair
product *= (arr[i] % mod
* arr[j] % mod)
% mod;
product = product % mod;
}
}
// Return the final result
return product % mod;
}
// Driver code
int main()
{
int arr[] = { 1, 2, 3 };
int n = sizeof(arr) / sizeof(arr[0]);
cout << productPairs(arr, n);
return 0;
}
// Java implementation to find the
// product of all the pairs from
// the given array
import java.util.*;
class GFG{
static final int mod = 1000000007;
// Function to return the product of
// the elements of all possible pairs
// from the array
static int productPairs(int arr[], int n)
{
// To store the required product
int product = 1;
// Nested loop to calculate all
// possible pairs
for(int i = 0; i < n; i++)
{
for(int j = 0; j < n; j++)
{
// Multiply the product
// of the elements of the
// current pair
product *= (arr[i] % mod *
arr[j] % mod) % mod;
product = product % mod;
}
}
// Return the final result
return product % mod;
}
// Driver code
public static void main(String[] args)
{
int arr[] = { 1, 2, 3 };
int n = arr.length;
System.out.print(productPairs(arr, n));
}
}
// This code is contributed by sapnasingh4991
# Python3 implementation to find the
# product of all the pairs from
# the given array
mod = 1000000007;
# Function to return the product of
# the elements of all possible pairs
# from the array
def productPairs(arr, n):
# To store the required product
product = 1;
# Nested loop to calculate all
# possible pairs
for i in range(n):
for j in range(n):
# Multiply the product
# of the elements of the
# current pair
product *= (arr[i] % mod *
arr[j] % mod) % mod;
product = product % mod;
# Return the final result
return product % mod;
# Driver code
if __name__ == '__main__':
arr = [1, 2, 3];
n = len(arr);
print(productPairs(arr, n));
# This code is contributed by 29AjayKumar
// C# implementation to find the
// product of all the pairs from
// the given array
using System;
class GFG{
static readonly int mod = 1000000007;
// Function to return the product of
// the elements of all possible pairs
// from the array
static int productPairs(int []arr, int n)
{
// To store the required product
int product = 1;
// Nested loop to calculate all
// possible pairs
for(int i = 0; i < n; i++)
{
for(int j = 0; j < n; j++)
{
// Multiply the product
// of the elements of the
// current pair
product *= (arr[i] % mod *
arr[j] % mod) % mod;
product = product % mod;
}
}
// Return the readonly result
return product % mod;
}
// Driver code
public static void Main(String[] args)
{
int []arr = { 1, 2, 3 };
int n = arr.Length;
Console.Write(productPairs(arr, n));
}
}
// This code is contributed by sapnasingh4991
<script>
//Javascript implementation to find the
// product of all the pairs from
// the given array
mod = 1000000007
// Function to return the product of
// the elements of all possible pairs
// from the array
function productPairs(arr, n)
{
// To store the required product
let product = 1;
// Nested loop to calculate all
// possible pairs
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
// Multiply the product of
// the elements of the
// current pair
product *= (arr[i] % mod
* arr[j] % mod)
% mod;
product = product % mod;
}
}
// Return the final result
return product % mod;
}
// Driver code
let arr = [ 1, 2, 3 ];
let n = arr.length;
document.write(productPairs(arr, n));
// This code is contributed by Mayank Tyagi
</script>
Time Complexity: O(N2)
Auxiliary Space: O(1)
Efficient approach:
We can observe that each element appears exactly (2 * N) times as one of the elements of a pair (X, Y). Exactly N times as X and exactly N times as Y.
Below is the implementation of the above approach:
C++
// C++ implementation to Find the product
// of all the pairs from the given array
#include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
#define ll long long int
// Function to calculate
// (x^y)%1000000007
int power(int x, unsigned int y)
{
int p = 1000000007;
// Initialize result
int res = 1;
// Update x if it is more than
// or equal to p
x = x % p;
while (y > 0) {
// If y is odd, multiply x
// with result
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
// Return the final result
return res;
}
// Function to return the product
// of the elements of all possible
// pairs from the array
ll productPairs(ll arr[], ll n)
{
// To store the required product
ll product = 1;
// Iterate for every element
// of the array
for (int i = 0; i < n; i++) {
// Each element appears (2 * n) times
product
= (product
% mod
* (int)power(
arr[i], (2 * n))
% mod)
% mod;
}
return product % mod;
}
// Driver code
int main()
{
ll arr[] = { 1, 2, 3 };
ll n = sizeof(arr) / sizeof(arr[0]);
cout << productPairs(arr, n);
return 0;
}
// Java implementation to Find the product
// of all the pairs from the given array
import java.util.*;
class GFG{
static final int mod = 1000000007;
// Function to calculate
// (x^y)%1000000007
static int power(int x, int y)
{
int p = 1000000007;
// Initialize result
int res = 1;
// Update x if it is more than
// or equal to p
x = x % p;
while (y > 0)
{
// If y is odd, multiply x
// with result
if (y % 2 == 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
// Return the final result
return res;
}
// Function to return the product
// of the elements of all possible
// pairs from the array
static int productPairs(int arr[], int n)
{
// To store the required product
int product = 1;
// Iterate for every element
// of the array
for (int i = 0; i < n; i++)
{
// Each element appears (2 * n) times
product = (product % mod *
(int)power(arr[i],
(2 * n)) % mod) % mod;
}
return product % mod;
}
// Driver code
public static void main(String[] args)
{
int arr[] = { 1, 2, 3 };
int n = arr.length;
System.out.print(productPairs(arr, n));
}
}
// This code is contributed by amal kumar choubey
# Python3 implementation to Find the product
# of all the pairs from the given array
mod = 1000000007
# Function to calculate
# (x^y)%1000000007
def power(x, y):
p = 1000000007
# Initialize result
res = 1
# Update x if it is more than
# or equal to p
x = x % p
while (y > 0):
# If y is odd, multiply x
# with result
if ((y & 1) != 0):
res = (res * x) % p
y = y >> 1
x = (x * x) % p
# Return the final result
return res
# Function to return the product
# of the elements of all possible
# pairs from the array
def productPairs(arr, n):
# To store the required product
product = 1
# Iterate for every element
# of the array
for i in range(n):
# Each element appears (2 * n) times
product = (product % mod *
(int)(power(arr[i], (2 * n))) %
mod) % mod
return (product % mod)
# Driver code
arr = [ 1, 2, 3 ]
n = len(arr)
print(productPairs(arr, n))
# This code is contributed by divyeshrabadiya07
// C# implementation to Find the product
// of all the pairs from the given array
using System;
class GFG{
const int mod = 1000000007;
// Function to calculate
// (x^y)%1000000007
static int power(int x, int y)
{
int p = 1000000007;
// Initialize result
int res = 1;
// Update x if it is more than
// or equal to p
x = x % p;
while (y > 0)
{
// If y is odd, multiply x
// with result
if (y % 2 == 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
// Return the final result
return res;
}
// Function to return the product
// of the elements of all possible
// pairs from the array
static int productPairs(int []arr, int n)
{
// To store the required product
int product = 1;
// Iterate for every element
// of the array
for (int i = 0; i < n; i++)
{
// Each element appears (2 * n) times
product = (product % mod *
(int)power(arr[i],
(2 * n)) % mod) % mod;
}
return product % mod;
}
// Driver code
public static void Main()
{
int []arr = { 1, 2, 3 };
int n = arr.Length;
Console.Write(productPairs(arr, n));
}
}
// This code is contributed by Code_Mech
<script>
// Javascript implementation to Find the product
// of all the pairs from the given array
let mod = 1000000007;
// Function to calculate
// (x^y)%1000000007
function power(x, y)
{
let p = 1000000007;
// Initialize result
let res = 1;
// Update x if it is more than
// or equal to p
x = x % p;
while (y > 0)
{
// If y is odd, multiply x
// with result
if (y % 2 == 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
// Return the final result
return res;
}
// Function to return the product
// of the elements of all possible
// pairs from the array
function productPairs(arr, n)
{
// To store the required product
let product = 1;
// Iterate for every element
// of the array
for (let i = 0; i < n; i++)
{
// Each element appears (2 * n) times
product = (product % mod *
power(arr[i],
(2 * n)) % mod) % mod;
}
return product % mod;
}
// Driver Code
let arr = [ 1, 2, 3 ];
let n = arr.length;
document.write(productPairs(arr, n));
</script>
Time Complexity: O(N)
Space Complexity: O(1)
Similar Reads
Sum of all ordered pair-products from a given array Given an array arr[] of size N, the task is to find the sum of all products of ordered pairs that can be generated from the given array elements.Examples: Input: arr[] ={1, 2, 3}Output: 36Explanation:All possible pairs are {(1, 1), {1, 2}, {1, 3}, {2, 1}, {2, 2}, {2, 3}, {3, 1}, {3, 2}, {3, 3}}. The
4 min read
Find all Pairs possible from the given Array Given an array arr[] of N integers, the task is to find all the pairs possible from the given array. Note: (arr[i], arr[i]) is also considered as a valid pair.(arr[i], arr[j]) and (arr[j], arr[i]) are considered as two different pairs.Examples: Input: arr[] = {1, 2} Output: (1, 1), (1, 2), (2, 1), (
4 min read
Count pairs with Even Product from two given arrays Given two arrays, arr[] and brr[] of size N and M respectively, the task is to find the count of pairs (arr[i], brr[j]) such that the product of elements of the pairs is an even number. Examples: Input: arr[] = { 1, 2, 3 }, brr[] = { 1, 2 } Output: 4 Explanation: Pairs with even product are: { (arr[
10 min read
Count all possible pairs in given Array with product K Given an integer array arr[] of size N and a positive integer K, the task is to count all the pairs in the array with a product equal to K. Examples: Input: arr[] = {1, 2, 16, 4, 4, 4, 8 }, K=16Output: 5Explanation: Possible pairs are (1, 16), (2, 8), (4, 4), (4, 4), (4, 4) Input: arr[] = {1, 10, 20
11 min read
Sum of product of all pairs of array elements Given an array A[] of integers find sum of product of all pairs of array elements i. e., we need to find of product after execution of following pseudo code product = 0 for i = 1:n for j = i+1:n product = product + A[i]*A[j] Examples: Input : A[] = {1, 3, 4} Output : 19 Possible Pairs : (1,3), (1,4)
12 min read