# 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++ 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; ` `} `

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