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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Algorithm:

1. Initialize a pointer ptr with the head of the linked list, a product variable with 1 and a sum variable with 0.
2. Start traversing the linked list using a loop until all the nodes get traversed.
3. 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.
4. Increment the pointer to the next node of linked list i.e. ptr = ptr ->next.
5. Repeat the above steps until end of linked list is reached.
6. 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 ` `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; ` `} `

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

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

## 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 */`

Output:

```Product = 700
Sum = 80
```

Time Complexity: O(N), where N is the number of nodes in the linked list.

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.