Sum and Product of the nodes of a Singly Linked List which are divisible by K
Given a singly linked list. The task is to find the sum and product of all of the nodes of the given linked list which are divisible by a given number k.
Examples:
Input : List = 7->60->8->40->1
k = 10
Output : Product = 2400, Sum = 100
Product of nodes: 60 * 40 = 2400
Input : List = 15->7->3->9->11->5
k = 5
Output : Product = 75, Sum = 20
Algorithm:
- Initialize a pointer ptr with the head of the linked list, a product variable with 1 and a sum variable with 0.
- Start traversing the linked list using a loop until all the nodes get traversed.
- For every node:
- Multiply the value of the current node to the product if current node is divisible by k.
- Add the value of the current node to the sum if current node is divisible by k.
- Increment the pointer to the next node of linked list i.e. ptr = ptr ->next.
- Repeat the above steps until end of linked list is reached.
- Finally, print the product and sum.
Below is the implementation of the above approach:
C++
// C++ implementation to find the product // and sum of nodes which are divisible by k #include <iostream> using namespace std; // A Linked list node struct Node { int data; struct Node* next; }; // Function to insert a node at the // beginning of the linked list void push(struct Node** head_ref, int new_data) { /* allocate node */ struct Node* new_node = new Node; /* put in the data */ new_node->data = new_data; /* link the old list to the new node */ new_node->next = (*head_ref); /* move the head to point to the new node */ (*head_ref) = new_node; } // Function to find the product and sum of // nodes which are divisible by k // of the given linked list void productAndSum(struct Node* head, int k) { // Pointer to traverse the list struct Node* ptr = head; int product = 1; // Variable to store product int sum = 0; // Variable to store sum // Traverse the list and // calculate the product // and sum while (ptr != NULL) { if (ptr->data % k == 0) { product *= ptr->data; sum += ptr->data; } ptr = ptr->next; } // Print the product and sum cout << "Product = " << product << endl; cout << "Sum = " << sum; } // Driver Code int main() { struct Node* head = NULL; // create linked list 70->6->8->4->10 push(&head, 70); push(&head, 6); push(&head, 8); push(&head, 4); push(&head, 10); int k = 10; productAndSum(head, k); return 0; } |
chevron_right
filter_none
Java
// Java implementation to find the product // and sum of nodes which are divisible by k class GFG { // A Linked list node static class Node { int data; Node next; }; // Function to insert a node at the // beginning of the 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 to 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 find the product and sum of // nodes which are divisible by k // of the given linked list static void productAndSum( Node head, int k) { // Pointer to traverse the list Node ptr = head; int product = 1; // Variable to store product int sum = 0; // Variable to store sum // Traverse the list and // calculate the product // and sum while (ptr != null) { if (ptr.data % k == 0) { product *= ptr.data; sum += ptr.data; } ptr = ptr.next; } // Print the product and sum System.out.println( "Product = " + product ); System.out.println( "Sum = " + sum); } // Driver Code public static void main(String args[]) { Node head = null; // create linked list 70.6.8.4.10 head = push(head, 70); head = push(head, 6); head = push(head, 8); head = push(head, 4); head = push(head, 10); int k = 10; productAndSum(head, k); } } // This code is contributed by Arnab Kundu |
chevron_right
filter_none
Python3
# Python3 implementation to find the product # and sum of nodes which are divisible by k import math # A Linked list node class Node: def __init__(self, data): self.data = data self.next = None # Function to insert a node at the # beginning of the linked list def push(head_ref, new_data): # allocate node new_node =Node(new_data) # put in the data new_node.data = new_data # link the old list to 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 find the product and sum of # nodes which are divisible by k # of the given linked list def productAndSum(head, k): # Pointer to traverse the list ptr = head product = 1 # Variable to store product add = 0 # Variable to store sum # Traverse the list and # calculate the product # and sum while (ptr != None): if (ptr.data % k == 0): product = product * ptr.data add = add + ptr.data ptr = ptr.next # Print the product and sum print("Product =", product) print("Sum =", add) # Driver Code if __name__=='__main__': head = None # create linked list 70.6.8.4.10 head = push(head, 70) head = push(head, 6) head = push(head, 8) head = push(head, 4) head = push(head, 10) k = 10 productAndSum(head, k) # This code is contributed by Srathore |
chevron_right
filter_none
C#
// C# implementation to find the product // and sum of nodes which are divisible by k using System; class GFG { // A Linked list node public class Node { public int data; public Node next; }; // Function to insert a node at the // beginning of the 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 to 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 find the product and sum of // nodes which are divisible by k // of the given linked list static void productAndSum( Node head, int k) { // Pointer to traverse the list Node ptr = head; int product = 1; // Variable to store product int sum = 0; // Variable to store sum // Traverse the list and // calculate the product // and sum while (ptr != null) { if (ptr.data % k == 0) { product *= ptr.data; sum += ptr.data; } ptr = ptr.next; } // Print the product and sum Console.WriteLine( "Product = " + product ); Console.WriteLine( "Sum = " + sum); } // Driver Code public static void Main(String []args) { Node head = null; // create linked list 70.6.8.4.10 head = push(head, 70); head = push(head, 6); head = push(head, 8); head = push(head, 4); head = push(head, 10); int k = 10; productAndSum(head, k); } } /* This code contributed by PrinciRaj1992 */ |
chevron_right
filter_none
Output:
Product = 700 Sum = 80
Time Complexity: O(N), where N is the number of nodes in the linked list.
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.
