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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation to fine Sum of
// prime factorials in a Linked list
  
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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);
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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)

chevron_right


Output:

8

java-img




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.