# Sum of nodes of Linked List whose contains values with exactly three factors

• Difficulty Level : Medium
• Last Updated : 21 Jun, 2021

Given a singly linked list containing N nodes, the task is to find the sum of all possible nodes of the list which contains value with exactly three distinct factors.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: 1 -> 2 -> 4 -> 5
Output:
Explanation:
Factors of 2 are {1, 2}
Factors of 3 are {1, 3}
Factors of 4 are {1, 2, 4}
Factors of 5 are {1, 5}
Since only 4 contains three distinct factors. Therefore, the required output is 4.

Input: 1 -> 6 -> 8 -> 10
Output: 0

Approach: The idea is based on the fact that if a number is a prime number, then the square of the number contains exactly three distinct factors. Follow the steps below to solve the problem:

• Initialize a variable, say nodeSum, to store the sum of nodes which contains value with exactly three distinct factors.
• Traverse the linked list and for each node, check if the square root of the current nodes is a prime number or not. If found to be true, then increment nodeSum by the value of current node.
• Finally, print the value of nodeSum.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Structure of a``// singly Linked List``struct` `Node {` `    ``// Stores data value``    ``// of a Node``    ``int` `data;` `    ``// Stores pointer``    ``// to next Node``    ``struct` `Node* next;``};` `// Function to insert a node at the``// beginning of the singly Linked List``void` `push(Node** head_ref,``          ``int` `new_data)``{``    ``// Create a new Node``    ``Node* new_node = ``new` `Node;` `    ``// Insert the data into``    ``// the Node``    ``new_node->data = new_data;` `    ``// Insert pointer to``    ``// the next Node``    ``new_node->next = (*head_ref);` `    ``// Update head_ref``    ``(*head_ref) = new_node;``}` `// Function to check if a number``// is a prime number or not``bool` `CheckPrimeNumber(``int` `n)``{``    ``// Base Case``    ``if` `(n <= 1)``        ``return` `false``;``    ``if` `(n <= 3)``        ``return` `true``;` `    ``// If n is multiple of 2 or 3``    ``if` `(n % 2 == 0 || n % 3 == 0)``        ``return` `false``;` `    ``// Iterate over the range``    ``// [5, sqrt(N)]``    ``for` `(``int` `i = 5; i * i <= n;``         ``i = i + 6) {` `        ``// If n is multiple of``        ``// i or (i + 2)``        ``if` `(n % i == 0 || n % (i + 2) == 0)``            ``return` `false``;``    ``}` `    ``return` `true``;``}` `// Function to check if number is``// a perfect square number or not``bool` `checkperfect_square(``int` `n)``{``    ``// Stores square root of n``    ``long` `double` `sr = ``sqrt``(n);` `    ``// If n is a``    ``// perfect square number``    ``if` `(sr - ``floor``(sr) == 0) {``        ``return` `true``;``    ``}` `    ``return` `false``;``}` `// Function to check if n is square``// of a prime number or not``bool` `is_square(``int` `n)``{``    ``// If n is a perfect square``    ``if` `(checkperfect_square(n)) {` `        ``// Stores sqrt of n``        ``int` `root = ``sqrt``(n);` `        ``// If root is a prime number``        ``if` `(CheckPrimeNumber(root)) {``            ``return` `true``;``        ``}``    ``}``    ``return` `false``;``}` `// Function to find sum of node values``// which contains three distinct factors``int` `calculate_sum(``struct` `Node* head)``{` `    ``// Stores head of``    ``// the linked list``    ``Node* curr = head;` `    ``// Stores sum of nodes whose data value``    ``// contains three distinct factors``    ``int` `nodeSum = 0;` `    ``// Traverse the linked list``    ``while` `(curr) {` `        ``// If data value of curr is``        ``// square of a prime number``        ``if` `(is_square(curr->data)) {` `            ``// Update nodeSum``            ``nodeSum += curr->data;``        ``}` `        ``// Update curr``        ``curr = curr->next;``    ``}` `    ``// Return sum``    ``return` `nodeSum;``}` `// Driver Code``int` `main()``{``    ``// Stores head node of``    ``// the linked list``    ``Node* head = NULL;` `    ``// Insert all data values``    ``// in the linked list``    ``push(&head, 5);``    ``push(&head, 4);``    ``push(&head, 2);``    ``push(&head, 1);` `    ``cout << calculate_sum(head);``    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;` `class` `GFG{` `// Structure of a``// singly Linked List``static` `class` `Node``{``    ` `    ``// Stores data value``    ``// of a Node``    ``int` `data;` `    ``// Stores pointer``    ``// to next Node``    ``Node next;``};` `static`  `Node head = ``null``;` `// Function to insert a node at the``// beginning of the singly Linked List``static` `Node push(``int` `new_data)``{``    ` `    ``// Create a new Node``    ``Node new_node = ``new` `Node();` `    ``// Insert the data into``    ``// the Node``    ``new_node.data = new_data;` `    ``// Insert pointer to``    ``// the next Node``    ``new_node.next = head;` `    ``// Update head_ref``    ``return` `head = new_node;``}` `// Function to check if a number``// is a prime number or not``static` `boolean` `CheckPrimeNumber(``int` `n)``{``    ` `    ``// Base Case``    ``if` `(n <= ``1``)``        ``return` `false``;``    ``if` `(n <= ``3``)``        ``return` `true``;` `    ``// If n is multiple of 2 or 3``    ``if` `(n % ``2` `== ``0` `|| n % ``3` `== ``0``)``        ``return` `false``;` `    ``// Iterate over the range``    ``// [5, Math.sqrt(N)]``    ``for``(``int` `i = ``5``; i * i <= n; i = i + ``6``)``    ``{``        ` `        ``// If n is multiple of``        ``// i or (i + 2)``        ``if` `(n % i == ``0` `|| n % (i + ``2``) == ``0``)``            ``return` `false``;``    ``}``    ``return` `true``;``}` `// Function to check if number is``// a perfect square number or not``static` `boolean` `checkperfect_square(``int` `n)``{``    ` `    ``// Stores square root of n``    ``long` `sr = (``long``)Math.sqrt(n);``    ` `    ``// If n is a``    ``// perfect square number``    ``if` `(sr - Math.floor(sr) == ``0``)``    ``{``        ``return` `true``;``    ``}``    ``return` `false``;``}` `// Function to check if n is square``// of a prime number or not``static` `boolean` `is_square(``int` `n)``{``    ` `    ``// If n is a perfect square``    ``if` `(checkperfect_square(n))``    ``{``        ` `        ``// Stores sqrt of n``        ``int` `root = (``int``)Math.sqrt(n);` `        ``// If root is a prime number``        ``if` `(CheckPrimeNumber(root))``        ``{``            ``return` `true``;``        ``}``    ``}``    ``return` `false``;``}` `// Function to find sum of node values``// which contains three distinct factors``static` `int` `calculate_sum(Node head)``{``    ` `    ``// Stores head of``    ``// the linked list``    ``Node curr = head;` `    ``// Stores sum of nodes whose data value``    ``// contains three distinct factors``    ``int` `nodeSum = ``0``;` `    ``// Traverse the linked list``    ``while` `(curr.next != ``null``)``    ``{``        ` `        ``// If data value of curr is``        ``// square of a prime number``        ``if` `(is_square(curr.data))``        ``{``            ` `            ``// Update nodeSum``            ``nodeSum += curr.data;``        ``}` `        ``// Update curr``        ``curr = curr.next;``    ``}` `    ``// Return sum``    ``return` `nodeSum;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Stores head node of``    ``// the linked list``   ` `    ``// Insert all data values``    ``// in the linked list``    ``head = push(``5``);``    ``head = push(``4``);``    ``head = push(``2``);``    ``head = push(``1``);` `    ``System.out.print(calculate_sum(head));``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program to implement``# the above approach``import` `math` `# Structure of a``# singly linked list``class` `Node:``    ` `    ``def` `__init__(``self``, data):``        ` `        ``self``.data ``=` `data``        ``self``.``next` `=` `None``        ` `class` `LinkedList:``    ` `    ``def` `__init__(``self``):``        ` `        ``self``.head ``=` `None` `    ``# Function to insert a nodeat the``    ``# beginning of the singly linked list``    ``def` `Push(``self``, new_data):``        ` `        ``# Create new node``        ``# and insert the data``        ``# into the node``        ``new_node ``=` `Node(new_data)` `        ``# Insert pointer to the``        ``# next node``        ``new_node.``next` `=` `self``.head` `        ``# Update head``        ``self``.head ``=` `new_node``        ` `    ``# Function to find sum of node values``    ``# which contains three distinct factors``    ``def` `calculate_sum(``self``):``        ` `        ``# Stores the head of linked list``        ``curr ``=` `self``.head``        ` `        ``# Stores sum of nodes whose data``        ``# value contains three distinct factors``        ``nodeSum ``=` `0` `        ``# Traverse the linked list``        ``while``(curr):``            ` `            ``# If data value of curr is``            ``# square of a prime number``            ``if` `(is_square(curr.data)):``                ` `                ``# Update nodeSum``                ``nodeSum ``+``=` `curr.data``                ` `            ``# Update curr    ``            ``curr ``=` `curr.``next``            ` `        ``# Return Sum``        ``return` `nodeSum` `# Function to check if a number``# is a prime number or not``def` `CheckPrimeNumber(n):``    ` `    ``# Base Class``    ``if` `n <``=` `1``:``        ``return` `False``    ``if` `n <``=` `3``:``        ``return` `True``        ` `    ``# If n is multiple of 2 or 3``    ``if` `(n ``%` `2` `=``=` `0` `or` `n ``%` `3` `=``=` `0``):``        ``return` `False``        ` `    ``# Iterate over the range``    ``# [5,sqrt(N)]``    ``i ``=` `5``    ``while` `((i ``*` `i) <``=` `n):``        ` `        ``# If n is multiple of``        ``# i or (i+2)``        ``if` `(n ``%` `i ``=``=` `0` `or` `n ``%` `(i ``+` `2``) ``=``=` `0``):``            ``return` `False``            ` `        ``i ``+``=` `6``        ` `    ``return` `True` ` ``# Function to check if number is``# a perfect square number or not``def` `checkperfect_square(n):``    ` `    ``# Stores square root of n``    ``sr ``=` `math.sqrt(n)` `    ``# If n is a perfect``    ``# square number``    ``if` `(sr ``-` `math.floor(sr)) ``=``=` `0``:``        ``return` `True``        ` `    ``return` `False` `# Function to check if n is square``# of a prime number or not``def` `is_square(n):``    ` `    ``# If n is a perfect square``    ``if` `(checkperfect_square(n)):``        ` `        ``# Stores sqrt of n``        ``root ``=` `math.sqrt(n)``        ` `        ``# If root is a prime number``        ``if` `(CheckPrimeNumber(root)):``            ``return` `True``            ` `    ``return` `False` `# Driver Code``if` `__name__ ``=``=` `"__main__"` `:``    ` `    ``LList ``=` `LinkedList()``    ` `    ``# Insert all data values``    ``# in the linked list``    ``LList.Push(``5``)``    ``LList.Push(``4``)``    ``LList.Push(``2``)``    ``LList.Push(``1``)``    ` `    ``print``(LList.calculate_sum())``             ` `# This code is contributed by Virusbuddah`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG{` `// Structure of a``// singly Linked List``public` `class` `Node``{``    ` `    ``// Stores data value``    ``// of a Node``    ``public` `int` `data;``    ` `    ``// Stores pointer``    ``// to next Node``    ``public` `Node next;``};` `static`  `Node head = ``null``;` `// Function to insert a node at the``// beginning of the singly Linked List``static` `Node push(``int` `new_data)``{``    ` `    ``// Create a new Node``    ``Node new_node = ``new` `Node();``    ` `    ``// Insert the data into``    ``// the Node``    ``new_node.data = new_data;``    ` `    ``// Insert pointer to``    ``// the next Node``    ``new_node.next = head;``    ` `    ``// Update head_ref``    ``return` `head = new_node;``}` `// Function to check if a number``// is a prime number or not``static` `bool` `CheckPrimeNumber(``int` `n)``{``    ` `    ``// Base Case``    ``if` `(n <= 1)``        ``return` `false``;``    ``if` `(n <= 3)``        ``return` `true``;``        ` `    ``// If n is multiple of 2 or 3``    ``if` `(n % 2 == 0 || n % 3 == 0)``        ``return` `false``;``        ` `    ``// Iterate over the range``    ``// [5, Math.Sqrt(N)]``    ``for``(``int` `i = 5; i * i <= n; i = i + 6)``    ``{``        ` `        ``// If n is multiple of``        ``// i or (i + 2)``        ``if` `(n % i == 0 || n % (i + 2) == 0)``            ``return` `false``;``    ``}``    ``return` `true``;``}` `// Function to check if number is``// a perfect square number or not``static` `bool` `checkperfect_square(``int` `n)``{``    ` `    ``// Stores square root of n``    ``long` `sr = (``long``)Math.Sqrt(n);``    ` `    ``// If n is a perfect square number``    ``if` `(sr - Math.Floor((``double``)sr) == 0)``    ``{``        ``return` `true``;``    ``}``    ``return` `false``;``}` `// Function to check if n is square``// of a prime number or not``static` `bool` `is_square(``int` `n)``{``    ` `    ``// If n is a perfect square``    ``if` `(checkperfect_square(n))``    ``{``        ` `        ``// Stores sqrt of n``        ``int` `root = (``int``)Math.Sqrt(n);``        ` `        ``// If root is a prime number``        ``if` `(CheckPrimeNumber(root))``        ``{``            ``return` `true``;``        ``}``    ``}``    ``return` `false``;``}` `// Function to find sum of node values``// which contains three distinct factors``static` `int` `calculate_sum(Node head)``{``    ` `    ``// Stores head of``    ``// the linked list``    ``Node curr = head;``    ` `    ``// Stores sum of nodes whose data value``    ``// contains three distinct factors``    ``int` `nodeSum = 0;``    ` `    ``// Traverse the linked list``    ``while` `(curr.next != ``null``)``    ``{``        ` `        ``// If data value of curr is``        ``// square of a prime number``        ``if` `(is_square(curr.data))``        ``{``            ` `            ``// Update nodeSum``            ``nodeSum += curr.data;``        ``}``        ` `        ``// Update curr``        ``curr = curr.next;``    ``}` `    ``// Return sum``    ``return` `nodeSum;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Stores head node of``    ``// the linked list``    ` `    ``// Insert all data values``    ``// in the linked list``    ``head = push(5);``    ``head = push(4);``    ``head = push(2);``    ``head = push(1);` `    ``Console.Write(calculate_sum(head));``}``}` `// This code is contributed by aashish1995`

## Javascript

 ``
Output:
`4`

Time Complexity: O(N * √ X), where X is the largest element in the linked list
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up