# Prefix Factorials of a Prefix Sum Array

• Difficulty Level : Medium
• Last Updated : 06 Sep, 2021

Given an array arr[] consisting of N positive integers, the task is to find the prefix factorials of a prefix sum array of the given array i.e., .

Examples:

Input: arr[] = {1, 2, 3, 4}
Output: 1 6 720 3628800
Explanation:
The prefix sum of the given array is {1, 3, 6, 10}. Therefore, prefix factorials of the obtained prefix sum array is {1!, (1+2)!, (1+2+3)!, (1+2+3+4)!} = {1!, 3!, 6!, 10!} = {1 6 720 3628800}.

Input: arr[] = {2, 4, 3, 1}
Output: 2 720 362880 3628800

Naive Approach: The simplest approach to solve the given problem is to find the prefix sum of the given array and then find the factorial of each array element in the prefix sum array. After calculating the prefix sum print the factorial array.

Below is the implementation of the above approach.

## C++

 // C++ program for the above approach   #include  using namespace std;   // Function to find the factorial of // a number N int fact(int N) {     // Base Case     if (N == 1 || N == 0)         return 1;       // Find the factorial recursively     return N * fact(N - 1); }   // Function to find the prefix // factorial array void prefixFactorialArray(int arr,                           int N) {     // Find the prefix sum array     for (int i = 1; i < N; i++) {         arr[i] += arr[i - 1];     }       // Find the factorials of each     // array element     for (int i = 0; i < N; i++) {         arr[i] = fact(arr[i]);     }       // Print the resultant array     for (int i = 0; i < N; i++) {         cout << arr[i] << " ";     } }   // Driver Code int main() {     int arr[] = { 1, 2, 3, 4 };     int N = sizeof(arr) / sizeof(arr[0]);     prefixFactorialArray(arr, N);       return 0; }

## Java

 // Java program for the above approach class GFG{   // Function to find the factorial of // a number N static int fact(int N) {           // Base Case     if (N == 1 || N == 0)         return 1;       // Find the factorial recursively     return N * fact(N - 1); }   // Function to find the prefix // factorial array static void prefixFactorialArray(int[] arr, int N) {       // Find the prefix sum array     for(int i = 1; i < N; i++)      {         arr[i] += arr[i - 1];     }       // Find the factorials of each     // array element     for(int i = 0; i < N; i++)     {         arr[i] = fact(arr[i]);     }       // Print the resultant array     for(int i = 0; i < N; i++)     {         System.out.print(arr[i] + " ");     } }   // Driver Code public static void main(String[] args) {     int[] arr = { 1, 2, 3, 4 };     int N = arr.length;       prefixFactorialArray(arr, N); } }   // This code is contributed by ukasp

## Python3

 # Python implementation of the approach def fact(N):         # Base Case     if (N == 1 or N == 0):         return 1       # Find the factorial recursively     return N * fact(N - 1)     # Function to find the prefix # factorial array def prefixFactorialArray(arr, N):       # Find the prefix sum array     for i in range(1, N):         arr[i] += arr[i - 1]       # Find the factorials of each     # array element     for i in range(N):         arr[i] = fact(arr[i])           # Print the resultant array     for i in range(N):         print(arr[i], end=" ")   # Driver Code if __name__ == "__main__":       arr = [1, 2, 3, 4]     N = len(arr)     prefixFactorialArray(arr, N)   # This code is contributed by kirtishsurangalikar

## C#

 // C# program for the above approach using System;           class GFG{   // Function to find the factorial of // a number N static int fact(int N) {           // Base Case     if (N == 1 || N == 0)         return 1;       // Find the factorial recursively     return N * fact(N - 1); }   // Function to find the prefix // factorial array static void prefixFactorialArray(int[] arr,                                  int N) {           // Find the prefix sum array     for(int i = 1; i < N; i++)     {         arr[i] += arr[i - 1];     }       // Find the factorials of each     // array element     for(int i = 0; i < N; i++)     {         arr[i] = fact(arr[i]);     }       // Print the resultant array     for(int i = 0; i < N; i++)      {         Console.Write(arr[i] + " ");     } }       // Driver Code public static void Main() {     int[] arr = { 1, 2, 3, 4 };     int N = arr.Length;           prefixFactorialArray(arr, N); } }   // This code is contributed by code_hunt

## Javascript

 

Output:

1 6 720 3628800

Time Complexity: O(N*M), where M is the sum of the array elements
Auxiliary Space: O(1)

Efficient Approach: The above approach can also be optimized by precalculating the factorial of sum of the array elements so that the factorial calculation at each index is can be calculated in O(1) time.

Below is an implementation of the above approach:

## C++

 // C++ program for the above approach   #include  using namespace std;   // Function to find the factorial of // prefix sum at every possible index void prefixFactorialArray(int A[], int N) {     // Find the prefix sum array     for (int i = 1; i < N; i++) {         A[i] += A[i - 1];     }       // Stores the factorial of all the     // element till the sum of array     int fact[A[N - 1] + 1];     fact[0] = 1;       // Find the factorial array     for (int i = 1; i <= A[N - 1]; i++) {         fact[i] = i * fact[i - 1];     }       // Find the factorials of     // each array element     for (int i = 0; i < N; i++) {         A[i] = fact[A[i]];     }       // Print the resultant array     for (int i = 0; i < N; i++) {         cout << A[i] << " ";     } }   // Driver Code int main() {     int arr[] = { 1, 2, 3, 4 };     int N = sizeof(arr) / sizeof(arr[0]);     prefixFactorialArray(arr, N);       return 0; }

## Java

 // Java program for the above approach class GFG{   // Function to find the factorial of // prefix sum at every possible index static void prefixFactorialArray(int A[], int N) {           // Find the prefix sum array     for(int i = 1; i < N; i++)     {         A[i] += A[i - 1];     }       // Stores the factorial of all the     // element till the sum of array     int fact[] = new int[A[N - 1] + 1];     fact[0] = 1;       // Find the factorial array     for(int i = 1; i <= A[N - 1]; i++)     {         fact[i] = i * fact[i - 1];     }       // Find the factorials of     // each array element     for(int i = 0; i < N; i++)     {         A[i] = fact[A[i]];     }       // Print the resultant array     for(int i = 0; i < N; i++)      {         System.out.print(A[i] + " ");     } }   // Driver code public static void main(String[] args) {     int arr[] = { 1, 2, 3, 4 };     int N = arr.length;           prefixFactorialArray(arr, N); } }   // This code is contributed by abhinavjain194

## Python3

 # // python program for the above approach   # // Function to find the factorial of # // prefix sum at every possible index def prefixFactorialArray(A, N):         # // Find the prefix sum array     for i in range(1, N):         A[i] += A[i - 1]       # // Stores the factorial of all the     # // element till the sum of array     fact = [0 for x in range(A[N - 1] + 1)]     fact[0] = 1       # // Find the factorial array     for i in range(1, A[N-1]+1):         fact[i] = i * fact[i - 1]       # // Find the factorials of     # // each array element     for i in range(0, N):         A[i] = fact[A[i]]               # // Print the resultant array     for i in range(0, N):         print(A[i], end=" ")   # Driver code arr = [1, 2, 3, 4] N = len(arr) prefixFactorialArray(arr, N)   # This code is contributed by amreshkumar3.

## C#

 // C# program for the above approach using System; class GFG {           // Function to find the factorial of     // prefix sum at every possible index     static void prefixFactorialArray(int[] A, int N)     {                    // Find the prefix sum array         for(int i = 1; i < N; i++)         {             A[i] += A[i - 1];         }                // Stores the factorial of all the         // element till the sum of array         int[] fact = new int[A[N - 1] + 1];         fact[0] = 1;                // Find the factorial array         for(int i = 1; i <= A[N - 1]; i++)         {             fact[i] = i * fact[i - 1];         }                // Find the factorials of         // each array element         for(int i = 0; i < N; i++)         {             A[i] = fact[A[i]];         }                // Print the resultant array         for(int i = 0; i < N; i++)         {             Console.Write(A[i] + " ");         }     }     // Driver code   static void Main() {     int[] arr = { 1, 2, 3, 4 };     int N = arr.Length;            prefixFactorialArray(arr, N);   } }   // This code is contributed by divyeshrabadiya07.

## Javascript

 

Output:

1 6 720 3628800

Time Complexity: O(N + M), where M is the sum of the array elements.
Auxiliary Space: O(M), where M is the sum of the array elements.

My Personal Notes arrow_drop_up
Recommended Articles
Page :