## Algorithm

Problem Name: Data Structures - Get Node Value

In this HackerRank in Data Structures - Get Node Value solutions

Given a pointer to the head of a linked list and a specific position, determine the data value at that position. Count backwards from the tail node. The tail is at postion 0, its parent is at 1 and so on.

Example

head refers to 3 -> 2 -> 1 -> 0 -.> NULL

positionFromTail = 2

Each of the data values matches its distance from the tail. The value 2 is at the desired position.

Function Description

Complete the getNode function in the editor below.

getNode has the following parameters:

• int positionFromTail: the item to retrieve

Returns

• int: the value at the desired position

Input Format

The first line contains an integer t, the number of test cases. Each test case has the following format:
The first line contains an integer n, he number of elements in the linked list.
The next n lines contains an integer, the data value for an element of the linked list.
The last line contains an integer positionFromTail, the position from the tail to retrieve the value of.

Constraints

• 1 <= t <= 10
• 1 <= n,m <= 1000
• 1 <= list1[i],list2[i] <= 1000, where list[i] is the i**th element of the list.
• 0 <= positionFromTail < n

Sample Input

``````2
1
1
0
3
3
2
1
2
``````

Sample Output

``````1
3
``````

Explanation

In the first case, there is one element in linked list with a value of 1. The last (only) element contains 1.

In the second case, the list is 3 -> 2 -> 1 -> NULL. The element with position of 2 from tail contains 3.

## Code Examples

### #1 Code Example with C Programming

```Code - C Programming```

``````
#include <assert.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int data;
};

};

node->data = node_data;
node->next = NULL;

return node;
}

} else {
}

}

while (node) {
fprintf(fptr, "%d", node->data);

node = node->next;

if (node) {
fprintf(fptr, "%s", sep);
}
}
}

while (node) {
node = node->next;

free(temp);
}
}

/*
* Complete the 'getNode' function below.
*
* The function is expected to return an INTEGER.
* The function accepts following parameters:
*  2. INTEGER positionFromTail
*/

/*
*
*     int data;
* };
*
*/

{
int total = 0;

// get the number of the total number of node
while( nodePtr )
{
total++;
nodePtr = nodePtr->next;
}

for( int indx = 0; indx  <  total-positionFromTail-1; indx++ )
{
nodePtr = nodePtr->next;
}
return nodePtr->data;

}

int main()
{
FILE* fptr = fopen(getenv("OUTPUT_PATH"), "w");

char* tests_endptr;
int tests = strtol(tests_str, &tests_endptr, 10);

if (tests_endptr == tests_str || *tests_endptr != '\0') { exit(EXIT_FAILURE); }

for (int tests_itr = 0; tests_itr  <  tests; tests_itr++) {
llist->tail = NULL;

char* llist_count_endptr;
int llist_count = strtol(llist_count_str, &llist_count_endptr, 10);

if (llist_count_endptr == llist_count_str || *llist_count_endptr != '\0') { exit(EXIT_FAILURE); }

for (int i = 0; i  <  llist_count; i++) {
char* llist_item_endptr;
int llist_item = strtol(llist_item_str, &llist_item_endptr, 10);

if (llist_item_endptr == llist_item_str || *llist_item_endptr != '\0') { exit(EXIT_FAILURE); }

}

char* position_endptr;
int position = strtol(position_str, &position_endptr, 10);

if (position_endptr == position_str || *position_endptr != '\0') { exit(EXIT_FAILURE); }

fprintf(fptr, "%d\n", result);
}

fclose(fptr);

return 0;
}

size_t alloc_length = 1024;
size_t data_length = 0;
char* data = malloc(alloc_length);

while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);

if (!line) { break; }

data_length += strlen(cursor);

if (data_length  <  alloc_length - 1 || data[data_length - 1] == '\n') { break; }

size_t new_length = alloc_length << 1;
data = realloc(data, new_length);

if (!data) { break; }

alloc_length = new_length;
}

if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';
}

data = realloc(data, data_length);

return data;
}
``````
Copy The Code &

### #2 Code Example with C++ Programming

```Code - C++ Programming```

``````
#include <bits/stdc++.h>

using namespace std;

public:
int data;

this->data = node_data;
this->next = nullptr;
}
};

public:

this->tail = nullptr;
}

void insert_node(int node_data) {

} else {
this->tail->next = node;
}

this->tail = node;
}
};

while (node) {
fout << node->data;

node = node->next;

if (node) {
fout << sep;
}
}
}

while (node) {
node = node->next;

free(temp);
}
}

int n = 0;
while(tmp) {n++; tmp = tmp->next;}
fprintf(stderr, "n: %d\n", n);
int pos = n - positionFromTail-1;
fprintf(stderr, "Pos: %d\n", pos);
}

int main()
{
ofstream fout(getenv("OUTPUT_PATH"));

int tests;
cin >> tests;
cin.ignore(numeric_limits < streamsize>::max(), '\n');

for (int tests_itr = 0; tests_itr  <  tests; tests_itr++) {

int llist_count;
cin >> llist_count;
cin.ignore(numeric_limits < streamsize>::max(), '\n');

for (int i = 0; i  <  llist_count; i++) {
int llist_item;
cin >> llist_item;
cin.ignore(numeric_limits < streamsize>::max(), '\n');

llist->insert_node(llist_item);
}

int position;
cin >> position;
cin.ignore(numeric_limits < streamsize>::max(), '\n');

fout << result << "\n";
}

fout.close();

return 0;
}
``````
Copy The Code &

### #3 Code Example with Java Programming

```Code - Java Programming```

``````
import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

public class Solution {

public int data;

this.data = nodeData;
this.next = null;
}
}

this.tail = null;
}

public void insertNode(int nodeData) {

} else {
this.tail.next = node;
}

this.tail = node;
}
}

public static void printSinglyLinkedList(SinglyLinkedListNode node, String sep, BufferedWriter bufferedWriter) throws IOException {
while (node != null) {
bufferedWriter.write(String.valueOf(node.data));

node = node.next;

if (node != null) {
bufferedWriter.write(sep);
}
}
}

int pos = 0;
while (pos  <  positionFromTail) {
fast = fast.next;
pos++;
}
while (fast.next!=null) {
slow = slow.next;
fast = fast.next;
}

return slow.data;

}

private static final Scanner scanner = new Scanner(System.in);

public static void main(String[] args) throws IOException {
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

int tests = scanner.nextInt();
scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

for (int testsItr = 0; testsItr  <  tests; testsItr++) {

int llistCount = scanner.nextInt();
scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

for (int i = 0; i  <  llistCount; i++) {
int llistItem = scanner.nextInt();
scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

llist.insertNode(llistItem);
}

int position = scanner.nextInt();
scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

bufferedWriter.write(String.valueOf(result));
bufferedWriter.newLine();
}

bufferedWriter.close();

scanner.close();
}
}
``````
Copy The Code &

### #4 Code Example with Javascript Programming

```Code - Javascript Programming```

``````
'use strict';

const fs = require('fs');

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
inputString += inputStdin;
});

process.stdin.on('end', _ => {
inputString = inputString.replace(/\s*\$/, '')
.split('\n')
.map(str => str.replace(/\s*\$/, ''));

main();
});

return inputString[currentLine++];
}

constructor(nodeData) {
this.data = nodeData;
this.next = null;
}
};

constructor() {
this.tail = null;
}

insertNode(nodeData) {

} else {
this.tail.next = node;
}

this.tail = node;
}
};

while (node != null) {
ws.write(String(node.data));

node = node.next;

if (node != null) {
ws.write(sep);
}
}
}

/*
* Complete the 'getNode' function below.
*
* The function is expected to return an INTEGER.
* The function accepts following parameters:
*  2. INTEGER positionFromTail
*/

/*
*
*     int data;
* }
*
*/

var prev
var next
while(current) {
next = current.next;
current.next = prev;
prev = current;
current = next;
}
for(var i = 0; i  <  position; i++){
prev = prev.next;
}
return prev.data;
}

function main() {
const ws = fs.createWriteStream(process.env.OUTPUT_PATH);

for (let testsItr = 0; testsItr  <  tests; testsItr++) {

for (let i = 0; i  <  llistCount; i++) {
llist.insertNode(llistItem);
}

ws.write(result + "\n");
}

ws.end();
}
``````
Copy The Code &

### #5 Code Example with Python Programming

```Code - Python Programming```

``````
#!/bin/python3

import math
import os
import random
import re
import sys

def __init__(self, node_data):
self.data = node_data
self.next = None

def __init__(self):
self.tail = None

def insert_node(self, node_data):

else:
self.tail.next = node

self.tail = node

while node:
fptr.write(str(node.data))

node = node.next

if node:
fptr.write(sep)

#
# Complete the 'getNode' function below.
#
# The function is expected to return an INTEGER.
# The function accepts following parameters:
#  2. INTEGER positionFromTail
#

#
#
#     int data
#
#

return None
lst_len = 0
while ptr.next:
lst_len += 1
ptr = ptr.next
while lst_len > position:
lst_len -= 1

if __name__ == '__main__':
fptr = open(os.environ['OUTPUT_PATH'], 'w')

tests = int(input())

for tests_itr in range(tests):
llist_count = int(input())

for _ in range(llist_count):
llist_item = int(input())
llist.insert_node(llist_item)

position = int(input())