can you explain why your code works ??

The way you solved this the best one in my opinion. Congratulations!!!

Nice

Really nice logic!

nice logic :)

Clever

Excellent work!!

very clever!

Elegant solution... Bravo

Brilliant solution!

Really nice congrats!!

How did you come up with this? Beautiful.

Very smart solution !

very clever. I adapted this and it all worked out!

Awesome.

1) Similar idea of using two points to detect whether there is any cycle or not.

2) Also, pay attention to the differece between C++ and Java about their operator priority. C++ (index++>positionFromTail) equals to (++index>positionFromTail) !

beautiful solution #salcio

python version

def GetNode(head, position):
    h1 = head
    h2 = head 
    while 1:
        h2 = h2.next
        if not h2:
            return h1.data
        if position == 0:
            h1 = h1.next
        else:
            position -= 1

Nice Solution. Here is the same idea in python:

def GetNode(head, position):
    tracked = head
    while position > 0:
        head = head.next
        position -= 1
        
    while head.next:
        head = head.next
        tracked = tracked.next
        
    return tracked.data

Brilliant!!

Here is my code in java based on your algorithm.

    int GetNode(Node head, int n) {
        Node pointer = head;        
        int pointerPosition = 0;

        while (head.next != null){
            head = head.next;
            if (pointerPosition < n){
                pointerPosition++;
            }else {
                pointer = pointer.next;
            }
        }

        return pointer.data;
    }

That's brilliant, salcio! I'm surprised their test case allow passing with double traversal.

Ahhh this is great. Smart person!

very clever solutions

I hate to see solutions in the Discussions page. But this one is an exception. Clever and simple. Persons who get the solution correct at first go and miss this post are going to be unlucky...

awesome, you're so smart!

nice idea...

void printNthFromLast(struct node* head, int n) { static int i = 0; if (head == NULL) return; printNthFromLast(head->next, n); if (++i == n) printf("%d", head->data); }

Very nice, doing (n - positionFromTail) iterations from the head by ignoring the first (positionFromTail) when counting all (n).

there is no need to declare current : Java Solution :

int GetNode(Node head,int n) { Node result = head; int i = 0; while(head != null) { head = head.next; if(i++ > n) { result = result.next; } } return result.data;

}

Salcio, your solution is excellent, but you can simplify the code even further by not maintaining a separate "current" pointer.

int GetNode(Node *head,int positionFromTail)
{
    Node* tortoise = head;
    int index = 0;
    
    while (head->next) {
        head = head->next;
        if (++index > positionFromTail) {
            tortoise = tortoise->next;
        } 
    }
    
    return tortoise->data;
}

Awesome!! I really am implressed by your logic.

oh dam son

really good one

Smart, heck smart!

Salute to this solution!!! awesome!!

Beautiful solution

Nice approach. But, we dont need current pointer here. This solution works without that.
Python code (same approach)

def GetNode(head, position):
    index = 0
    result = head
    while(head.next != None):
        head = head.next
        index += 1
        if(index > position):
            result = result.next
    
    return result.data

When you think about it, its the same thing as explained in the editorial combined inside one loop.

Fantastic :)

super

Awesome..

it's really an amazing way to solve this problem!

Awesome logic

Kudos Dude! smart thinking!

simple java solution based on this algorithm

int GetNode(Node head,int n) {
     // This is a "method-only" submission. 
     // You only need to complete this method. 
    Node curr = head;
    for(int i = 0; i<n;i++){
        head = head.next;
    }
    while(head.next!=null){
        head=head.next;
        curr=curr.next;
    }
    return curr.data;

}

ingenious.

kudos! very clever solution.

INCREDIBLE!!

shorter

int GetNode(Node *head,int positionFromTail)
{
    Node *p = head;
    while(head) {
        if(positionFromTail < 0) p = p->next;
        positionFromTail--;
        head = head->next;
    }
    return p->data;
}

How are you people so smart -.-

great solution

Awesome man!

Great explanation. I rewrite the idea in the following way

int GetNode(Node *head,int positionFromTail)
{
    // walks in the liked list
    Node *iter = head;
    for (int i=0; i <= positionFromTail; ++i){
        iter = iter->next;
    }
    Node *result=head;
    while(iter != NULL){
        iter = iter->next;
        result = result->next;
    }

    return result->data;
}

Thank you for the code it's really a nice one.

superb logic .

Incredible,it's very smart solution i just want to ask you that how did you think of this solution ,can you tell me the strategy behind this, if you could than it would be really kind of you :) :) :)

note that this is completely equivalent to iterating twice through the list with a single pointer, since we are iterating two pointers.

Nice idea !!

Amazing solution! I would have never thought like this.

nice

But we start from tail position

i am failed to understand this.. Please explain

Awesome and simple logic.

Can you tell me what i>=n does in your if statement.

a new different idea!

instead of prepending to the array, you can also do this:

def GetNode(head, position):
    out = []
    while head:
        out.append(head.data)
        head = head.next
        
    return out[-(position + 1)]

int getNode( SinglyLinkedListNode * head , int positionFromTail) {

     SinglyLinkedListNode * cur = head;
   SinglyLinkedListNode *prev =head;
while(positionFromTail){
    cur=cur->next;
    positionFromTail--;    
    }


while(cur!=NULL){
    prev=prev->next;
    cur=cur->next;
}

return prev->data;

}

thanks!