Skip to content
Related Articles

Related Articles

Queries for the product of first N factorials

View Discussion
Improve Article
Save Article
Like Article
  • 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[0] = 1 and result[0] = 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 <bits/stdc++.h>
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


Javascript




<script>
    // Javascript implementation of the approach
     
    let MAX = 1000000;
   
    let MOD = 10000007;
 
    // Declare result array globally
    let result = new Array(MAX + 1);
    result.fill(0);
    let fact = new Array(MAX + 1);
    fact.fill(0);
 
    // Function to precompute the product
    // of factorials upto MAX
    function 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 (let 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
    function performQueries(q, n)
    {
 
        // Precomputing the result till MAX
        preCompute();
 
        // Perform queries
        for (let i = 0; i < n; i++)
            document.write(result[q[i]] + "</br>");
    }
     
    let q = [ 4, 5 ];
    let n = q.length;
       
    performQueries(q, n);
     
</script>


Output: 

288
34560

 

Time Complexity: O(MAX)

Auxiliary Space: O(MAX)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!