# Sum of all perfect numbers present in an Linked list

• Last Updated : 18 Jun, 2021

Given an Linked list containing N positive integer, the task is to find the sum of all the perfect numbers from the list.

A number is perfect if is equal to the sum of its proper divisors i.e. the sum of its positive divisors excluding the number itself.

Examples:

Input: L1 = 3 -> 6 -> 9
Output:6
Proper divisor sum of 3 = 1
ans=0
Proper divisor sum of 6 = 1 + 2 + 3 = 6
ans=6;
Proper divisor sum of 9 = 1 + 3 = 4
ans=6;
Input: L1 = 17 -> 6 -> 10 -> 6 -> 4
Output: 12

Approach: Initialise sum = 0 and for every node of the list, find the sum of its proper divisors say sumFactors. If cur_node = sumFactors then update the resultant sum as sum = sum + cur_node. Print the sum in the end.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach` `#include ``using` `namespace` `std;` `// Node of the singly linked list``struct` `Node {``    ``int` `data;``    ``Node* next;``};` `// Function to insert a node``// at the beginning of``// the singly Linked List``void` `push(Node** head_ref, ``int` `new_data)``{``    ``// allocate node``    ``Node* new_node``        ``= (Node*)``malloc``(``            ``sizeof``(``struct` `Node));` `    ``// put in the data``    ``new_node->data = new_data;` `    ``// link the old list off the new node``    ``new_node->next = (*head_ref);` `    ``// move the head to point``    ``// to the new node``    ``(*head_ref) = new_node;``}``// Function to return the sum of``// all the proper factors of n``int` `sumOfFactors(``int` `n)``{``    ``int` `sum = 0;``    ``for` `(``int` `f = 1; f <= n / 2; f++) {` `        ``// f is the factor of n``        ``if` `(n % f == 0) {``            ``sum += f;``        ``}``    ``}``    ``return` `sum;``}` `// Function to return the required sum``int` `getSum(Node* head_1)``{` `    ``// To store the sum``    ``int` `sum = 0;``    ``Node* ptr = head_1;``    ``while` `(ptr != NULL) {` `        ``// If current element is non-zero``        ``// and equal to the sum``        ``// of proper factors of itself``        ``if` `(ptr->data > 0``            ``&& ptr->data``                   ``== sumOfFactors(ptr->data)) {``            ``sum += ptr->data;``        ``}``        ``ptr = ptr->next;``    ``}``    ``return` `sum;``}` `// Driver code``int` `main()``{``    ``// start with the empty list``    ``Node* head1 = NULL;` `    ``// create the linked list``    ``push(&head1, 17);``    ``push(&head1, 6);``    ``push(&head1, 10);``    ``push(&head1, 6);``    ``push(&head1, 4);``    ``int` `k = getSum(head1);``    ``cout << k;``    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG{` `// Node of the singly linked list``static` `class` `Node``{``    ``int` `data;``    ``Node next;``};` `// Function to insert a node``// at the beginning of``// the singly 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 off 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 return the sum of``// all the proper factors of n``static` `int` `sumOfFactors(``int` `n)``{``    ``int` `sum = ``0``;``    ` `    ``for``(``int` `f = ``1``; f <= n / ``2``; f++)``    ``{` `       ``// f is the factor of n``       ``if` `(n % f == ``0``)``       ``{``           ``sum += f;``       ``}``    ``}``    ``return` `sum;``}` `// Function to return the required sum``static` `int` `getSum(Node head_1)``{` `    ``// To store the sum``    ``int` `sum = ``0``;``    ` `    ``Node ptr = head_1;``    ` `    ``while` `(ptr != ``null``)``    ``{` `        ``// If current element is non-zero``        ``// and equal to the sum of proper``        ``//  factors of itself``        ``if` `(ptr.data > ``0` `&& ptr.data ==``                ``sumOfFactors(ptr.data))``        ``{``            ``sum += ptr.data;``        ``}``        ``ptr = ptr.next;``    ``}``    ``return` `sum;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Start with the empty list``    ``Node head = ``new` `Node();` `    ``// Create the linked list``    ``head = push(head, ``17``);``    ``head = push(head, ``6``);``    ``head = push(head, ``10``);``    ``head = push(head, ``6``);``    ``head = push(head, ``4``);``    ` `    ``int` `k = getSum(head);``    ` `    ``System.out.print(k);``}``}` `// This code is contributed by amal kumar choubey`

## Python3

 `# Python3 implementation of the approach` `# Node class``class` `Node:``    ` `    ``# Function to initialize the node object``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.``next` `=` `None``    ` `# Linked List Class``class` `LinkedList:` `    ``# Function to initialize the``    ``# LinkedList class.``    ``def` `__init__(``self``):``        ` `        ``self``.head ``=` `None` `    ``# This function insert a new node at``    ``# the beginning of the linked list``    ``def` `push(``self``, new_data):``    ` `        ``# Create a new Node``        ``new_node ``=` `Node(new_data)` `        ``# Make next of new Node as head``        ``new_node.``next` `=` `self``.head` `        ``# Move the head to point to new Node``        ``self``.head ``=` `new_node` `    ``# Function to return the required sum``    ``def` `getSum(``self``):``        ` `        ``# To store the sum``        ``Sum` `=` `0``        ` `        ``# Initialising the pointer``        ``ptr ``=` `self``.head``        ``while``(``True``):``            ` `            ``# If current element is non Zero``            ``# and is a perfect number then``            ``# add to sum``            ``if``(ptr.data > ``0` `and` `ptr.data ``=``=``                   ``sumOfFactors(ptr.data)):``                ``Sum` `+``=` `ptr.data` `            ``# Breaking the loop if list terminates``            ``if``(ptr.``next` `=``=` `None``):``                ``break` `            ``# Moving to next node``            ``ptr ``=` `ptr.``next` `        ``# Returning the sum``        ``return` `Sum` `# Function to return the sum of``# all the proper factors of n``def` `sumOfFactors(n):``    ` `    ``Sum` `=` `0` `    ``# f is factor of n``    ``for` `f ``in` `range``(``1``, (n ``/``/` `2``) ``+` `1``):``        ``if``(n ``%` `f ``=``=` `0``):``            ``Sum` `+``=` `f``            ` `    ``return` `Sum` `# Driver Code``if` `__name__``=``=``'__main__'``:` `    ``# Start with empty list``    ``head1 ``=` `LinkedList()` `    ``# Create the linked list``    ``head1.push(``17``)``    ``head1.push(``6``)``    ``head1.push(``10``)``    ``head1.push(``6``)``    ``head1.push(``4``)` `    ``# Getting the required sum``    ``k ``=` `head1.getSum()``    ``print``(k)``    ` `# This code is contributed by Amit Mangal`

## C#

 `// C# implementation of the approach``using` `System;``class` `GFG{` `// Node of the singly linked list``class` `Node``{``    ``public` `int` `data;``    ``public` `Node next;``};` `// Function to insert a node``// at the beginning of``// the singly 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 off 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 return the sum of``// all the proper factors of n``static` `int` `sumOfFactors(``int` `n)``{``    ``int` `sum = 0;``    ` `    ``for``(``int` `f = 1; f <= n / 2; f++)``    ``{` `        ``// f is the factor of n``        ``if` `(n % f == 0)``        ``{``            ``sum += f;``        ``}``    ``}``    ``return` `sum;``}` `// Function to return the required sum``static` `int` `getSum(Node head_1)``{` `    ``// To store the sum``    ``int` `sum = 0;``    ` `    ``Node ptr = head_1;``    ` `    ``while` `(ptr != ``null``)``    ``{` `        ``// If current element is non-zero``        ``// and equal to the sum of proper``        ``// factors of itself``        ``if` `(ptr.data > 0 && ptr.data ==``               ``sumOfFactors(ptr.data))``        ``{``            ``sum += ptr.data;``        ``}``        ``ptr = ptr.next;``    ``}``    ``return` `sum;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Start with the empty list``    ``Node head = ``new` `Node();` `    ``// Create the linked list``    ``head = push(head, 17);``    ``head = push(head, 6);``    ``head = push(head, 10);``    ``head = push(head, 6);``    ``head = push(head, 4);``    ` `    ``int` `k = getSum(head);``    ` `    ``Console.Write(k);``}``}` `// This code is contributed by amal kumar choubey`

## Javascript

 ``

Output:

`12`

My Personal Notes arrow_drop_up