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 = 16Input: 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++ 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> |
46656
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++ 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> |
46656
Time Complexity: O(N)
Space Complexity: O(1)