Product of nodes with Bell Number weights in a Singly Linked List
Last Updated :
04 Dec, 2023
Given a singly linked list containing nodes with numeric values and their corresponding weights. The goal is to find the product of the nodes whose weight corresponds Bell Number.
Bell numbers are a sequence of numbers that count different combinatorial arrangements, particularly the partitions of a set. These numbers are named after Eric Temple Bell, a prominent mathematician.
Bell numbers have various applications in combinatorics, including counting the number of ways to:
- Divide a set into non-empty, disjoint subsets.
- Partition a set into subsets with a specified number of elements.
- Calculate the number of equivalence relations on a set.
- Enumerate restricted permutations and many other combinatorial problems.
The first few Bell numbers are 1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147, …
Examples:
Input: 12 (4) -> 23 (1) -> 4 (8) -> 14 (52) -> NULL
Output: 322
Explanation: In this example, the nodes with weights that are Bell Numbers are 23 (1) and 14 (52). Their product is 23 * 14 = 322.
Input: 4 (9) -> 5 (1) -> 26 (5) -> 1 (12) -> 56 (203) -> NULL
Output: 7280
Explanation: In this example, the nodes with weights that are Bell Numbers are 5 (1), 26 (5), and 56 (203). Their product is 5 * 26 * 56 = 7280.
Approach: To solve the problem follow the below idea:
In this approach, we aim to find the product of nodes in a singly linked list whose weights correspond to Bell Numbers. To achieve this, we start by dynamically calculating Bell Numbers using a two-dimensional array based on the maximum weight in the linked list. Then, we traverse the list and for each node, we check if its weight matches any Bell Number by comparing it with the values in the Bell Number array. If there's a match, we multiply the node's value with the running product. This approach ensures that we consider all nodes with weights as Bell Numbers and accumulate their values to calculate the final product efficiently.
Steps of this approach:
- Define a function productOfBellNumbers to calculate the product of nodes with weights corresponding to Bell Numbers.
- Initialize a product variable to 1 to accumulate the result.
- Traverse the linked list to find the maximum weight, which will determine the size of the Bell Number array.
- Create a two-dimensional array bell to store Bell Numbers using dynamic programming.
- Calculate Bell Numbers for weights up to the maximum weight using nested loops.
- Re-traverse the linked list and for each node, check if its weight matches any Bell Number in the bell array.
- If a match is found, multiply the node's value with the running product.
- Continue this process for all nodes in the linked list.
- Return the final product, which represents the product of nodes with Bell Number weights.
Below is the implementation of the above approach:
C++
// C++ code for the above approach:
#include <iostream>
using namespace std;
// Define the structure of a singly
// linked list node
struct Node {
int value;
int weight;
Node* next;
Node(int val, int w)
: value(val)
, weight(w)
, next(nullptr)
{
}
};
// Function to find the product of nodes
// with Bell Number weights
int productOfBellNumbers(Node* head)
{
int product = 1;
Node* current = head;
// Step 1: Find the maximum weight in
// the linked list
int maxWeight = 0;
while (current) {
if (current->weight > maxWeight) {
maxWeight = current->weight;
}
current = current->next;
}
// Step 2: Calculate Bell Numbers using
// dynamic programming
int bell[maxWeight + 1][maxWeight + 1];
bell[0][0] = 1;
for (int i = 1; i <= maxWeight; i++) {
bell[i][0] = bell[i - 1][i - 1];
for (int j = 1; j <= i; j++) {
bell[i][j]
= bell[i - 1][j - 1] + bell[i][j - 1];
}
}
// Step 3: Calculate the product of nodes
// with Bell Number weights
current = head;
while (current) {
int weight = current->weight;
// Check if the weight is a Bell Number
for (int i = 0; i <= weight; i++) {
if (bell[i][0] == weight) {
product *= current->value;
break;
}
}
current = current->next;
}
return product;
}
// Function to print the linked list
void printLinkedList(Node* head)
{
Node* current = head;
while (current) {
cout << current->value << " (" << current->weight
<< ") -> ";
current = current->next;
}
cout << "NULL" << endl;
}
// Drivers code
int main()
{
// Create the first linked list
Node* head1 = new Node(12, 4);
head1->next = new Node(23, 1);
head1->next->next = new Node(4, 8);
head1->next->next->next = new Node(14, 52);
// Calculate and print the product of nodes
// with Bell Number weights for the first example
int result1 = productOfBellNumbers(head1);
cout << "Output 1: " << result1 << endl;
// Free the memory of the first linked list
while (head1) {
Node* temp = head1;
head1 = head1->next;
delete temp;
}
// Create the second linked list
Node* head2 = new Node(4, 9);
head2->next = new Node(5, 1);
head2->next->next = new Node(26, 5);
head2->next->next->next = new Node(1, 12);
head2->next->next->next->next = new Node(56, 203);
// Calculate and print the product of nodes
// with Bell Number weights for the second example
int result2 = productOfBellNumbers(head2);
cout << "Output 2: " << result2 << endl;
// Free the memory of the second linked list
while (head2) {
Node* temp = head2;
head2 = head2->next;
delete temp;
}
return 0;
}
// Java code to implement above approach
class Node {
int value;
int weight;
Node next;
Node(int val, int w)
{
value = val;
weight = w;
next = null;
}
}
public class Main {
// Function to find the product of nodes with Bell
// Number weights
static int productOfBellNumbers(Node head)
{
int product = 1;
Node current = head;
// Step 1: Find the maximum weight in the linked
// list
int maxWeight = 0;
while (current != null) {
if (current.weight > maxWeight) {
maxWeight = current.weight;
}
current = current.next;
}
// Step 2: Calculate Bell Numbers using dynamic
// programming
int[][] bell
= new int[maxWeight + 1][maxWeight + 1];
bell[0][0] = 1;
for (int i = 1; i <= maxWeight; i++) {
bell[i][0] = bell[i - 1][i - 1];
for (int j = 1; j <= i; j++) {
bell[i][j]
= bell[i - 1][j - 1] + bell[i][j - 1];
}
}
// Step 3: Calculate the product of nodes with Bell
// Number weights
current = head;
while (current != null) {
int weight = current.weight;
// Check if the weight is a Bell Number
for (int i = 0; i <= weight; i++) {
if (bell[i][0] == weight) {
product *= current.value;
break;
}
}
current = current.next;
}
return product;
}
// Function to print the linked list
static void printLinkedList(Node head)
{
Node current = head;
while (current != null) {
System.out.print(current.value + " ("
+ current.weight + ") -> ");
current = current.next;
}
System.out.println("NULL");
}
// Driver code
public static void main(String[] args)
{
// Create the first linked list
Node head1 = new Node(12, 4);
head1.next = new Node(23, 1);
head1.next.next = new Node(4, 8);
head1.next.next.next = new Node(14, 52);
// Calculate and print the product of nodes with
// Bell Number weights for the first example
int result1 = productOfBellNumbers(head1);
System.out.println("Output 1: " + result1);
// Free the memory of the first linked list
while (head1 != null) {
Node temp = head1;
head1 = head1.next;
temp.next = null;
}
// Create the second linked list
Node head2 = new Node(4, 9);
head2.next = new Node(5, 1);
head2.next.next = new Node(26, 5);
head2.next.next.next = new Node(1, 12);
head2.next.next.next.next = new Node(56, 203);
// Calculate and print the product of nodes with
// Bell Number weights for the second example
int result2 = productOfBellNumbers(head2);
System.out.println("Output 2: " + result2);
// Free the memory of the second linked list
while (head2 != null) {
Node temp = head2;
head2 = head2.next;
temp.next = null;
}
}
}
// This code is contributed by Abhinav Mahajan (abhinav_m22)
# Define the structure of a singly
# linked list node
class Node:
def __init__(self, value, weight):
self.value = value
self.weight = weight
self.next = None
# Function to find the product of nodes
# with Bell Number weights
def product_of_bell_numbers(head):
product = 1
current = head
# Step 1: Find the maximum weight in
# the linked list
maxWeight = 0
while current:
if current.weight > maxWeight:
maxWeight = current.weight
current = current.next
# Step 2: Calculate Bell Numbers using dynamic programming
bell = [[0] * (maxWeight + 1) for _ in range(maxWeight + 1)]
bell[0][0] = 1
for i in range(1, maxWeight + 1):
bell[i][0] = bell[i - 1][i - 1]
for j in range(1, i + 1):
bell[i][j] = bell[i - 1][j - 1] + bell[i][j - 1]
# Step 3: Calculate the product of nodes with Bell Number weights
current = head
while current:
weight = current.weight
# Check if the weight is a Bell Number
for i in range(weight + 1):
if bell[i][0] == weight:
product *= current.value
break
current = current.next
return product
# Function to print the linked list
def print_linked_list(head):
current = head
while current:
print(f"{current.value} ({current.weight}) -> ", end="")
current = current.next
print("NULL")
# Driver code
if __name__ == "__main__":
# Create the first linked list
head1 = Node(12, 4)
head1.next = Node(23, 1)
head1.next.next = Node(4, 8)
head1.next.next.next = Node(14, 52)
# Calculate and print the product of nodes
# with Bell Number weights for the first example
result1 = product_of_bell_numbers(head1)
print("Output 1:", result1)
# Free the memory of the first linked list
while head1:
temp = head1
head1 = head1.next
temp.next = None
# Create the second linked list
head2 = Node(4, 9)
head2.next = Node(5, 1)
head2.next.next = Node(26, 5)
head2.next.next.next = Node(1, 12)
head2.next.next.next.next = Node(56, 203)
# Calculate and print the product of nodes
# with Bell Number weights for the second example
result2 = product_of_bell_numbers(head2)
print("Output 2:", result2)
# Free the memory of the second linked list
while head2:
temp = head2
head2 = head2.next
temp.next = None
// code by Flutterfly
using System;
// Define the structure of a singly
// linked list node
public class Node
{
public int Value { get; set; }
public int Weight { get; set; }
public Node Next { get; set; }
public Node(int val, int w)
{
Value = val;
Weight = w;
Next = null;
}
}
public class Program
{
// Function to find the product of nodes
// with Bell Number weights
public static int ProductOfBellNumbers(Node head)
{
int product = 1;
Node current = head;
// Step 1: Find the maximum weight in
// the linked list
int maxWeight = 0;
while (current != null)
{
if (current.Weight > maxWeight)
{
maxWeight = current.Weight;
}
current = current.Next;
}
// Step 2: Calculate Bell Numbers using
// dynamic programming
int[,] bell = new int[maxWeight + 1, maxWeight + 1];
bell[0, 0] = 1;
for (int i = 1; i <= maxWeight; i++)
{
bell[i, 0] = bell[i - 1, i - 1];
for (int j = 1; j <= i; j++)
{
bell[i, j] = bell[i - 1, j - 1] + bell[i, j - 1];
}
}
// Step 3: Calculate the product of nodes
// with Bell Number weights
current = head;
while (current != null)
{
int weight = current.Weight;
// Check if the weight is a Bell Number
for (int i = 0; i <= weight; i++)
{
if (i < maxWeight + 1 && bell[i, 0] == weight)
{
product *= current.Value;
break;
}
}
current = current.Next;
}
return product;
}
// Function to print the linked list
public static void PrintLinkedList(Node head)
{
Node current = head;
while (current != null)
{
Console.Write($"{current.Value} ({current.Weight}) -> ");
current = current.Next;
}
Console.WriteLine("NULL");
}
// Drivers code
public static void Main()
{
// Create the first linked list
Node head1 = new Node(12, 4);
head1.Next = new Node(23, 1);
head1.Next.Next = new Node(4, 8);
head1.Next.Next.Next = new Node(14, 52);
// Calculate and print the product of nodes
// with Bell Number weights for the first example
int result1 = ProductOfBellNumbers(head1);
Console.WriteLine($"Output 1: {result1}");
// Free the memory of the first linked list
while (head1 != null)
{
Node temp = head1;
head1 = head1.Next;
temp.Next = null;
}
// Create the second linked list
Node head2 = new Node(4, 9);
head2.Next = new Node(5, 1);
head2.Next.Next = new Node(26, 5);
head2.Next.Next.Next = new Node(1, 12);
head2.Next.Next.Next.Next = new Node(56, 203);
// Calculate and print the product of nodes
// with Bell Number weights for the second example
int result2 = ProductOfBellNumbers(head2);
Console.WriteLine($"Output 2: {result2}");
// Free the memory of the second linked list
while (head2 != null)
{
Node temp = head2;
head2 = head2.Next;
temp.Next = null;
}
}
}
class Node {
constructor(val, w) {
this.value = val;
this.weight = w;
this.next = null;
}
}
function productOfBellNumbers(head) {
let product = 1;
let current = head;
// Step 1: Find the maximum weight in the linked list
let maxWeight = 0;
while (current) {
if (current.weight > maxWeight) {
maxWeight = current.weight;
}
current = current.next;
}
// Step 2: Calculate Bell Numbers using dynamic programming
let bell = new Array(maxWeight + 1).fill(0).map(() => new Array(maxWeight + 1).fill(0));
bell[0][0] = 1;
for (let i = 1; i <= maxWeight; i++) {
bell[i][0] = bell[i - 1][i - 1];
for (let j = 1; j <= i; j++) {
bell[i][j] = bell[i - 1][j - 1] + bell[i][j - 1];
}
}
// Step 3: Calculate the product of nodes with Bell Number weights
current = head;
while (current) {
let weight = current.weight;
// Check if the weight is a Bell Number
for (let i = 0; i <= weight; i++) {
if (i < maxWeight + 1 && bell[i][0] === weight) {
product *= current.value;
break;
}
}
current = current.next;
}
return product;
}
function printLinkedList(head) {
let current = head;
while (current) {
console.log(`${current.value} (${current.weight}) ->`);
current = current.next;
}
console.log("NULL");
}
// Drivers code
// Create the first linked list
let head1 = new Node(12, 4);
head1.next = new Node(23, 1);
head1.next.next = new Node(4, 8);
head1.next.next.next = new Node(14, 52);
// Calculate and print the product of nodes with Bell Number weights for the first example
let result1 = productOfBellNumbers(head1);
console.log("Output 1:", result1);
// Create the second linked list
let head2 = new Node(4, 9);
head2.next = new Node(5, 1);
head2.next.next = new Node(26, 5);
head2.next.next.next = new Node(1, 12);
head2.next.next.next.next = new Node(56, 203);
// Calculate and print the product of nodes with Bell Number weights for the second example
let result2 = productOfBellNumbers(head2);
console.log("Output 2:", result2);
OutputOutput 1: 322
Output 2: 7280
Time Complexity: O(n^2), where n is the number of nodes in list.
Auxiliary Space: O(n), where n is the nodes in list.
Similar Reads
Find product of nodes whose weights is triangular number in a Linked list Given a linked list with weights, the task is to find the product of nodes whose weights are all triangular numbers where a triangular number is a number that can be represented as the sum of consecutive positive integers starting from 1. In other words, a triangular number is the sum of the first n
7 min read
Find product of nodes with min and max weights in a singly linked list Given a singly linked list with weights, the task is to find the product of nodes with minimum and maximum weights in the list. Examples: Input: 3 (4) -> 1 (2) -> 8 (14) -> 12 (1) -> 5 (9) -> 7 (3) -> NULLOutput: 96Explanation: Node with minimum weight is 12 and maximum weight is 8
7 min read
Find product of nodes whose weights is catalan number in a Linked list Given a linked list with weights, the task is to find the product of nodes whose weights are Catalan numbers. Examples: Input: 3(1) -> 7 (4) -> 5 (2) -> 12 (5) -> 14 (3) -> NULLOutput: 180Explanation: Catalan number weights are 1, 2, and 5, and the product of their nodes is 3 * 5 * 12
11 min read
Product of the nodes of a Singly Linked List Given a singly linked list, the task is to find the product of all of the nodes of the given linked list.Note: For empty/ null lists, return -1.Examples: Input : List = 7->6->8->4->1Output : 1344Explanation: Product of nodes: 7 * 6 * 8 * 4 * 1 = 1344Input : List = 1->7->3->9-
7 min read
Sum and Product of all Prime Nodes of a Singly Linked List Given a singly linked list containing N nodes, the task is to find the sum and product of all nodes from the list which are prime. Examples: Input : List = 15 -> 16 -> 6 -> 7 -> 17 Output : Product = 119, Sum = 24 Prime nodes are 7, 17. Input : List = 15 -> 3 -> 4 -> 2 -> 9 O
15+ min read