# Sum and Product of the nodes of a Singly Linked List which are divisible by K

• Difficulty Level : Easy
• Last Updated : 06 Nov, 2021

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:

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

## Javascript

 ``

Output:

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

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

My Personal Notes arrow_drop_up