 Open in App
Not now

# 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