Skip to content
Related Articles

Related Articles

Improve Article

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

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




<script>
      // JavaScript implementation to find Sum of
      // prime factorials in a Linked list
      // Node of the singly linked list
      class Node {
        constructor() {
          this.data = 0;
          this.next = null;
        }
      }
 
      // Function to insert a node
      // at the beginning of the
      // singly Linked List
      function push(head_ref, new_data)
      {
       
        // Allocate node
        var 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
      function factorial(n) {
        var f = 1;
        for (var i = 1; i <= n; i++) {
          f *= i;
        }
        return f;
      }
 
      // Function to check if number
      // is prime
      function isPrime(n) {
        // Corner cases
        if (n <= 1) return false;
        if (n <= 3) return true;
 
        if (n % 2 == 0 || n % 3 == 0) return false;
 
        for (var 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
      function sumFactorial(head_1) {
        var ptr = head_1;
 
        // To store the required sum
        var 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
      var head1 = null;
 
      head1 = push(head1, 4);
      head1 = push(head1, 6);
      head1 = push(head1, 2);
      head1 = push(head1, 12);
      head1 = push(head1, 3);
 
      var ans = sumFactorial(head1);
 
      document.write(ans);
       
      // This code is contributed by rdtank.
    </script>
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
Recommended Articles
Page :