Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Queries for the product of first N factorials

  • Last Updated : 30 Apr, 2021

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 
 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

 



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

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :