Sum of all perfect numbers present in an Linked list

Last Updated : 03 Apr, 2023

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 <bits/stdc++.h>
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 of 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 of 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# 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 of 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

<script>
      // JavaScript implementation of the approach
      // Node of the singly linked list
      class Node {
        constructor() {
          this.data = 0;
          this.next = null;
        }
      }

      // Function to insert a node
      // at the beginning of
      // the singly 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 of 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
      function sumOfFactors(n) {
        var sum = 0;

        for (var f = 1; f <= parseInt(n / 2); f++) {
          // f is the factor of n
          if (n % f == 0) {
            sum += f;
          }
        }
        return sum;
      }

      // Function to return the required sum
      function getSum(head_1) {
        // To store the sum
        var sum = 0;

        var 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
      // Start with the empty list
      var 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);

      var k = getSum(head);

      document.write(k);
      
      // This code is contributed by rdtank.
    </script>

Output:

Sum of all perfect numbers present in an array

ShivaTeja2

Improve

Article Tags :

Practice Tags :

Sum of all perfect numbers present in an Linked list

Similar Reads

Thank You!

What kind of Experience do you want to share?