Skip to content
Related Articles

Related Articles

Improve Article

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

  • Last Updated : 21 Jun, 2021

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).
Below is the implementation of the above approach:
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
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




<script>
 
      // JavaScript implementation of the approach
      // Structure of a node of linked list
      class Node {
        constructor(data) {
          this.data = data;
          this.next = null;
        }
      }
 
      // Function to find the total distance sum
      function distanceSum(head) {
        // If head is null
        if (head == null) return 0;
 
        // To store the required sum
        var tsum = 0;
        var temp = head;
 
        // Traversing through all the nodes one by one
        while (temp != null) {
          var 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) {
            var left_ps =
              parseInt(Math.floor(sq_root)) *
              parseInt(Math.floor(sq_root));
            var right_ps =
              parseInt(Math.ceil(sq_root)) *
              parseInt(Math.ceil(sq_root));
            tsum += right_ps - left_ps;
          }
 
          // Get to the next node
          temp = temp.next;
        }
        return tsum;
      }
 
      // Driver code
      var 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);
      var result = distanceSum(head);
      document.write(result);
       
</script>
Output: 



41

 

Time Complexity: O(n)
 

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :