# Sum of distances between the two nearest perfect squares to all the nodes of the given linked list

Last Updated : 03 May, 2023

Given a linked list, the task is to find the sum of distances between the two nearest perfect squares for all the nodes of the given linked list.
Examples:

Input: 3 -> 15 -> 7 -> NULL
Output: 15
For 3: closest left perfect square is 1 and closest right 4 i.e. 4-1 = 3
For 15: 16 – 9 = 7
For 7: 9 – 4 = 5
3 + 7 + 5 = 15

Input: 1 -> 5 -> 10 -> 78 -> 23 -> NULL
Output: 38

Approach: Initialise sum = 0 and for every node, if the current node’s value is a perfect square itself then the left and right closest perfect square will be the value itself and distance will be 0. Else, find the left and right closest perfect squares say leftPS and rightPS and update sum = sum + (rightPS – leftPS).

Algorithm:

• create a function with an int return type that takes the head of the linked list as input.
•  Set the base condition that is if the head is equal to null then return 0.
• Now initialize an int variable to store the total distance sum initially assigned 0 to it.
• Now create a pointer named “temp” which points to the head of the linked list.
• start a while loop with the conditioning temp not equal to NULL
• Now for each iteration.
• Find the square root of the node data and store the value in a variable sq_root
•  It indicates that “temp->data” is not a perfect square if “sq root” is less than “temp->data”. Get the left and right perfect  squares of the given “temp->data” and place them, respectively, in the variables “left ps” and “right ps.”
• To “tsum,” add the discrepancy between “right ps” and “left ps.
• Transfer the “temp” pointer to the following node.

Below is the implementation of the above approach:

## C++

 // C++ implementation of the approach #include using namespace std;   // Structure of a node of linked list class Node { public:     int data;     Node* next;     Node(int data)     {         this->data = data;         this->next = NULL;     } };    // Function to find the total distance sum int distanceSum(Node* head) {       // If head is null     if (head == NULL)         return 0;       // To store the required sum     int tsum = 0;     Node* temp = head;       // Traversing through all the nodes one by one     while (temp != NULL) {         double sq_root = sqrt(temp->data);           // If current node is not a perfect square         // then find left perfect square and         // right perfect square         if (sq_root < temp->data) {             int left_ps = (int)floor(sq_root)                           * (int)floor(sq_root);             int right_ps = (int)ceil(sq_root)                            * (int)ceil(sq_root);             tsum += right_ps - left_ps;         }         // Get to the next node         temp = temp->next;     }     return tsum; }   // Driver code int main() {     Node* head = new Node(3);     head->next = new Node(15);     head->next->next = new Node(7);     head->next->next->next = new Node(40);     head->next->next->next->next = new Node(42);     int result = distanceSum(head);     cout << result << endl;     return 0; }   // This code is contributed by divyeshrabadiya07

## Java

 // Java implementation of the approach class GFG {     //  Structure of a node of linked list     static class Node {         int data;         Node next;         Node(int data)         {             this.data = data;             this.next = null;         }     }       // Function to find the total distance sum     static int distanceSum(Node head)     {           // If head is null         if (head == null)             return 0;           // To store the required sum         int tsum = 0;         Node temp = head;           // Traversing through all the nodes one by one         while (temp != null) {             double sq_root = Math.sqrt(temp.data);               // If current node is not a perfect square             // then find left perfect square and             // right perfect square             if (sq_root < temp.data) {                 int left_ps = (int)Math.floor(sq_root)                               * (int)Math.floor(sq_root);                 int right_ps = (int)Math.ceil(sq_root)                                * (int)Math.ceil(sq_root);                 tsum += right_ps - left_ps;             }             // Get to the next node             temp = temp.next;         }           return tsum;     }       // Driver code     public static void main(String[] args)     {         Node head = new Node(3);         head.next = new Node(15);         head.next.next = new Node(7);         head.next.next.next = new Node(40);         head.next.next.next.next = new Node(42);           int result = distanceSum(head);           System.out.println(result);     } }

## Python3

 # Python3 implementation of the approach import sys import math   # Structure for a node class Node:     def __init__(self, data):         self.data = data         self.next = None   # Function to find the total distance sum def distanceSum(head):       # If head is null     if not head:         return           # To store the required sum     tsum = 0     temp = head           # Traversing through all the nodes one by one     while(temp):         sq_root = math.sqrt(temp.data)       # If current node is not a perfect square     # then find left perfect square and     # right perfect square         if sq_root < temp.data:             left_ps = math.floor(sq_root) ** 2             right_ps = math.ceil(sq_root) ** 2             tsum += (right_ps - left_ps)                   # Get to the next node         temp = temp.next     return tsum   # Driver code if __name__=='__main__':     head = Node(3)     head.next = Node(15)     head.next.next = Node(7)     head.next.next.next = Node(40)     head.next.next.next.next = Node(42)       result = distanceSum(head)     print("{}".format(result))       # This code is contributed by rutvik_56

## C#

 // C# implementation of the approach using System; using System.Collections; using System.Collections.Generic;   class GFG {         //  Structure of a node of linked list     class Node     {         public int data;         public Node next;         public Node(int data)         {             this.data = data;             this.next = null;         }     }       // Function to find the total distance sum     static int distanceSum(Node head)     {           // If head is null         if (head == null)             return 0;           // To store the required sum         int tsum = 0;         Node temp = head;           // Traversing through all the nodes one by one         while (temp != null)         {             double sq_root = Math.Sqrt(temp.data);               // If current node is not a perfect square             // then find left perfect square and             // right perfect square             if (sq_root < temp.data)             {                 int left_ps = (int)Math.Floor(sq_root)                               * (int)Math.Floor(sq_root);                 int right_ps = (int)Math.Ceiling(sq_root)                                * (int)Math.Ceiling(sq_root);                 tsum += right_ps - left_ps;             }                         // Get to the next node             temp = temp.next;         }         return tsum;     }       // Driver code     public static void Main(string[] args)     {         Node head = new Node(3);         head.next = new Node(15);         head.next.next = new Node(7);         head.next.next.next = new Node(40);         head.next.next.next.next = new Node(42);         int result = distanceSum(head);         Console.Write(result);     } }   // This code is contributed by pratham76

## Javascript



Output:

41

Time Complexity: O(n*sqrt(maximum element in linked list))

Space Complexity: O(1)

Previous
Next