# Queries for the product of first N factorials

Given Q[] queries where each query consists of an integer N, the task is to find the product of first N factorials for each of the query. Since the result could be large, compute it modulo 109 + 7.

Examples:

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

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

Approach: Create two arrays result[] and fact[] where fact[i] will store the factorial of i and result[i] will store the product of first i factorial.
Initialise fact = 1 and result = 1. Now for the rest of the values, the recurrence relation will be:

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

Now, each query can be answered using the result[] array generated.

Below is the implementation of the above approach:

## 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 = 1; ` `    ``result = 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); ` ` `  `    ``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 = 1; ` `    ``result = 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 `

Output:

```288
34560
```

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.

My Personal Notes arrow_drop_up 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.