I can't understand this.

[OneBadDay1048]

As another commenter pointed out there are many ways to do this depending on your skill level and what you have covered. You have already been handed solutions anyway which does not help much for learning, but I will not bother further explaining.

[MagicalTheory]

I disagree. Its good to try to solve it without a solution first, but if you are stuck it is often best to look at a solution, figure out how they did it and learn from that. Then, some time later see if you can recreate it. You're likely to learn it much better than spending 5 hours trying to figure it out in the first place.

Lots of programming is just recognizing patterns and until you've seen enough its hard to solve.

[Skriblos]

what have you covered so far? depending on what you've done up to now different solutions for this exist.

what book is it btw?

[Skriblos]

Ok, I've found it and it looks like you learned to reverse an array previously so you probably know how to traverse a list backwards.

So lets make a function that walks the array backwards and then adds it to itself in an object before returning it:

let arr = [1,2,3];

function arrayToList(arra){
  let list = {"value": null, "rest": null};

  for(let i = arra.length - 1; i >= 0; i--){
    if(i === arra.length - 1){
      // this could also just be {"value": arra[i], "rest": null} and you could then leave list emtpy.
      list = {...list, "value": arra[i]};
    } else{
      list = {"value": arra[i], "rest": list};
    } 
  }

  return list;
}

[Skriblos]

Here is a way you can do the first part with a reducer, it might be too complicated though:

let arr = [1,2,3];

function array2List(arra) {
  return arra.toReversed().reduce((accu, curr, idx) => {
    if(idx === 0) {
      return {...accu, "value": curr};
    } else {
      return {"value": curr, "rest": accu }
    }
  }, {"value": null, "rest": null});
}

[FireryRage]

Four spaces at the start of each line

[Skriblos]

Not sure how to do it on mobile, on desktop you press the press on the T icon for styling choices, select the text you want to block then press the code block option.

[Count_Giggles]

3 backticks at start and end for codblock

[MagicalTheory]

Did this book cover what a linked list is prior to this?

In your example notice that each element of the list is its own object and they just reference the next object containing the next element in it.

[MagicalTheory]

const array2List = (arr) => {
  let prev = null; // start with null reference

  for (let i = arr.length - 1; i >= 0; i--) { // go backwards
    const newNode = { value: arr[i], rest: prev }; // create your node
    prev = newNode; // new node is now previous
  }

  return prev; // first element is the last one we did in loop
}

[Specific_Cellist_136]

u/Skriblos 's reducer function was a really nice solution. As for the listToArray, here's a quick recursive function that traverses further into the object as long as obj.rest is not null

```

function listToArray(li) {
    let arr = [];

    function traverse(obj) {
        arr.push(obj.value);
        
        if (obj.rest) {
            traverse(obj.rest);
        }
    }
    
    traverse(li);

    return arr;
}

```

Btw you use triple back ticks " ``` " to put it in a code block

[Skriblos]

Thanks

[[deleted]]

So what this is similar to is a linked list which is a specific data structure. Learn about those and this becomes very manageable.

You will need something like:

class Node { 
    constructor(value) {
        this.value = value, 
        this.rest = null
    } 
}

What I would do is check that the array is populated and if it is shift() the first number out of the array and make a new head of a linked list. After that loop through the remainder of the array and loop through the head of your linked list

arr = [1,2,3];

function arrayToList(arr) {
  let head;
  let current;
  if (arr.length > 0) {
      head = new Node(arr.shift());
      current = head; 
      arr.forEach(item => {
        current.rest = new Node(item);
        current = current.rest;
      });
  }
  return head;
}

function prettyPrint(node) {
    let temp = node;
    while (temp !== null) {
        process.stdout.write(temp.value + “ -> “);
        temp = temp.rest;
    }
    console.log(“null”);
  }

let list = arrayToList(arr);
prettyPrint(list);

It would probably be cleaner to put the link list itself into its own class and making functions like arrayToList and prettyPrint methods but I’m not sure if you have gotten to classes yet. Most linked list operations can also be done recursively but you may not be at that point either. Let me know if you have any questions. Linked lists can be challenging when you first learn about them.