Well I think in custom input author does not want this

Wasted a lot of my time

C solution:

Node* InsertNth(Node *head, int data, int position)
{
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;

    if (head == NULL) {
        return newNode;
    }

    if (position == 0) {
       newNode->next = head;
       return newNode;
    }

    Node *currentNode = head;
    while (position - 1 > 0) {
        currentNode = currentNode->next;
        position--;
    }

    newNode->next = currentNode->next;
    currentNode->next = newNode;

    return head;
 }

I think next time it is good to clarify things like this !

@hejohnny : you dont need to check "head.next != null" in while loop as it is mentioned in the question that position will be in between 0 and the number of nodes of the linked list provided.

In addition, the head may not be null the first time this method is called. For the given test case, the 3 uses If(position==0) condition instead of head==null condition as we would expect.

Hey, I am Greg :) I was looking through your code and I see the implementation accepts duplicate values, at least my local test printed duplicates.

It is really amasing, according to test case and expected output no duplicates must be contained, but actually your code passes the test :)

I have just posted also my solution which is somehow wrong but only for last entrie magically, because on my local environment it runs correctly....

can you please explain the above code ? I didn't get it fully.

My idea is similar:

Node InsertNth(Node head, int data, int position) {
    Node newNode = new Node();
    newNode.data = data;
    
    // Special case: insert in the front
    if(position == 0) {
        newNode.next = head;
        return newNode;
    }
    
    // Other cases: found the node at position - 1
    //         newNode.next = Node(position -1).next
    //         Update Node(position -1).next = newNode
    Node cur = head;
    int curPos = 0;
    while(curPos != position - 1) {
        cur = cur.next;
        curPos += 1;
    }
    
    newNode.next = cur.next;
    cur.next = newNode;
    return head;
}

this solution works..test it after a long time of trying to solve this. i still have a doubt.. The head node at first has a 2 so it is 2-null The sequence of operation then is given as.. 3 0, 3-2-null 5 1, 3-5-2-null 4 2, 3-5-4-2-null 2 3, 3-5-4-2-2-null 10 1, 3-10-5-4-2-2-null (should this be the result instead of 3-10-5-4-2?) correct me if i am wrong! Thank you.

@hejohnny Here, inside the while loop you have used position but you have not defined it. Won't that be a problem for compiler?

Here's my solution in Java. I missed the fact that head could be null. Thanks to you! But the traversal part in your solution seems complex, so I thought I could post mine.

Node InsertNth(Node head, int data, int position) {
    Node newNode = new Node();
    newNode.data = data;
    
    if(head == null)
        return newNode;
    else if(position == 0) {
        newNode.next = head;
        return newNode;
    }
    
    Node currNode = head;
    
    for(int i=0; i<position-1; i++) {
        currNode = currNode.next;   
    }
    
    newNode.next = currNode.next;
    currNode.next = newNode;
    
    return head;
}

Why not simply we can write the below:

//Inserting a Node in-between a List or at the end of of a List nodeToInsert.next = head.next; head.next = nodeToInsert;

return trackedHeadNode;

My Solution

SinglyLinkedListNode n=new SinglyLinkedListNode(data);

    SinglyLinkedListNode node=head;
      while(position!=1 && node.next!=null)
      {
          node=node.next;
          position--;
      }
      SinglyLinkedListNode temp=node.next;
     node.next=n;
     n.next=temp;
     return head;

Another node assignment is not required;

static SinglyLinkedListNode insertNodeAtPosition(SinglyLinkedListNode head, int data, int position) {

    SinglyLinkedListNode headNode = head;

    SinglyLinkedListNode newNode = new SinglyLinkedListNode(data);

    int pos = 0;   

    while(headNode.next != null && pos < position - 1){    

            headNode = headNode.next;

            pos++;

    }

    SinglyLinkedListNode nodeAtPosition = headNode.next;

    headNode.next = newNode;

    newNode.next = nodeAtPosition;

    return head;

}

Much too long, you can simplify this by not iterating when you don't need to.

    Node newNode = new Node();
    newNode.data = data;
    Node current = head;  
    
    if( position == 0 ){
        newNode.next = head;
        return newNode;
    }
    
    int counter = 0;
    while( ++counter < position ){
        current = current.next;
    }
        
    newNode.next = current.next;   
    current.next = newNode;   
    
    return head;

head.next = InsertNth(head.next,data,position-1);

Why you used head.next why not only head?

I got almost the same answer. There is a small improvement to be had.

def insertNodeAtPosition(head, data, position):
    n = head
    for _ in range(position - 1):
        n = n.next
    n_next = n.next
    n.next = SinglyLinkedListNode(data)
    n.next.next = n_next
    return head

Can someone explain me this code?

I just hacked in a check at the beginning:

if (head->data == 2) { delete head; head = nullptr; }

And then another special case hack to insert a node containing 2 after the 4.

There is nothing wrong with the test case. Hunter_ likely had an off by one error.

Edit: Just FYI, the "hack" he used wouldn't work against virtually any other test case. Check the section of code where you iterate. There is likely an off by one error there if your output is incorrectly ordered.

your comment is useless without some details

your logic is unnessessarily complicated. Here's a better python3 version

def InsertNth(head, data, position):
	if position == 0:
		node_to_isert = Node(data=data, next_node=head)
		return node_to_isert
		
	node = head
	for i in range(position-1):
		node = node.next

	node_to_isert = Node(data=data, next_node=node.next)
	node.next = node_to_isert
	return head