same thing i am facing too

Subject: Issue with the "Insert a Node at a Specific Position in a Linked List" Challenge

Hello,

I am experiencing a problem with the "Insert a Node at a Specific Position in a Linked List" challenge. Specifically, I am encountering compilation errors related to the method declaration and access.

Errors Encountered:

*Illegal Static Declaration: The insertNodeAtPosition method, which is supposed to be used in the Result class, cannot be called directly due to the static modifier issue. This results in an error:

Solution.java:78: error: Illegal static declaration in inner class Solution.Result public static SinglyLinkedListNode insertNodeAtPosition(SinglyLinkedListNode llist, int data, int position) { Cannot Find Symbol: When attempting to call insertNodeAtPosition from the main method, the compiler reports that it cannot find the method:

Solution.java:128: error: cannot find symbol SinglyLinkedListNode llisthead = insertNodeAtPosition(llist.head, data, position);

here is my code(i've only written in the part inside the function insertNodeAtPosition, not changed anything in the set up)

: 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 {

static class SinglyLinkedListNode {
    public int data;
    public SinglyLinkedListNode next;

    public SinglyLinkedListNode(int nodeData) {
        this.data = nodeData;
        this.next = null;
    }
}

static class SinglyLinkedList {
    public SinglyLinkedListNode head;
    public SinglyLinkedListNode tail;

    public SinglyLinkedList() {
        this.head = null;
        this.tail = null;
    }

    public void insertNode(int nodeData) {
        SinglyLinkedListNode node = new SinglyLinkedListNode(nodeData);

        if (this.head == null) {
            this.head = node;
        } 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);
        }
    }
}

// Move Result class to be inside Solution class
static class Result {

    /*
     * Complete the 'insertNodeAtPosition' function below.
     *
     * The function is expected to return an INTEGER_SINGLY_LINKED_LIST.
     * The function accepts following parameters:
     *  1. INTEGER_SINGLY_LINKED_LIST llist
     *  2. INTEGER data
     *  3. INTEGER position
     */

    /*
     * For your reference:
     *
     * SinglyLinkedListNode {
     *     int data;
     *     SinglyLinkedListNode next;
     * }
     *
     */

    public static SinglyLinkedListNode insertNodeAtPosition(SinglyLinkedListNode llist, int data, int position) {
        SinglyLinkedListNode newnode = new SinglyLinkedListNode(data);

        if (position == 0) {
            newnode.next = llist;
            llist = newnode;
        } else {
            SinglyLinkedListNode temp = llist;
            SinglyLinkedListNode prev = null; // Updated to handle cases correctly
            int n = 0;
            while (n != position) {
                prev = temp;
                temp = temp.next;
                n++;
            }
            newnode.next = temp;
            if (prev != null) {
                prev.next = newnode;
            }
        }
        return llist;
    }

}

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")));

    SinglyLinkedList llist = new SinglyLinkedList();

    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 data = scanner.nextInt();
    scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

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

    SinglyLinkedListNode llist_head = Result.insertNodeAtPosition(llist.head, data, position); // Call insertNodeAtPosition from Result class

    printSinglyLinkedList(llist_head, " ", bufferedWriter);
    bufferedWriter.newLine();

    bufferedWriter.close();

    scanner.close();
}

}

**Request: **Could you please review the challenge setup and method declarations to ensure they align with the instructions provided? It appears that the method needs to be properly scoped and referenced to work within the provided code structure.

Thank you for your assistance.

Is there a way to do this in rust without having to use unsafe code blocks?

Sol in C++

SinglyLinkedListNode* insertNodeAtPosition(SinglyLinkedListNode* llist, int data, int position) { SinglyLinkedListNode* newNode = new SinglyLinkedListNode(data);

if(position == 0){
    newNode -> next = llist;
    llist = newNode;
    return llist;
}else{
    SinglyLinkedListNode* current = llist;
    int i=0;
    while(i<position-1 && current->next!=nullptr){
        current = current->next;
        i++;
    }
    if(current->next == nullptr){
        newNode->next = nullptr;
        current->next = newNode;
    }else{
        newNode -> next = current->next;
        current -> next = newNode;
    }
    return llist;   
}

}

In c language

SinglyLinkedListNode* insertNodeAtPosition(SinglyLinkedListNode* llist, int data, int position) { struct Node *ptr = (struct Node *)malloc(sizeof(struct Node )); struct Node * p = llist; int i = 0;

while (i!=position-1) {
    p = p->next;
    i++;
}
ptr->data=data;
ptr->next = p->next;
p->next = ptr;
return llist;

}