对前N个阶乘的乘积的查询

给定Q []查询，其中每个查询由整数N组成，任务是查找每个查询的前N个阶乘的乘积。由于结果可能很大，因此以10 ⁹ + 7为模进行计算。

例子：

Input: Q[] = {4, 5}
Output:
288
34560
Query 1: 1! * 2! * 3! * 4! = 1 * 2 * 6 * 24 = 288
Query 2: 1! * 2! * 3! * 4! * 5! = 1 * 2 * 6 * 24 * 120 = 34560

Input: Q[] = {500, 1000, 7890}
Output:
976141892
560688561
793351288

方法：创建两个数组result []和fact [] ，其中fact [i]将存储i的阶乘，而result [i]将存储第一个i阶乘的乘积。
初始化事实[0] = 1 ，结果[0] = 1 。现在，对于其余的值，递归关系将是：

fact[i] = fact[i – 1] * i
result[i] = result[i – 1] * fact[i]

现在，可以使用生成的result []数组回答每个查询。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
  
#define ll long long
#define MAX 1000000
  
const ll MOD = 1e9 + 7;
  
// Declare result array globally
ll result[MAX + 1];
ll fact[MAX + 1];
  
// Function to precompute the product
// of factorials upto MAX
void preCompute()
{
  
    // Initialize base condition if n = 0
    // then factorial of 0 is equal to 1
    // and answer for n = 0 is 1
    fact[0] = 1;
    result[0] = 1;
  
    // Iterate loop from 1 to MAX
    for (int i = 1; i <= MAX; i++) {
  
        // factorial(i) = factorial(i - 1) * i
        fact[i] = ((fact[i - 1] % MOD) * i) % MOD;
  
        // Result for current n is equal to result[i-1]
        // multiplied by the factorial of i
        result[i] = ((result[i - 1] % MOD) * (fact[i] % MOD)) % MOD;
    }
}
  
// Function to perform the queries
void performQueries(int q[], int n)
{
  
    // Precomputing the result till MAX
    preCompute();
  
    // Perform queries
    for (int i = 0; i < n; i++)
        cout << result[q[i]] << "\n";
}
  
// Driver code
int main()
{
  
    int q[] = { 4, 5 };
    int n = sizeof(q) / sizeof(q[0]);
  
    performQueries(q, n);
  
    return 0;
}

Java

// Java implementation of the approach
import java.io.*;
  
class GFG
{
static int MAX = 1000000;
  
static int MOD = 10000007;
  
// Declare result array globally
static int []result = new int [MAX + 1];
static int []fact = new int [MAX + 1];
  
// Function to precompute the product
// of factorials upto MAX
static void preCompute()
{
  
    // Initialize base condition if n = 0
    // then factorial of 0 is equal to 1
    // and answer for n = 0 is 1
    fact[0] = 1;
    result[0] = 1;
  
    // Iterate loop from 1 to MAX
    for (int i = 1; i <= MAX; i++) 
    {
  
        // factorial(i) = factorial(i - 1) * i
        fact[i] = ((fact[i - 1] % MOD) * i) % MOD;
  
        // Result for current n is equal to result[i-1]
        // multiplied by the factorial of i
        result[i] = ((result[i - 1] % MOD) * 
                   (fact[i] % MOD)) % MOD;
    }
}
  
// Function to perform the queries
static void performQueries(int q[], int n)
{
  
    // Precomputing the result till MAX
    preCompute();
  
    // Perform queries
    for (int i = 0; i < n; i++)
        System.out.println (result[q[i]]);
}
  
// Driver code
public static void main (String[] args) 
{
    int q[] = { 4, 5 };
    int n = q.length;
      
    performQueries(q, n);
}
}
  
// This code is contributed by tushil.

Python3

# Python3 implementation of the approach
  
MAX = 1000000
MOD = 10**9 + 7
  
# Declare result array globally
result = [0 for i in range(MAX + 1)]
fact = [0 for i in range(MAX + 1)]
  
# Function to precompute the product
# of factorials upto MAX
def preCompute():
  
    # Initialize base condition if n = 0
    # then factorial of 0 is equal to 1
    # and answer for n = 0 is 1
    fact[0] = 1
    result[0] = 1
  
    # Iterate loop from 1 to MAX
    for i in range(1, MAX + 1):
  
        # factorial(i) = factorial(i - 1) * i
        fact[i] = ((fact[i - 1] % MOD) * i) % MOD
  
        # Result for current n is  
        # equal to result[i-1] 
        # multiplied by the factorial of i
        result[i] = ((result[i - 1] % MOD) * 
                     (fact[i] % MOD)) % MOD
  
# Function to perform the queries
def performQueries(q, n):
  
    # Precomputing the result tiMAX
    preCompute()
  
    # Perform queries
    for i in range(n):
        print(result[q[i]])
  
# Driver code
q = [4, 5]
n = len(q)
  
performQueries(q, n)
  
# This code is contributed by Mohit Kumar

C#

// C# implementation of the approach 
using System;
  
class GFG
{
static int MAX = 1000000;
  
static int MOD = 10000007;
  
// Declare result array globally
static int []result = new int [MAX + 1];
static int []fact = new int [MAX + 1];
  
// Function to precompute the product
// of factorials upto MAX
static void preCompute()
{
  
    // Initialize base condition if n = 0
    // then factorial of 0 is equal to 1
    // and answer for n = 0 is 1
    fact[0] = 1;
    result[0] = 1;
  
    // Iterate loop from 1 to MAX
    for (int i = 1; i <= MAX; i++) 
    {
  
        // factorial(i) = factorial(i - 1) * i
        fact[i] = ((fact[i - 1] % MOD) * i) % MOD;
  
        // Result for current n is equal to result[i-1]
        // multiplied by the factorial of i
        result[i] = ((result[i - 1] % MOD) * 
                     (fact[i] % MOD)) % MOD;
    }
}
  
// Function to perform the queries
static void performQueries(int []q, int n)
{
  
    // Precomputing the result till MAX
    preCompute();
  
    // Perform queries
    for (int i = 0; i < n; i++)
        Console.WriteLine(result[q[i]]);
}
  
// Driver code
public static void Main (String[] args) 
{
    int []q = { 4, 5 };
    int n = q.Length;
      
    performQueries(q, n);
}
}
      
// This code is contributed by 29AjayKumar

输出：

288
34560