Replace every node in a linked list with its closest triangular number
Last Updated :
28 Aug, 2023
Given a singly linked list, the task is to replace every node with its closest triangular number.
Examples:
Input: 3 -> 9 -> 21 -> 25 -> NULL
Output: 3 -> 10 -> 21 -> 28 -> NULL
Explanation: The closest Triangular numbers for each node are:
- Node 1 (value = 3): Closest Triangular number = 3.
- Node 2 (value = 9): Closest Triangular number = 10.
- Node 3 (value = 21): Closest Triangular number = 21.
- Node 4 (value = 25): Closest Triangular number = 28.
Input: 10 -> 15 -> 30 -> 40 -> 50 -> NULL
Output: 10 -> 15 -> 28-> 36 -> 45 -> NULL
Explanation: The closest Triangular numbers for each node are:
- Node 1 (value = 10): Closest Triangular number = 10.
- Node 2 (value = 15): Closest Triangular number = 15.
- Node 3 (value = 30): Closest Triangular number = 28.
- Node 4 (value = 40): Closest Triangular number = 36.
- Node 5 (value = 50): Closest Triangular number = 45.
Approach: This can be solved with the following idea:
This approach uses the concept of triangular numbers to replace every node in a linked list with its closest triangular number. Triangular numbers are the numbers that can be represented in the form of a triangular grid of points, where each row contains one more point than the previous one. The nth triangular number is the sum of the first n natural numbers, i.e., T(n) = 1 + 2 + … + n = n(n+1)/2. To find the closest triangular number for a given integer, we first find the smallest triangular number that is greater than or equal to the given integer. We can use the formula for the nth triangular number to find this. If the difference between this triangular number and the given integer is less than the difference between the previous triangular number and the given integer, we choose this triangular number as the closest one. Otherwise, we choose the previous triangular number as the closest one. Using this approach, we iterate through the linked list and replace the value of each node with its closest triangular number. Finally, we return the head of the modified linked list and print it to verify the output.
Steps of the above approach:
- Inside the closestTriangular() function initialize a variable ‘i’ to 1, which represents the index of the triangular number we will start with.
- Use a while loop to iterate through each triangular number until we find the smallest triangular number that is greater than or equal to the input ‘n’. The formula for the nth triangular number is n*(n+1)/2.
- Compute the two closest triangular numbers to ‘n’ by using the formula for the (i-1)th triangular number and the ith triangular number.
- Determine which of the two closest triangular numbers is actually closer to the input ‘n’ using the absolute value function abs() and a conditional statement.
- Return the closest triangular number.
- Then inside the replaceWithClosestTriangular() function Initialize a pointer variable ‘curr’ to the head of the linked list.
- Use a while loop to iterate through each node in the linked list.
- Call the closest triangular () function for each node to find its closest triangular number.
- Update the value of the current node with its closest triangular number.
- Move to the next node in the linked list by updating the pointer variable ‘curr’ to point to the next node.
- Return the head of the modified linked list.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
Node* next;
Node( int x)
: data(x), next(NULL)
{
}
};
int closestTriangular( int n)
{
int i = 1;
while (i * (i + 1) / 2 < n) {
i++;
}
int tn1 = i * (i + 1) / 2;
int tn2 = (i - 1) * i / 2;
if ( abs (tn1 - n) < abs (tn2 - n)) {
return tn1;
}
else {
return tn2;
}
}
Node* replaceWithClosestTriangular(Node* head)
{
Node* curr = head;
while (curr) {
int closest = closestTriangular(curr->data);
curr->data = closest;
curr = curr->next;
}
return head;
}
void printList(Node* head)
{
Node* curr = head;
while (curr) {
cout << curr->data << " -> " ;
curr = curr->next;
}
cout << "NULL" << endl;
}
int main()
{
Node* head = new Node(3);
head->next = new Node(9);
head->next->next = new Node(21);
head->next->next->next = new Node(25);
head = replaceWithClosestTriangular(head);
printList(head);
return 0;
}
|
Java
class Node {
int data;
Node next;
Node( int x) {
data = x;
next = null ;
}
}
public class ClosestTriangularNumber {
static int closestTriangular( int n) {
int i = 1 ;
while (i * (i + 1 ) / 2 < n) {
i++;
}
int tn1 = i * (i + 1 ) / 2 ;
int tn2 = (i - 1 ) * i / 2 ;
if (Math.abs(tn1 - n) < Math.abs(tn2 - n)) {
return tn1;
} else {
return tn2;
}
}
static Node replaceWithClosestTriangular(Node head) {
Node curr = head;
while (curr != null ) {
int closest = closestTriangular(curr.data);
curr.data = closest;
curr = curr.next;
}
return head;
}
static void printList(Node head) {
Node curr = head;
while (curr != null ) {
System.out.print(curr.data + " -> " );
curr = curr.next;
}
System.out.println( "NULL" );
}
public static void main(String[] args) {
Node head = new Node( 3 );
head.next = new Node( 9 );
head.next.next = new Node( 21 );
head.next.next.next = new Node( 25 );
head = replaceWithClosestTriangular(head);
printList(head);
}
}
|
Python3
class Node:
def __init__( self , x):
self .data = x
self . next = None
def closestTriangular(n):
i = 1
while i * (i + 1 ) / / 2 < n:
i + = 1
tn1 = i * (i + 1 ) / / 2
tn2 = (i - 1 ) * i / / 2
if abs (tn1 - n) < abs (tn2 - n):
return tn1
else :
return tn2
def replaceWithClosestTriangular(head):
curr = head
while curr:
closest = closestTriangular(curr.data)
curr.data = closest
curr = curr. next
return head
def printList(head):
curr = head
while curr:
print (curr.data, "-> " , end = "")
curr = curr. next
print ( "NULL" )
if __name__ = = "__main__" :
head = Node( 3 )
head. next = Node( 9 )
head. next . next = Node( 21 )
head. next . next . next = Node( 25 )
head = replaceWithClosestTriangular(head)
printList(head)
|
C#
using System;
public class Node
{
public int data;
public Node next;
public Node( int x)
{
data = x;
next = null ;
}
}
public class GFG
{
public static int ClosestTriangular( int n)
{
int i = 1;
while (i * (i + 1) / 2 < n)
{
i++;
}
int tn1 = i * (i + 1) / 2;
int tn2 = (i - 1) * i / 2;
if (Math.Abs(tn1 - n) < Math.Abs(tn2 - n))
{
return tn1;
}
else
{
return tn2;
}
}
public static Node ReplaceWithClosestTriangular(Node head)
{
Node curr = head;
while (curr != null )
{
int closest = ClosestTriangular(curr.data);
curr.data = closest;
curr = curr.next;
}
return head;
}
public static void PrintList(Node head)
{
Node curr = head;
while (curr != null )
{
Console.Write(curr.data + " -> " );
curr = curr.next;
}
Console.WriteLine( "NULL" );
}
public static void Main( string [] args)
{
Node head = new Node(3);
head.next = new Node(9);
head.next.next = new Node(21);
head.next.next.next = new Node(25);
head = ReplaceWithClosestTriangular(head);
PrintList(head);
}
}
|
Javascript
class Node {
constructor(x) {
this .data = x;
this .next = null ;
}
}
function closestTriangular(n) {
let i = 1;
while (i * (i + 1) / 2 < n) {
i++;
}
const tn1 = i * (i + 1) / 2;
const tn2 = (i - 1) * i / 2;
return Math.abs(tn1 - n) < Math.abs(tn2 - n) ? tn1 : tn2;
}
function replaceWithClosestTriangular(head) {
let curr = head;
while (curr !== null ) {
const closest = closestTriangular(curr.data);
curr.data = closest;
curr = curr.next;
}
return head;
}
function printList(head) {
let curr = head;
while (curr !== null ) {
console.log(curr.data + " -> " );
curr = curr.next;
}
console.log( "NULL" );
}
const head = new Node(3);
head.next = new Node(9);
head.next.next = new Node(21);
head.next.next.next = new Node(25);
replaceWithClosestTriangular(head);
printList(head);
|
Output
3 -> 10 -> 21 -> 28 -> NULL
Time Complexity: O(n + sqrt(n))
Auxiliary Space: O(1), since we are not using any extra space.
Share your thoughts in the comments
Please Login to comment...