Enigma is like a never-ending loop.

It keeps calling itself by using the outcome of the rest function, which excludes the first element.

The end result is a combination of the previous result with the outcome of the first function, which fetches the first character and puts it at the end using conj.

For example, if you input [H e l l o],

it will generate conj(enigma([e l l o], H)

Then enigma([e l l o]) will give conj(enigma([l l o], e)

Followed by enigma([l l o]) resulting in conj(enigma([l o], l)

This process repeats until the array inside enigma is empty, at which point the recursion stops and goes back to the initial call.

Recursion is commonly used for exercises like this, but sometimes it's more efficient to avoid it due to the additional function call overhead. Using a simple loop might be a better option for some scenarios that involve moving or swapping items.

To understand the mechanics better, you can output some information:

function rest(arr) {
  return arr.slice(1);
}


function first(arr) {
  return arr[0];
}

function conj(arr, value) {
  arr.push(value);
  return arr;
}

function enigma(array, level) {
  if (array.length === 0) {
    console.log('Enigma level '+level+' is called with an empty array. Recursion ends here.. Stay tuned for the answer.');
    return [];
  }
  console.log('Enigma level '+level+' is called with '+array+
              '. I will move '+first(array)+' to the end.');
  
  var result = conj(enigma(rest(array), level+1), first(array));
  console.log('returning '+result+' for level '+level);
  return result;
}

console.log(enigma(['H','e','l','l','o'], 0));

In order to grasp the concept of a function that utilizes recursion, it can be helpful to temporarily envision that the recursive call returns the expected values, and then observe how it contributes to producing the accurate result.

For instance, let's assume that the array is initially set to [1, 2, 3, 4]

When we examine this specific line:

 conj(mystery(rest(array)), first(array));

... we encounter a recursive call to mystery. It takes the array as an argument, albeit with its first element eliminated (handled by

rest</code), resulting in <code>[2, 3, 4]

For the sake of understanding, let's presume that this recursive invocation of mystery correctly reverses the array to

[4, 3, 2]</code. Subsequently, based on the aforementioned code snippet, we observe that this outcome is combined with <code>first(array)

This instance illustrates that assuming mystery successfully handles an array with n-1 values guarantees it will also handle an array with n values correctly.

The final step involves ensuring that mystery manages the smallest case effectively, such as when the array is empty. It is evident that it produces the correct output in such scenarios, namely an empty array.

Hence, consolidating these observations confirms that mystery adeptly fulfills its function for arrays of all sizes.

the initial function "rest" eliminates the initial element by utilizing slice to extract elements starting from the second one to the final one in the array. Subsequently, the "conj" function regains the initial element that was extracted (by using the "first" function) and appends it at the end. This process is repeated recursively to shift elements from the beginning to the end.

Using the .push method adds an item to the end of an array. The .slice(1) function means “excluding the first item”

Algorithm

1. Retrieve array A (argument of mystery). If it is empty, return it
2. Extract rest (everything except the first item) and designate it as B
3. Recursively apply this program to B
4. Add the first item of A to the end of B

conj = add value to arr

first = retrieve first item of arr

rest = return everything except the first item

mystery when array is empty = return an empty array

mystery when array is not empty = Extract rest(array), apply mystery to it, then add the first of array

Recursion is truly magical. Imagine calling mystery with a 2-item array like [1,2].

rest(array) will be [2] and mystery(rest(array)) will also return [2].

first(array) is 1.

So, when you do conj([2], 1), you get [2,1].

Now, let's expand to 3 elements like [0,1,2] and call mystery:

• It calls mystery(rest(array)), which is essentially mystery([1,2]). This gives us [2,1] as we've seen.
• first(array) is 0.
• Therefore, conj([2,1],0) logically gives [2,1,0].

This recursive process can work for any number of elements. Each element is placed after all the others when mystery is called.

It's worth noting that the function mystery() is being called recursively here. I've included some comments to help explain the process at each step.

function rest(arr) {
  console.log('take first n-1 elements of', arr);
  return arr.slice(1);
}


function first(arr) {
  return arr[0];
}

function conj(arr, value) {
  arr.push(value);
  console.log('combine', arr, 'with', value)
  return arr;
}

function mystery(array) {
  console.log('call mystery on ', array)
  if (array.length === 0) {
    return [];
  }
  return conj(mystery(rest(array)), first(array));
}

mystery([0,1,2])

It's really quite straightforward. The primary reason why the content is not visible to you is due to RECURSION. Let me point out a couple of things I want you to observe:

• The function mystery(array) is recursive because it keeps calling itself until the array passed in becomes empty
• All the significant work is being done here: return conj(mystery(rest(array)), first(array));

Instead of delving deeper into recursive functions, I will demonstrate how you can monitor each recursive call using console.log(). Take a look at the code snippet below where I have included console.log() statements to help clarify things for you. Give mystery a go with a sample array and see the results. It should all start making sense to you.

function rest(arr) {
  return arr.slice(1);
}

function first(arr) {
  console.log("Returning ",arr[0], "from first(arr).")
  return arr[0];
}

function conj(arr, value) {
  console.log("Pushing ",value, " to ",arr, " in conj(arr,value)");
  arr.push(value);
  console.log("Returning ",arr, " from Conj(arr,value)");
  return arr;
}

function mystery(array) {
  if (array.length === 0) {
    console.log("The array is empty. Therefore, returning an empty array from mystery");
    return [];
  }
  console.log("The array is not empty. Hence, calling mystery(array) again.");
  return conj(mystery(rest(array)), first(array));
}
var reverse =mystery([1,2,3,4]);
console.log("The final result", reverse);

Admittedly, this method of reversing the array order is quite unconventional. It involves using recursion to continuously remove the first element of the array and append it to the end.

Let's break it down step by step:

mystery(['h','e','l','l','o']) ->

First, we check if the array is empty, if not, we call the rest method ->

rest(['h','e','l','l','o']) ->

rest slices the array starting from index 1, resulting in a new array: ['e','l','l','o'] ->

Then, we call mystery again with the new array returned from rest ->

mystery(['e','l','l','o']) ->

This process repeats until rest returns an empty array, like so:

mystery(['e','l','l','o']) ->
mystery(['l','l','o']) ->
mystery(['l','o']) ->
mystery(['o']) ->
mystery([]) ->

When mystery finally reaches an empty array, it returns the empty array. Then, we call first ->

mystery(['e','l','l','o']) , first(['h','e','l','l','o'])

[] , ['o'] ->
We then call conj with these values ->
conj([] , ['o']) ->
conj combines the two values ->
conj([] , ['o']) ->
['o'] ->
This result is then returned and the process repeats ->
conj([] , ['o']) ->
conj(['o'] , ['l']) ->
conj(['o','l'] , ['l']) ->
conj(['o', 'l','l'] , ['e']) ->

conj(['o', 'l','l', 'e'] , ['h'])