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:

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 <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 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
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.
Auxiliary Space: O(1)