# Queries for the product of first N factorials

• Last Updated : 13 Mar, 2022

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

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`

## Javascript

 ``

Output:

```288
34560```

Time Complexity: O(MAX)

Auxiliary Space: O(MAX)

My Personal Notes arrow_drop_up
Recommended Articles
Page :