# Product of all Subsequences of size K except the minimum and maximum Elements

Given an array A[] containing N elements and an integer K. The task is to calculate the product of all elements of subsequences of size K except the minimum and the maximum elements for each subsequence.

Note: Since the answer can be very large so print the final answer as mod of 109 + 7.

Examples:

```Input : arr[] = {1, 2, 3 4}, K = 3
Output : 36
Subsequences of length 3 are:
{1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, 4}
Excluding minimum and maximum elements from
each of the above subsequences, product will be:
(2 * 2 * 3 * 3) = 36.

Input : arr[] = {10, 5, 16, 6}, k=3
Output : 3600
```

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

Naive Approach: A simple approach is to generate all possible subsequences one by one and multiply all elements except maximum and minimum and further multiplying all of them. Since there will be a total of (n)C(K) subsequences all having K – 2 elements to be multiplied which is a tedious work to do.

Efficient Approach: The idea is to first sort the array since it doesn’t matter if we consider subsequences or subsets.

Now count the occurrence of each element one by one.

In total a number can occur in (n-1)C(K-1) subsequences out of which (i)C(K-1) times it will occur as maximum element and (n-i-1)C(K-1) times it will occur as minimum element of that subsequence.

Hence, in total element will occur:

```(n-1)C(K-1)  - (i)C(K-1) - (n-i-1)C(K-1) times. (let's say it x)
```

So, at first we’ll be calculating x for each element a[i] and then multiply a[i] x times. i.e ().

Since, It’s too difficult to calculate this for large arrays, so we’ll use the Fermat’s Little Theorem.

Below is the implementation of the above approach:

 `// C++ program to find product of all  ` `// Subsequences of size K except the  ` `// minimum and maximum Elements ` ` `  `#include ` `using` `namespace` `std; ` `#define MOD 1000000007 ` ` `  `#define ll long long ` ` `  `#define max 101 ` ` `  `// 2D array to store value of  ` `// combinations nCr ` `ll C[max - 1][max - 1]; ` ` `  `ll power(ll x, unsigned ll y) ` `{ ` `    ``unsigned ll res = 1; ` `    ``x = x % MOD; ` `    ``while` `(y > 0) { ` `        ``if` `(y & 1) { ` `            ``res = (res * x) % MOD; ` `        ``} ` ` `  `        ``y = y >> 1; ` `        ``x = (x * x) % MOD; ` `    ``} ` `    ``return` `res % MOD; ` `} ` ` `  `// Function to pre-calculate value of all  ` `// combinations nCr ` `void` `combi(``int` `n, ``int` `k) ` `{ ` `    ``int` `i, j; ` ` `  `    ``for` `(i = 0; i <= n; i++) { ` `        ``for` `(j = 0; j <= min(i, k); j++) { ` `            ``if` `(j == 0 || j == i) ` `                ``C[i][j] = 1; ` `            ``else` `                ``C[i][j] = (C[i - 1][j - 1] % MOD  ` `                            ``+ C[i - 1][j] % MOD) % MOD; ` `        ``} ` `    ``} ` `} ` ` `  `// Function to calculate product of all subsequences  ` `// except the minimum and maximum elements ` `unsigned ll product(ll a[], ``int` `n, ``int` `k) ` `{ ` `    ``unsigned ll ans = 1; ` ` `  `    ``// Sorting array so that it becomes easy  ` `    ``// to calculate the number of times an  ` `    ``// element will come in first or last place ` `    ``sort(a, a + n); ` `     `  `    ``// An element will occur 'powa' times in total ` `    ``// of which 'powla' times it will be last element ` `    ``// and 'powfa' times it will be first element ` `    ``ll powa = C[n - 1][k - 1]; ` ` `  `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``ll powla = C[i][k - 1]; ` `        ``ll powfa = C[n - i - 1][k - 1]; ` `         `  `        ``// In total it will come  ` `        ``// powe = powa-powla-powfa times ` `        ``ll powe = ((powa % MOD) - (powla + powfa) % MOD + MOD) % MOD; ` `         `  `        ``// Multiplying a[i] powe times using  ` `        ``// Fermat Little Theorem under MODulo  ` `        ``// MOD for fast exponentiation ` `        ``unsigned ll mul = power(a[i], powe) % MOD; ` `        ``ans = ((ans % MOD) * (mul % MOD)) % MOD; ` `    ``} ` `     `  `    ``return` `ans % MOD; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// pre-calculation of all combinations ` `    ``combi(100, 100); ` ` `  `    ``ll arr[] = { 1, 2, 3, 4 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof` `arr; ` `    ``int` `k = 3; ` ` `  `    ``unsigned ll ans = product(arr, n, k); ` `     `  `    ``cout << ans << endl; ` ` `  `    ``return` `0; ` `} `

 `// Java program to find product of all  ` `// Subsequences of size K except the  ` `// minimum and maximum Elements ` `import` `java.util.Arrays; ` ` `  `class` `GFG  ` `{ ` `     `  `static` `int` `MOD= ``1000000007``; ` `static` `int` `max =``101``; ` ` `  `// 2D array to store value of  ` `// combinations nCr ` `static` `long` `C[][] = ``new` `long``[max ][max]; ` ` `  `static` `long` `power(``long` `x, ``long` `y) ` `{ ` `    ``long` `res = ``1``; ` `    ``x = x % MOD; ` `    ``while` `(y > ``0``) ` `    ``{ ` `        ``if` `(y % ``2``== ``1``) ` `        ``{ ` `            ``res = (res * x) % MOD; ` `        ``} ` ` `  `        ``y = y >> ``1``; ` `        ``x = (x * x) % MOD; ` `    ``} ` `    ``return` `res % MOD; ` `} ` ` `  `// Function to pre-calculate value of all  ` `// combinations nCr ` `static` `void` `combi(``int` `n, ``int` `k) ` `{ ` `    ``int` `i, j; ` ` `  `    ``for` `(i = ``0``; i <= n; i++) ` `    ``{ ` `        ``for` `(j = ``0``; j <= Math.min(i, k); j++)  ` `        ``{ ` `            ``if` `(j == ``0` `|| j == i) ` `                ``C[i][j] = ``1``; ` `            ``else` `                ``C[i][j] = (C[i - ``1``][j - ``1``] % MOD  ` `                            ``+ C[i - ``1``][j] % MOD) % MOD; ` `        ``} ` `    ``} ` `} ` ` `  `// Function to calculate product of all subsequences  ` `// except the minimum and maximum elements ` `static` `long` `product(``long` `a[], ``int` `n, ``int` `k) ` `{ ` `    ``long` `ans = ``1``; ` ` `  `    ``// Sorting array so that it becomes easy  ` `    ``// to calculate the number of times an  ` `    ``// element will come in first or last place ` `    ``Arrays.sort(a); ` `     `  `    ``// An element will occur 'powa' times in total ` `    ``// of which 'powla' times it will be last element ` `    ``// and 'powfa' times it will be first element ` `    ``long` `powa = C[n - ``1``][k - ``1``]; ` ` `  `    ``for` `(``int` `i = ``0``; i < n; i++)  ` `    ``{ ` `        ``long` `powla = C[i][k - ``1``]; ` `        ``long` `powfa = C[n - i - ``1``][k - ``1``]; ` `         `  `        ``// In total it will come  ` `        ``// powe = powa-powla-powfa times ` `        ``long` `powe = ((powa % MOD) - (powla + powfa) % MOD + MOD) % MOD; ` `         `  `        ``// Multiplying a[i] powe times using  ` `        ``// Fermat Little Theorem under MODulo  ` `        ``// MOD for fast exponentiation ` `        ``long` `mul = power(a[i], powe) % MOD; ` `        ``ans = ((ans % MOD) * (mul % MOD)) % MOD; ` `    ``} ` `     `  `    ``return` `ans % MOD; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``// pre-calculation of all combinations ` `    ``combi(``100``, ``100``); ` ` `  `    ``long` `arr[] = { ``1``, ``2``, ``3``, ``4` `}; ` `    ``int` `n = arr.length; ` `    ``int` `k = ``3``; ` ` `  `    ``long` `ans = product(arr, n, k); ` `     `  `    ``System.out.println(ans); ` `} ` `} ` ` `  `/* This code contributed by PrinciRaj1992 */`

 `# Python 3 program to find product of all  ` `# Subsequences of size K except the  ` `# minimum and maximum Elements ` ` `  `MOD ``=` `1000000007` ` `  `max` `=` `101` ` `  `# 2D array to store value of  ` `# combinations nCr ` `C ``=` `[[``0` `for` `i ``in` `range``(``max``)] ``for` `j ``in` `range``(``max``)] ` ` `  `def` `power(x,y): ` `    ``res ``=` `1` `    ``x ``=` `x ``%` `MOD ` `    ``while` `(y > ``0``): ` `        ``if` `(y & ``1``): ` `            ``res ``=` `(res ``*` `x) ``%` `MOD ` ` `  `        ``y ``=` `y >> ``1` `        ``x ``=` `(x ``*` `x) ``%` `MOD ` ` `  `    ``return` `res ``%` `MOD ` ` `  `# Function to pre-calculate value of all  ` `# combinations nCr ` `def` `combi(n, k): ` `    ``for` `i ``in` `range``(n ``+` `1``): ` `        ``for` `j ``in` `range``(``min``(i, k) ``+` `1``): ` `            ``if` `(j ``=``=` `0` `or` `j ``=``=` `i): ` `                ``C[i][j] ``=` `1` `            ``else``: ` `                ``C[i][j] ``=` `(C[i ``-` `1``][j ``-` `1``] ``%` `MOD ``+`  `                            ``C[i ``-` `1``][j] ``%` `MOD) ``%` `MOD ` ` `  `# Function to calculate product of all subsequences  ` `# except the minimum and maximum elements ` `def` `product(a, n, k): ` `    ``ans ``=` `1` ` `  `    ``# Sorting array so that it becomes easy  ` `    ``# to calculate the number of times an  ` `    ``# element will come in first or last place ` `    ``a.sort(reverse ``=` `False``) ` `     `  `    ``# An element will occur 'powa' times in total ` `    ``# of which 'powla' times it will be last element ` `    ``# and 'powfa' times it will be first element ` `    ``powa ``=` `C[n ``-` `1``][k ``-` `1``] ` ` `  `    ``for` `i ``in` `range``(n): ` `        ``powla ``=` `C[i][k ``-` `1``] ` `        ``powfa ``=` `C[n ``-` `i ``-` `1``][k ``-` `1``] ` `         `  `        ``# In total it will come  ` `        ``# powe = powa-powla-powfa times ` `        ``powe ``=` `((powa ``%` `MOD) ``-` `(powla ``+` `powfa) ``%` `MOD ``+` `MOD) ``%` `MOD ` `         `  `        ``# Multiplying a[i] powe times using  ` `        ``# Fermat Little Theorem under MODulo  ` `        ``# MOD for fast exponentiation ` `        ``mul ``=` `power(a[i], powe) ``%` `MOD ` `        ``ans ``=` `((ans ``%` `MOD) ``*` `(mul ``%` `MOD)) ``%` `MOD ` `     `  `    ``return` `ans ``%` `MOD ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``# pre-calculation of all combinations ` `    ``combi(``100``, ``100``) ` ` `  `    ``arr ``=` `[``1``, ``2``, ``3``, ``4``] ` `    ``n ``=` `len``(arr) ` `    ``k ``=` `3` ` `  `    ``ans ``=` `product(arr, n, k) ` `    ``print``(ans) ` ` `  `# This code is contributed by ` `# Surendra_Gangwar `

 `// C# program to find product of all  ` `// Subsequences of size K except the  ` `// minimum and maximum Elements ` `using` `System; ` ` `  `class` `GFG ` `{ ` `static` `int` `MOD = 1000000007; ` `static` `int` `max = 101; ` ` `  `// 2D array to store value of  ` `// combinations nCr ` `static` `long` `[,]C = ``new` `long``[max, max]; ` ` `  `static` `long` `power(``long` `x, ``long` `y) ` `{ ` `    ``long` `res = 1; ` `    ``x = x % MOD; ` `    ``while` `(y > 0) ` `    ``{ ` `        ``if` `(y % 2 == 1) ` `        ``{ ` `            ``res = (res * x) % MOD; ` `        ``} ` ` `  `        ``y = y >> 1; ` `        ``x = (x * x) % MOD; ` `    ``} ` `    ``return` `res % MOD; ` `} ` ` `  `// Function to pre-calculate value  ` `// of all combinations nCr ` `static` `void` `combi(``int` `n, ``int` `k) ` `{ ` `    ``int` `i, j; ` ` `  `    ``for` `(i = 0; i <= n; i++) ` `    ``{ ` `        ``for` `(j = 0; ` `             ``j <= Math.Min(i, k); j++)  ` `        ``{ ` `            ``if` `(j == 0 || j == i) ` `                ``C[i, j] = 1; ` `            ``else` `                ``C[i, j] = (C[i - 1, j - 1] % MOD +  ` `                           ``C[i - 1, j] % MOD) % MOD; ` `        ``} ` `    ``} ` `} ` ` `  `// Function to calculate product of  ` `// all subsequences except  ` `// the minimum and maximum elements ` `static` `long` `product(``long` `[]a, ``int` `n, ``int` `k) ` `{ ` `    ``long` `ans = 1; ` ` `  `    ``// Sorting array so that it becomes easy  ` `    ``// to calculate the number of times an  ` `    ``// element will come in first or last place ` `    ``Array.Sort(a); ` `     `  `    ``// An element will occur 'powa' times  ` `    ``// in total of which 'powla' times it  ` `    ``// will be last element and 'powfa' times ` `    ``// it will be first element ` `    ``long` `powa = C[n - 1, k - 1]; ` ` `  `    ``for` `(``int` `i = 0; i < n; i++)  ` `    ``{ ` `        ``long` `powla = C[i, k - 1]; ` `        ``long` `powfa = C[n - i - 1, k - 1]; ` `         `  `        ``// In total it will come  ` `        ``// powe = powa-powla-powfa times ` `        ``long` `powe = ((powa % MOD) -      ` `                     ``(powla + powfa) %  ` `                      ``MOD + MOD) % MOD; ` `         `  `        ``// Multiplying a[i] powe times using  ` `        ``// Fermat Little Theorem under MODulo  ` `        ``// MOD for fast exponentiation ` `        ``long` `mul = power(a[i], powe) % MOD; ` `        ``ans = ((ans % MOD) *  ` `               ``(mul % MOD)) % MOD; ` `    ``} ` `     `  `    ``return` `ans % MOD; ` `} ` ` `  `// Driver Code ` `static` `public` `void` `Main () ` `{ ` `    ``// pre-calculation of all combinations ` `    ``combi(100, 100); ` ` `  `    ``long` `[]arr = { 1, 2, 3, 4 }; ` `    ``int` `n = arr.Length; ` `    ``int` `k = 3; ` ` `  `    ``long` `ans = product(arr, n, k); ` `     `  `    ``Console.WriteLine(ans); ` `} ` `} ` ` `  `// This code contributed by ajit  `

Output:
```36
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Check out this Author's contributed articles.

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.

Article Tags :