Skip to content
Related Articles

Related Articles

Improve Article

Factorial of an Array of integers

  • Difficulty Level : Expert
  • Last Updated : 20 Jul, 2021

Given an array with positive integers. The task is to find the factorial of all the array elements. 
Note: As the numbers would be very large, print them by taking modulus with 109+7.

Examples: 

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.

Input: arr[] = {3, 10, 200, 20, 12}
Output: 6 3628800 722479105 146326063 479001600

Input: arr[] = {5, 7, 10}
Output: 120 5040 3628800 

Naive approach: We know that there is a simple approach to calculate the factorial of a number. We can run a loop for all array values and can find the factorial of every number using the above approach.
Time Complexity would be O(N2
Space Complexity would be O(1) 



Efficient Approach: We know that the factorial of a number: 

N! = N*(N-1)*(N-2)*(N-3)*****3*2*1

The recursive formulae to calculate the factorial of a number is: 

fact(N) = N*fact(N-1).

Hence, we will build an array in a bottom-up manner using the above recursion. Once we have stored the values in the array then we can answer the queries in O(1) time. Hence, the overall time complexity would be O(N). We can use this method only if the array values are less than 10^6. Otherwise, we would not be able to store them in an array.

Below is the implementation of the above approach:  

Java




<script>
// Java implementation of the approach
import java.util.*;
 
class Sol
{
     
static int MOD = 1000000007 ;
static int SIZE = 10000;
 
 
// vector to store the factorial values
// max_element(arr) should be less than SIZE
static Vector<Long> fact = new Vector<Long>();
 
// Function to calculate the factorial
// using dynamic programming
static void factorial()
{
    int i;
    fact.add((long)1);
    for (i = 1; i <= SIZE; i++)
    {
 
        // Calculation of factorial
        // As fact[i-1] stores the factorial of n-1
        // so factorial of n is fact[i] = (fact[i-1]*i)
        fact.add((fact.get(i - 1) * i) % MOD);
    }
}
 
// Function to print factorial of every element
// of the array
static void PrintFactorial(int arr[],int n)
{
    for(int i = 0; i < n; i += 1)
    {
 
        // Printing the stored value of arr[i]!
        System.out.print(fact.get(arr[i])+" ");
    }
}
 
// Driver code
public static void main(String args[])
{
 
    int arr[] = {3, 10, 200, 20, 12};
    int n = arr.length;
 
    // Function to store factorial values mod 10**9+7
    factorial();
 
    // Function to print the factorial values mod 10**9+7
    PrintFactorial(arr,n);
}
}
 
// This code is contributed by Arnab Kundu
</script>

Python




# Python implementation of the above Approach
mod = 1000000007
SIZE = 10000
 
# declaring list initially and making
# it 1 i.e for every index
fact = [1]*SIZE
 
# Calculation of factorial using Dynamic programming
def factorial():   
    for i in range(1, SIZE):    
    
        # Calculation of factorial
        # As fact[i-1] stores the factorial of n-1
        # so factorial of n is fact[i] = (fact[i-1]*i)       
        fact[i] = (fact[i-1]*i) % mod
 
# function call
factorial()
 
# Driver code
arr=[3,10,200,20,12]
for i in arr:
    print fact[i],

PHP




<?php
// PHP implementation of the approach
 
$MOD = 1000000007 ;
$SIZE = 10000 ;
 
// Function to calculate the factorial
// using dynamic programming
function factorial($fact)
{
    $fact[0] = 1;
    for ($i = 1; $i <= $GLOBALS['SIZE']; $i++)
    {
 
        // Calculation of factorial
        // As fact[i-1] stores the factorial of n-1
        // so factorial of n is fact[i] = (fact[i-1]*i)
        $fact[$i] = ($fact[$i - 1] * $i) % $GLOBALS['MOD'];
    }
    return $fact;
}
 
// Function to print factorial of every element
// of the array
function PrintFactorial($fact, $arr, $n)
{
    for($i = 0; $i < $n; $i++)
    {
 
        // Printing the stored value of arr[i]!
        echo $fact[$arr[$i]]," ";
    }
}
 
    // Driver code
    // vector to store the factorial values
    // max_element(arr) should be less than SIZE
    $fact = array_fill(0,$SIZE + 1, 0);
 
    $arr = array(3, 10, 200, 20, 12);
    $n = count($arr);
 
    // Function to store factorial values mod 10**9+7
    $fact = factorial($fact);
 
    // Function to print the factorial values mod 10**9+7
    PrintFactorial($fact,$arr,$n);
 
    // This code is contributed by AnkitRai01
?>

C#




// C# implementation of above approach
using System.Collections.Generic;
using System;
 
class Sol
{
     
static int MOD = 1000000007 ;
static int SIZE = 10000;
 
 
// vector to store the factorial values
// max_element(arr) should be less than SIZE
static List<long> fact = new List<long>();
 
// Function to calculate the factorial
// using dynamic programming
static void factorial()
{
    int i;
    fact.Add((long)1);
    for (i = 1; i <= SIZE; i++)
    {
 
        // Calculation of factorial
        // As fact[i-1] stores the factorial of n-1
        // so factorial of n is fact[i] = (fact[i-1]*i)
        fact.Add((fact[i - 1] * i) % MOD);
    }
}
 
// Function to print factorial of every element
// of the array
static void PrintFactorial(int []arr,int n)
{
    for(int i = 0; i < n; i += 1)
    {
 
        // Printing the stored value of arr[i]!
        Console.Write(fact[arr[i]]+" ");
    }
}
 
// Driver code
public static void Main(String []args)
{
 
    int []arr = {3, 10, 200, 20, 12};
    int n = arr.Length;
 
    // Function to store factorial values mod 10**9+7
    factorial();
 
    // Function to print the factorial values mod 10**9+7
    PrintFactorial(arr,n);
}
}
 
// This code is contributed by 29AjayKumar

Javascript




// Javascript implementation of the approach
 
let MOD = 1000000007;
let SIZE = 10000;
 
// Function to calculate the factorial
// using dynamic programming
function factorial(fact)
{
    fact[0] = 1;
    for (let i = 1; i <= SIZE; i++)
    {
 
        // Calculation of factorial
        // As fact[i-1] stores the factorial of n-1
        // so factorial of n is fact[i] = (fact[i-1]*i)
        fact[i] = (fact[i - 1] * i) % MOD;
    }
    return fact;
}
 
// Function to print factorial of every element
// of the array
function PrintFactorial(fact, arr, n)
{
    for(let i = 0; i < n; i++)
    {
 
        // Printing the stored value of arr[i]!
        document.write(fact[arr[i]] + " ");
    }
}
 
    // Driver code
    // vector to store the factorial values
    // max_element(arr) should be less than SIZE
    let fact = new Array(SIZE + 1).fill(0);
 
    let arr = new Array(3, 10, 200, 20, 12);
    let n = arr.length;
 
    // Function to store factorial values mod 10**9+7
    fact = factorial(fact);
 
    // Function to print the factorial values mod 10**9+7
    PrintFactorial(fact,arr,n);
 
    // This code is contributed by gfgking
Output: 
6 3628800 722479105 146326063 479001600

 

Time Complexity : O(N) 
Space Complexity : O(N)
 




My Personal Notes arrow_drop_up
Recommended Articles
Page :