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 = 10Output: Product = 2400, Sum = 100 Product of nodes: 60 * 40 = 2400Input: List = 15->7->3->9->11->5 k = 5Output: 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;` `}` |

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

## Javascript

`<script>` `// Javascript implementation to find the product` `// and sum of nodes which are divisible by k ` `// A Linked list node` `class Node` `{` ` ` `constructor(val)` ` ` `{` ` ` `this` `.data = val;` ` ` `this` `.next = ` `null` `;` ` ` `}` `}` `// Function to insert a node at the` `// beginning of the 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 to the new node` ` ` `new_node.next = (head_ref);` ` ` `// Move the head to povar 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` `function` `productAndSum(head, k)` `{` ` ` ` ` `// Pointer to traverse the list` ` ` `var` `ptr = head;` ` ` ` ` `// Variable to store product` ` ` `var` `product = 1;` ` ` ` ` `// Variable to store sum` ` ` `var` `sum = 0;` ` ` `// 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` ` ` `document.write(` `"Product = "` `+ product);` ` ` `document.write(` `"<br/>Sum = "` `+ sum);` `}` `// Driver Code` `var` `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);` `var` `k = 10;` `productAndSum(head, k);` `// This code is contributed by umadevi9616` `</script>` |

**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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **DSA Live Classes**