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:
- 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++
#include <iostream>
using namespace std;
struct Node {
int data;
struct Node* next;
};
void push(struct Node** head_ref, int new_data)
{
struct Node* new_node = new Node;
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
void productAndSum(struct Node* head, int k)
{
struct Node* ptr = head;
int product = 1;
int sum = 0;
while (ptr != NULL) {
if (ptr->data % k == 0) {
product *= ptr->data;
sum += ptr->data;
}
ptr = ptr->next;
}
cout << "Product = " << product << endl;
cout << "Sum = " << sum;
}
int main()
{
struct Node* head = NULL;
push(&head, 70);
push(&head, 6);
push(&head, 8);
push(&head, 4);
push(&head, 10);
int k = 10;
productAndSum(head, k);
return 0;
}
|
Java
class GFG
{
static class Node
{
int data;
Node next;
};
static Node push( Node head_ref, int new_data)
{
Node new_node = new Node();
new_node.data = new_data;
new_node.next = (head_ref);
(head_ref) = new_node;
return head_ref;
}
static void productAndSum( Node head, int k)
{
Node ptr = head;
int product = 1;
int sum = 0;
while (ptr != null)
{
if (ptr.data % k == 0)
{
product *= ptr.data;
sum += ptr.data;
}
ptr = ptr.next;
}
System.out.println( "Product = " + product );
System.out.println( "Sum = " + sum);
}
public static void main(String args[])
{
Node head = null;
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);
}
}
|
Python3
import math
class Node:
def __init__(self, data):
self.data = data
self.next = None
def push(head_ref, new_data):
new_node =Node(new_data)
new_node.data = new_data
new_node.next = head_ref
head_ref = new_node
return head_ref
def productAndSum(head, k):
ptr = head
product = 1
add = 0
while (ptr != None):
if (ptr.data % k == 0):
product = product * ptr.data
add = add + ptr.data
ptr = ptr.next
print("Product =", product)
print("Sum =", add)
if __name__=='__main__':
head = None
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)
|
C#
using System;
class GFG
{
public class Node
{
public int data;
public Node next;
};
static Node push( Node head_ref, int new_data)
{
Node new_node = new Node();
new_node.data = new_data;
new_node.next = (head_ref);
(head_ref) = new_node;
return head_ref;
}
static void productAndSum( Node head, int k)
{
Node ptr = head;
int product = 1;
int sum = 0;
while (ptr != null)
{
if (ptr.data % k == 0)
{
product *= ptr.data;
sum += ptr.data;
}
ptr = ptr.next;
}
Console.WriteLine( "Product = " + product );
Console.WriteLine( "Sum = " + sum);
}
public static void Main(String []args)
{
Node head = null;
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);
}
}
|
Javascript
<script>
class Node
{
constructor(val)
{
this.data = val;
this.next = null;
}
}
function push(head_ref, new_data)
{
var new_node = new Node();
new_node.data = new_data;
new_node.next = (head_ref);
(head_ref) = new_node;
return head_ref;
}
function productAndSum(head, k)
{
var ptr = head;
var product = 1;
var sum = 0;
while (ptr != null)
{
if (ptr.data % k == 0)
{
product *= ptr.data;
sum += ptr.data;
}
ptr = ptr.next;
}
document.write("Product = " + product);
document.write("<br/>Sum = " + sum);
}
var head = null;
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);
</script>
|
OutputProduct = 700
Sum = 80
Complexity Analysis:
- Time Complexity: O(N), where N is the number of nodes in the linked list.
- Auxiliary Space: O(1)
Approach : Use a simple iterative traversal of the linked list and performs constant-time operations for each node to compute the product and sum of nodes that are divisible by a given integer k.
Algorithm steps:
- Start with an empty linked list, represented by a null head pointer.
- Add new nodes to the beginning of the linked list using the push() function. The push() function takes a pointer to the head pointer and the data of the new node as input, creates a new node, sets its data to the input data, sets its next pointer to the current head pointer, and updates the head pointer to point to the new node.
- Define a function productAndSum() that takes a pointer to the head of the linked list and an integer k as input.
- Initialize two variables product and sum to 1 and 0, respectively.
- Traverse the linked list using a pointer ptr. For each node:
- a. Check if the node’s data is divisible by k using the modulo operator. If it is, multiply the product variable by the node’s data and add the node’s data to the sum variable.
- b. Move the ptr pointer to the next node.
- Print the product and sum variables.
- Return from the function.
Below is the implementation of the above approach:
C++
#include <iostream>
using namespace std;
struct Node {
int data;
struct Node* next;
};
void push(struct Node** head_ref, int new_data)
{
struct Node* new_node = new Node;
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
void productAndSumRecursive(struct Node* head, int k, int& product, int& sum)
{
if (head == NULL) {
return;
}
productAndSumRecursive(head->next, k, product, sum);
if (head->data % k == 0) {
product *= head->data;
sum += head->data;
}
}
void productAndSum(struct Node* head, int k)
{
int product = 1;
int sum = 0;
productAndSumRecursive(head, k, product, sum);
cout << "Product = " << product << endl;
cout << "Sum = " << sum;
}
int main()
{
struct Node* head = NULL;
push(&head, 70);
push(&head, 6);
push(&head, 8);
push(&head, 4);
push(&head, 10);
int k = 10;
productAndSum(head, k);
return 0;
}
|
Java
class Node {
int data;
Node next;
Node(int val){
this.data = val;
this.next = null;
}
}
class GFG {
static Node head;
static int product = 1;
static int sum = 0;
static void push(int new_data) {
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
static void productAndSumRecursive(Node head, int k){
if(head == null) return;
productAndSumRecursive(head.next, k);
if(head.data % k == 0){
product = product * head.data;
sum = sum + head.data;
}
}
static void productAndSum(Node head, int k) {
productAndSumRecursive(head, k);
System.out.println("Product = " + product);
System.out.println("Sum = " + sum);
}
public static void main(String[] args) {
push(70);
push(6);
push(8);
push(4);
push(10);
int k = 10;
productAndSum(head, k);
}
}
|
Python3
class Node:
def __init__(self, val):
self.data = val
self.next = None
def push(head_ref, new_data):
new_node = Node(new_data)
new_node.next = head_ref
head_ref = new_node
return head_ref
def productAndSumRecursive(head, k):
global product, sum
if head is None:
return
productAndSumRecursive(head.next, k)
if head.data % k == 0:
product *= head.data
sum += head.data
def productAndSum(head, k):
global product, sum
product = 1
sum = 0
productAndSumRecursive(head, k)
print("Product =", product)
print("Sum =", sum)
head = None
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)
|
C#
using System;
public class Node
{
public int data;
public Node next;
}
public class GFG
{
public static void Push(ref Node head_ref, int new_data)
{
Node new_node = new Node();
new_node.data = new_data;
new_node.next = head_ref;
head_ref = new_node;
}
public static void ProductAndSumRecursive(Node head, int k, ref int product, ref int sum)
{
if (head == null)
{
return;
}
ProductAndSumRecursive(head.next, k, ref product, ref sum);
if (head.data % k == 0)
{
product *= head.data;
sum += head.data;
}
}
public static void ProductAndSum(Node head, int k)
{
int product = 1;
int sum = 0;
ProductAndSumRecursive(head, k, ref product, ref sum);
Console.WriteLine("Product = " + product);
Console.WriteLine("Sum = " + sum);
}
public static void Main(string[] args)
{
Node head = null;
Push(ref head, 70);
Push(ref head, 6);
Push(ref head, 8);
Push(ref head, 4);
Push(ref head, 10);
int k = 10;
ProductAndSum(head, k);
}
}
|
Javascript
class Node {
constructor(val){
this.data = val;
this.next = null;
}
}
function push(head_ref, new_data) {
var new_node = new Node();
new_node.data = new_data;
new_node.next = (head_ref);
(head_ref) = new_node;
return head_ref;
}
function productAndSumRecursive(head, k){
if(head == null) return;
productAndSumRecursive(head.next, k);
if(head.data % k == 0){
product = product * head.data;
sum = sum + head.data;
}
}
var product = 1;
var sum = 0;
function productAndSum(head, k) {
productAndSumRecursive(head, k, product, sum);
console.log("Product = " + product);
console.log("Sum = " + sum);
}
var head = null;
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);
|
OutputProduct = 700
Sum = 80
Time Complexity: O(n), where n is the number of nodes in the linked list.
Auxiliary Space: O(1), because we only use a fixed amount of additional memory that does not depend on the size of the input.