Related Articles

# Sum of factorials of Prime numbers in a Linked list

• Last Updated : 18 Jun, 2021

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:
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)`

## C#

 `// C# implementation to find Sum of``// prime factorials in a Linked list``using` `System;` `class` `GFG{` `// Node of the singly linked list``class` `Node``{``    ``public` `int` `data;``    ``public` `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` `bool` `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);` `    ``Console.WriteLine(ans);``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``
Output:
`8`

Attention reader! Don’t stop learning now. Join the First-Step-to-DSA Course for Class 9 to 12 students , specifically designed to introduce data structures and algorithms to the class 9 to 12 students

My Personal Notes arrow_drop_up