# Sum of factorials of Prime numbers in a Linked list

Given a Linked list of N integers, the task is to find the sum of factorials of each prime element in the list.

Examples:

Input: L1 = 4 -> 6 -> 2 -> 12 -> 3
Output: 8
Explanation:
Prime numbers are 2 and 3, hence 2! + 3! = 2 + 6 = 8.

Input: L1 = 7 -> 4 -> 5
Output: 5160
Explanation:
Prime numbers are 7 and 5, hence 7! + 5! = 5160.

Approach: To solve the problem mentioned above follow the steps given below:

• Implement a function factorial(n) that finds the factorial of N .
• Initialize a variable sum = 0. Now, traverse the given list and for each node check whether node is prime or not.
• If node is prime then update sum = sum + factorial(node) otherwise else move the node to next.
• Print the calculated sum in the end.

Below is the implementation of the above approach:

## C++

 `// C++ implementation to fine Sum of ` `// prime factorials in a Linked list ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Node of the singly linked list ` `struct` `Node { ` `    ``int` `data; ` `    ``Node* next; ` `}; ` ` `  `// Function to insert a node ` `// at the beginning ` `// of the singly Linked List ` `void` `push(Node** head_ref, ``int` `new_data) ` `{ ` `    ``// allocate node ` `    ``Node* new_node ` `        ``= (Node*)``malloc``( ` `            ``sizeof``(``struct` `Node)); ` ` `  `    ``// put in the data ` `    ``new_node->data = new_data; ` ` `  `    ``// link the old list ` `    ``// off the new node ` `    ``new_node->next = (*head_ref); ` ` `  `    ``// move the head to point ` `    ``// to the new node ` `    ``(*head_ref) = new_node; ` `} ` ` `  `// Function to return the factorial of N ` `int` `factorial(``int` `n) ` `{ ` `    ``int` `f = 1; ` `    ``for` `(``int` `i = 1; i <= n; i++) { ` `        ``f *= i; ` `    ``} ` `    ``return` `f; ` `} ` ` `  `// Function to check if number is prime ` `bool` `isPrime(``int` `n) ` `{ ` `    ``if` `(n <= 1) ` `        ``return` `false``; ` `    ``if` `(n <= 3) ` `        ``return` `true``; ` ` `  `    ``if` `(n % 2 == 0 || n % 3 == 0) ` `        ``return` `false``; ` ` `  `    ``for` `(``int` `i = 5; i * i <= n; i = i + 6) ` `        ``if` `(n % i == 0 ` `            ``|| n % (i + 2) == 0) ` `            ``return` `false``; ` ` `  `    ``return` `true``; ` `} ` ` `  `// Function to return the sum of ` `// factorials of the LL elements ` `int` `sumFactorial(Node* head_1) ` `{ ` ` `  `    ``// To store the required sum ` `    ``Node* ptr = head_1; ` `    ``int` `s = 0; ` `    ``while` `(ptr != NULL) { ` ` `  `        ``// Add factorial of all the elements ` `        ``if` `(isPrime(ptr->data)) { ` `            ``s += factorial(ptr->data); ` `            ``ptr = ptr->next; ` `        ``} ` `        ``else` `            ``ptr = ptr->next; ` `    ``} ` `    ``return` `s; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``Node* head1 = NULL; ` ` `  `    ``push(&head1, 4); ` `    ``push(&head1, 6); ` `    ``push(&head1, 2); ` `    ``push(&head1, 12); ` `    ``push(&head1, 3); ` ` `  `    ``cout << sumFactorial(head1); ` `    ``return` `0; ` `} `

## Java

 `// Java implementation to find Sum of ` `// prime factorials in a Linked list ` ` `  `import` `java.util.*; ` ` `  `class` `GFG { ` ` `  `    ``// Node of the singly linked list ` `    ``static` `class` `Node { ` `        ``int` `data; ` `        ``Node next; ` `    ``}; ` ` `  `    ``// Function to insert a ` `    ``// node at the beginning ` `    ``// of the singly Linked List ` `    ``static` `Node push( ` `        ``Node head_ref, ` `        ``int` `new_data) ` `    ``{ ` `        ``// allocate node ` `        ``Node new_node = ``new` `Node(); ` ` `  `        ``// put in the data ` `        ``new_node.data = new_data; ` ` `  `        ``// link the old list ` `        ``// off the new node ` `        ``new_node.next = (head_ref); ` ` `  `        ``// move the head to point ` `        ``// to the new node ` `        ``(head_ref) = new_node; ` `        ``return` `head_ref; ` `    ``} ` ` `  `    ``// Function to return ` `    ``// the factorial of n ` `    ``static` `int` `factorial(``int` `n) ` `    ``{ ` `        ``int` `f = ``1``; ` `        ``for` `(``int` `i = ``1``; i <= n; i++) { ` `            ``f *= i; ` `        ``} ` `        ``return` `f; ` `    ``} ` ` `  `    ``// Function to check if number is prime ` `    ``static` `boolean` `isPrime(``int` `n) ` `    ``{ ` `        ``// Corner cases ` `        ``if` `(n <= ``1``) ` `            ``return` `false``; ` `        ``if` `(n <= ``3``) ` `            ``return` `true``; ` ` `  `        ``if` `(n % ``2` `== ``0` `|| n % ``3` `== ``0``) ` `            ``return` `false``; ` ` `  `        ``for` `(``int` `i = ``5``; i * i <= n; i = i + ``6``) ` `            ``if` `(n % i == ``0` `                ``|| n % (i + ``2``) == ``0``) ` `                ``return` `false``; ` ` `  `        ``return` `true``; ` `    ``} ` ` `  `    ``// Function to return the sum of ` `    ``// factorials of the LL elements ` `    ``static` `int` `sumFactorial(Node head_1) ` `    ``{ ` `        ``Node ptr = head_1; ` `        ``// To store the required sum ` `        ``int` `s = ``0``; ` `        ``while` `(ptr != ``null``) { ` ` `  `            ``// Add factorial of ` `            ``// all the elements ` `            ``if` `(isPrime(ptr.data)) { ` `                ``s += factorial(ptr.data); ` `                ``ptr = ptr.next; ` `            ``} ` `            ``else` `{ ` `                ``ptr = ptr.next; ` `            ``} ` `        ``} ` `        ``return` `s; ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` ` `  `        ``Node head1 = ``null``; ` ` `  `        ``head1 = push(head1, ``4``); ` `        ``head1 = push(head1, ``6``); ` `        ``head1 = push(head1, ``2``); ` `        ``head1 = push(head1, ``12``); ` `        ``head1 = push(head1, ``3``); ` `        ``int` `ans = sumFactorial(head1); ` ` `  `        ``System.out.println(ans); ` `    ``} ` `} `

## Python3

 `# Python implementation of the approach  ` `class` `Node:   ` `          `  `    ``def` `__init__(``self``, data):   ` `        ``self``.data ``=` `data   ` `        ``self``.``next` `=` `next` `              `  `# Function to insert a ` `# node at the beginning   ` `# of the singly Linked List   ` `def` `push( head_ref, new_data) :  ` `      `  `    ``# allocate node   ` `    ``new_node ``=` `Node(``0``)   ` `      `  `    ``# put in the data   ` `    ``new_node.data ``=` `new_data   ` `      `  `    ``# link the old list ` `    ``# off the new node   ` `    ``new_node.``next` `=` `(head_ref)   ` `      `  `    ``# move the head to ` `    ``# point to the new node   ` `    ``(head_ref) ``=` `new_node  ` `    ``return` `head_ref ` `     `  `def` `factorial(n):  ` `    ``f ``=` `1``;  ` `    ``for` `i ``in` `range``(``1``, n ``+` `1``):  ` `        ``f ``*``=` `i;  ` `    ``return` `f;  ` `  ``# prime for def   ` `def` `isPrime(n):  ` `    `  `    ``# Corner cases  ` `    ``if` `(n <``=` `1``):  ` `        ``return` `False` `    ``if` `(n <``=` `3``):  ` `        ``return` `True` `    `  `    ``# This is checked so that we can skip  ` `    ``# middle five numbers in below loop  ` `    ``if` `(n ``%` `2` `=``=` `0` `or` `n ``%` `3` `=``=` `0``):  ` `        ``return` `False` `    ``i ``=` `5` `    ``while` `( i ``*` `i <``=` `n ):  ` `        ``if` `(n ``%` `i ``=``=` `0`  `            ``or` `n ``%` `(i ``+` `2``) ``=``=` `0``):  ` `            ``return` `False` `        ``i ``+``=` `6``;  ` `    `  `    ``return` `True` `   `  `# Function to return the sum of  ` `# factorials of the LL elements  ` `def` `sumFactorial(head_ref1):  ` `   `  `    ``# To store the required sum  ` `    ``s ``=` `0``;  ` `    ``ptr1 ``=` `head_ref1 ` `    ``while` `(ptr1 !``=` `None``) :  ` `   `  `        ``# Add factorial of all the elements ` `        ``if``(isPrime(ptr1.data)): ` `            ``s ``+``=` `factorial(ptr1.data); ` `            ``ptr1 ``=` `ptr1.``next` `        ``else``: ` `            ``ptr1 ``=` `ptr1.``next` `    ``return` `s;  ` `# Driver code   ` `# start with the empty list   ` `head1 ``=` `None` `# create the linked list   ` `head1 ``=` `push(head1, ``4``)   ` `head1 ``=` `push(head1, ``6``)   ` `head1 ``=` `push(head1, ``2``)   ` `head1 ``=` `push(head1, ``12``)   ` `head1 ``=` `push(head1, ``3``) ` `ans ``=` `sumFactorial(head1) ` `print``(ans) `

Output:

```8
```

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.