Sum and Product of all Prime Nodes of a Singly Linked List
Given a singly linked list containing N nodes, the task is to find the sum and product of all nodes from the list which are prime.
Examples:
Input : List = 15 -> 16 -> 6 -> 7 -> 17 Output : Product = 119, Sum = 24 Prime nodes are 7, 17. Input : List = 15 -> 3 -> 4 -> 2 -> 9 Output : Product = 6, Sum = 5
Approach: The idea is to traverse the nodes of the singly linked list one by one and check if the current node is prime or not. Find the sum and product of the data of the nodes which are prime.
Below is the implementation of above idea:
C++
// C++ implementation to find sum and // product of all of prime nodes of // the singly 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 of the new node new_node->next = (*head_ref); // move the head to point to the new node (*head_ref) = new_node; } // Function to check if a number is prime bool isPrime( int 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 || 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 find sum and product of all // prime nodes of the singly linked list void sumAndProduct(Node* head_ref) { int prod = 1; int sum = 0; Node* ptr = head_ref; // Traverse the linked list while (ptr != NULL) { // if current node is prime, // Find sum and product if (isPrime(ptr->data)) { prod *= ptr->data; sum += ptr->data; } ptr = ptr->next; } cout << "Sum = " << sum << endl; cout << "Product = " << prod; } // Driver program int main() { // start with the empty list Node* head = NULL; // create the linked list // 15 -> 16 -> 7 -> 6 -> 17 push(&head, 17); push(&head, 7); push(&head, 6); push(&head, 16); push(&head, 15); sumAndProduct(head); return 0; } |
Java
// Java implementation to find sum and // product of all of prime nodes of // the singly linked list 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 of 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 check if a number is prime static boolean isPrime( int 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 || 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 find sum and product of all // prime nodes of the singly linked list static void sumAndProduct(Node head_ref) { int prod = 1 ; int sum = 0 ; Node ptr = head_ref; // Traverse the linked list while (ptr != null ) { // if current node is prime, // Find sum and product if (isPrime(ptr.data)) { prod *= ptr.data; sum += ptr.data; } ptr = ptr.next; } System.out.println( "Sum = " + sum ); System.out.println( "Product = " + prod); } // Driver code public static void main(String args[]) { // start with the empty list Node head = null ; // create the linked list // 15 . 16 . 7 . 6 . 17 head=push(head, 17 ); head=push(head, 7 ); head=push(head, 6 ); head=push(head, 16 ); head=push(head, 15 ); sumAndProduct(head); } } // This code is contributed by Arnab Kundu |
Python
# Python implementation to find sum and # product of all of prime nodes of # the singly linked list # Link list node 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 of 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 check if a number is prime 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 = i + 6 return True # Function to find sum and product of all # prime nodes of the singly linked list def sumAndProduct(head_ref) : prod = 1 sum = 0 ptr = head_ref # Traverse the linked list while (ptr ! = None ): # if current node is prime, # Find sum and product if (isPrime(ptr.data)): prod * = ptr.data sum + = ptr.data ptr = ptr. next print ( "Sum = " , sum ) print ( "Product = " , prod) # Driver code # start with the empty list head = None # create the linked list # 15 . 16 . 7 . 6 . 17 head = push(head, 17 ) head = push(head, 7 ) head = push(head, 6 ) head = push(head, 16 ) head = push(head, 15 ) sumAndProduct(head) # This code is contributed by Arnab Kundu |
C#
// C# implementation to find sum and // product of all of prime nodes of // the singly linked list using System; class GFG { // Node of the singly linked list public 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 of 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 check if a number is prime static bool isPrime( int 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 || 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 find sum and product of all // prime nodes of the singly linked list static void sumAndProduct(Node head_ref) { int prod = 1; int sum = 0; Node ptr = head_ref; // Traverse the linked list while (ptr != null ) { // if current node is prime, // Find sum and product if (isPrime(ptr.data)) { prod *= ptr.data; sum += ptr.data; } ptr = ptr.next; } Console.WriteLine( "Sum = " + sum); Console.WriteLine( "Product = " + prod); } // Driver code public static void Main(String []args) { // start with the empty list Node head = null ; // create the linked list // 15 . 16 . 7 . 6 . 17 head = push(head, 17); head = push(head, 7); head = push(head, 6); head = push(head, 16); head = push(head, 15); sumAndProduct(head); } } // This code is contributed by 29AjayKumar |
Javascript
<script> // javascript implementation to find sum and // product of all of prime nodes of // the singly 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 of 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 check if a number is prime function 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 || n % 3 == 0) return false ; for (i = 5; i * i <= n; i = i + 6) if (n % i == 0 || n % (i + 2) == 0) return false ; return true ; } // Function to find sum and product of all // prime nodes of the singly linked list function sumAndProduct(head_ref) { var prod = 1; var sum = 0; var ptr = head_ref; // Traverse the linked list while (ptr != null ) { // if current node is prime, // Find sum and product if (isPrime(ptr.data)) { prod *= ptr.data; sum += ptr.data; } ptr = ptr.next; } document.write( "Sum = " + sum); document.write( "<br/>Product = " + prod); } // Driver code // start with the empty list var head = null ; // create the linked list // 15 . 16 . 7 . 6 . 17 head = push(head, 17); head = push(head, 7); head = push(head, 6); head = push(head, 16); head = push(head, 15); sumAndProduct(head); // This code contributed by umadevi9616 </script> |
Sum = 24 Product = 119
complexity Analysis:
- Time Complexity: O(N), where N is the number of nodes in the linked list.
- Auxiliary Space: O(1) because it is using constant space
Approach (Recursive):
We can traverse the linked list recursively and for each node, check if it is prime or not. If it is prime, we add its value to the sum and multiply its value to the product. Then we call the same function recursively for the next node until we reach the end of the list.
- Create a recursive function that takes a pointer to the head of the linked list, a pointer to an integer variable that will hold the sum of prime nodes, and a pointer to an integer variable that will hold the product of prime nodes.
- Check if the head pointer is NULL. If it is, return from the function.
- If the data of the current node is prime, add it to the sum and multiply it to the product.
- Recursively call the function with the next node in the linked list and the updated sum and product variables.
- In the calling function, print the final values of the sum and product variables.
Below is the implementation of the above approach:
C++
#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 = new Node; // put in the data new_node->data = new_data; // link the old list of the new node new_node->next = (*head_ref); // move the head to point to the new node (*head_ref) = new_node; } // Function to check if a number is prime bool isPrime( int 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 || 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 find sum and product of all // prime nodes of the singly linked list void sumAndProductUtil(Node* node, int & prod, int & sum) { if (node == NULL) return ; // Check if the current node is prime if (isPrime(node->data)) { prod *= node->data; sum += node->data; } // Recursively call the function for the next node sumAndProductUtil(node->next, prod, sum); } // Wrapper function for the sumAndProductUtil function void sumAndProduct(Node* head) { int prod = 1; int sum = 0; sumAndProductUtil(head, prod, sum); cout << "Sum = " << sum << endl; cout << "Product = " << prod; } // Driver program int main() { // start with the empty list Node* head = NULL; // create the linked list // 15 -> 16 -> 7 -> 6 -> 17 push(&head, 17); push(&head, 7); push(&head, 6); push(&head, 16); push(&head, 15); sumAndProduct(head); return 0; } |
Java
// Java program to implement the above approach // Node of the singly linked list class Node { int data; Node next; Node( int data) { this .data = data; this .next = null ; } } public class GFG { // Function to insert a node at the beginning // of the singly Linked List static Node push(Node head, int new_data) { // allocate node Node new_node = new Node(new_data); // link the old list of the new node new_node.next = head; // move the head to point to the new node head = new_node; return head; } // Function to check if a number is prime static boolean isPrime( int 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 || 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 find sum and product of all // prime nodes of the singly linked list static void sumAndProduct(Node node) { int prod = 1 ; int sum = 0 ; // Traverse the linked list while (node != null ) { // Check if the current node is prime if (isPrime(node.data)) { prod *= node.data; sum += node.data; } node = node.next; } System.out.println( "Sum = " + sum); System.out.println( "Product = " + prod); } // Driver program public static void main(String[] args) { // Start with an empty list Node head = null ; // Create the linked list // 15 -> 16 -> 7 -> 6 -> 17 head = push(head, 17 ); head = push(head, 7 ); head = push(head, 6 ); head = push(head, 16 ); head = push(head, 15 ); // Calculate and print sum and product of prime // nodes sumAndProduct(head); } } // This code is contributed by Susobhan Akhuli |
Python3
# Python program to implement the above approach class Node: def __init__( self , data): self .data = data self . next = None # Function to insert a node at the beginning of the singly Linked List def push(head_ref, new_data): # allocate node new_node = Node(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 check if a number is prime 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 find sum and product of all prime nodes of the singly linked list def sumAndProductUtil(node, prod, sum ): if node is None : return sum , prod # Check if the current node is prime if isPrime(node.data): prod * = node.data sum + = node.data # Recursively call the function for the next node return sumAndProductUtil(node. next , prod, sum ) # Wrapper function for the sumAndProductUtil function def sumAndProduct(head): prod = 1 sum = 0 sum , prod = sumAndProductUtil(head, prod, sum ) print ( "Sum =" , sum ) print ( "Product =" , prod) # Driver program if __name__ = = '__main__' : # start with the empty list head = None # create the linked list # 15 -> 16 -> 7 -> 6 -> 17 head = push(head, 17 ) head = push(head, 7 ) head = push(head, 6 ) head = push(head, 16 ) head = push(head, 15 ) sumAndProduct(head) # This code is contributed by Susobhan Akhuli |
C#
using System; public class Node { public int data; public Node next; public Node( int data) { this .data = data; this .next = null ; } } public class LinkedList { public Node head; // Function to insert a node at the beginning of the // singly Linked List public void Push( int new_data) { // Allocate a new node Node new_node = new Node(new_data); // Link the old list off the new node new_node.next = head; // Move the head to point to the new node head = new_node; } } public class Program { // Function to check if a number is prime public static bool IsPrime( int 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 the below loop if (n % 2 == 0 || n % 3 == 0) return false ; int i = 5; while (i * i <= n) { if (n % i == 0 || n % (i + 2) == 0) return false ; i += 6; } return true ; } // Function to find sum and product of all prime nodes // of the singly linked list public static void SumAndProductUtil(Node node, ref int prod, ref int sum) { if (node == null ) return ; // Check if the current node is prime if (IsPrime(node.data)) { prod *= node.data; sum += node.data; } // Recursively call the function for the next node SumAndProductUtil(node.next, ref prod, ref sum); } // Wrapper function for the SumAndProductUtil function public static void SumAndProduct(LinkedList list) { int prod = 1; int sum = 0; SumAndProductUtil(list.head, ref prod, ref sum); Console.WriteLine( "Sum = " + sum); Console.WriteLine( "Product = " + prod); } public static void Main( string [] args) { // Start with an empty list LinkedList list = new LinkedList(); // Create the linked list: 15 -> 16 -> 7 -> 6 -> 17 list.Push(17); list.Push(7); list.Push(6); list.Push(16); list.Push(15); SumAndProduct(list); } } |
Javascript
<script> // JavaScript program to implement the above approach // Node of the singly linked list class Node { constructor(data) { this .data = data; this .next = null ; } } // Function to insert a node at the beginning // of the singly Linked List function push(headRef, newData) { // Allocate node const newNode = new Node(newData); // Link the old list to the new node newNode.next = headRef; // Move the head to point to the new node headRef = newNode; return headRef; } // Function to check if a number is prime function isPrime(n) { // Corner cases if (n <= 1) return false ; if (n <= 3) return true ; // Check if n is divisible by 2 or 3 if (n % 2 === 0 || n % 3 === 0) return false ; // Check for prime numbers using 6k +/- 1 rule for (let i = 5; i * i <= n; i = i + 6) { if (n % i === 0 || n % (i + 2) === 0) return false ; } return true ; } // Function to find sum and product of all // prime nodes of the singly linked list function sumAndProductUtil(node, sol) { if (node === null ) return ; // Check if the current node is prime if (isPrime(node.data)) { sol.prod *= node.data; sol.sum += node.data; } // Recursively call the function for the next node sumAndProductUtil(node.next, sol); } // Wrapper function for the sumAndProductUtil function function sumAndProduct(head) { let sol = { prod: 1, sum: 0 }; sumAndProductUtil(head, sol); document.write( "Sum = " , sol.sum); document.write( "<br>" ); document.write( "Product = " , sol.prod); } // Start with an empty list let head = null ; // Create the linked list: 15 -> 16 -> 7 -> 6 -> 17 head = push(head, 17); head = push(head, 7); head = push(head, 6); head = push(head, 16); head = push(head, 15); sumAndProduct(head); // This code is contributed by Susobhan Akhuli </script> |
Output:
Sum = 24
Product = 119
Time Complexity: O(n), where n is the number of nodes in the linked list.
Auxiliary Space: O(p), where p is the number of prime nodes in the linked list.
Contact Us