Problem: Find product of all elements at indexes which are factors of M for all possible sorted subsequences of length M
Given an array arr[] of N distinct integers and a positive integer M, the task is to find the product of all the elements at the indexes which are the factors of M for all the possible sorted subsequences of length M from the given array arr[].
Note: The product may be very large, take modulo to 109 + 7.

Sample Input: arr[] = {4, 7, 5, 9, 3}, M = 4
Sample Output: 808556639
Explanation:
There are five possible sets. They are:
{4, 7, 5, 9}. In the sorted order, this set becomes {4, 5, 7, 9}. In this set, index 1, 2 and 4 divides M completely. Therefore, arr[1] * arr[2] * arr[4] = 4 * 5 * 9 = 180.
Similarly, the remaining four sets along with their products are:
{4, 7, 9, 3} -> 108
{4, 5, 9, 3} -> 108
{4, 7, 5, 3} -> 84
{7, 5, 9, 3} -> 135
The total value = ((180 * 108 * 108 * 84 * 135) % (10^9+7)) = 808556639

Solution (cpp):
// C++ program to find the product of
// all the combinations of M elements
// from an array whose index in the
// sorted order divides M completely

#include <bits/stdc++.h>
using namespace std;

typedef long long int lli;
const int m = 4;

// Iterative Function to calculate
// (x^y)%p in O(log y)
long long int power(lli x, lli y, lli p)
{
    lli res = 1;
    x = x % p;

    while (y > 0) {

        // If y is odd, multiply x with result
        if (y & 1)
            res = (res * x) % p;

        // y must be even now
        y = y >> 1;
        x = (x * x) % p;
    }
    return res;
}

// Iterative Function to calculate
// (nCr)%p and save in f[n][r]
// C(n, r)%p = [ C(n-1, r-1)%p + C(n-1, r)%p ] % p
// and C(n, 0) = C(n, n) = 1
void nCr(lli n, lli p, lli f[][m + 1])
{
    for (lli i = 0; i <= n; i++) {
        for (lli j = 0; j <= m; j++) {

            // If j>i then C(i, j) = 0
            if (j > i)
                f[i][j] = 0;

            // If i is equal to j then C(i, j) = 1
            else if (j == 0 || j == i)
                f[i][j] = 1;

            // C(i, j) = ( C(i-1, j) + C(i-1, j-1))%p
            else
                f[i][j] = (f[i - 1][j]
                           + f[i - 1][j - 1])
                          % p;
        }
    }
}

void operations(lli arr[], lli n, lli f[][m + 1])
{
    lli p = 1000000007;
    nCr(n, p - 1, f);

    sort(arr, arr + n);

    // Initialize the answer
    lli ans = 1;

    for (lli i = 0; i < n; i++) {

        // For every element arr[i],
        // x is count of occurrence
        // of arr[i] in different set
        // such that index of arr[i]
        // in those sets divides m completely.
        long long int x = 0;

        for (lli j = 1; j <= m; j++) {

            // Finding the count of arr[i]
            // by placing it at the index
            // which divides m completely
            if (m % j == 0)

                // Using fermat's little theorem
                x = (x
                     + (f[n - i - 1][m - j]
                        * f[i][j - 1])
                           % (p - 1))
                    % (p - 1);
        }

        // Multiplying with the count
        ans = ((ans * power(arr[i],
                            x, p))
               % p);
    }

    cout << ans << endl;
}

// Driver code
int main()
{

    lli arr[] = { 4, 5, 7, 9, 3 };

    lli n = sizeof(arr) / sizeof(arr[0]);

    lli f[n + 1][m + 1];

    operations(arr, n, f);
}