Let's use the classic anagram problem.

Anagram is a word/phrase created by rearranging the letter of another word/phrase. E.g., cat becomes act.

Instinctively, many devs write something like the following:

function isAnagram(str1, str2) {
  if (str1.length !== str2.length) return false;

  for (let i = 0; i < str1.length; i++) {
    let found = false;

  for (let j = 0; j < str2.length; j++) {
      if (str1[i] === str2[j]) {
        found = true;
        break;
      }
    }

    if (!found) return false;
  }

  return true;
}

We have big problems here:

• Nested loops: quadratic complexity - O(n²).

• The char frequency is not verified, making the solution inaccurate.

Instead, we can use the frequency pattern to know the occurrences for each char by just using Objects.

Here's the solution:

function isAnagram(str1, str2) {
    if (str1.length !== str2.length) {
        return false;
    }

    let frequencyObject1 = {};
    let frequencyObject2 = {};

    for (let i = 0; i < str1.length; i++) {
        frequencyObject1[str1[i]] = (frequencyObject1[str1[i]] || 0) + 1;
    }

    for (let i = 0; i < str2.length; i++) {
        frequencyObject2[str2[i]] = (frequencyObject2[str2[i]] || 0) + 1;
    }

    for (const key in frequencyObject1) {
        if (!(key in frequencyObject2)) return false;
        if (frequencyObject1[key] !== frequencyObject2[key]) return false;
    }

    return true;
}

Now, we have a better solution with a linear complexity - O(n).

The main idea here is to create multiple pointers attached to specific positions and move them based on a particular condition.

You can find Multiple Pointers In countless algorithms, like:

• Binary Search

• Quick Sort

• Merge Sort

• Etc.

Let's imagine we need to write a function that finds the first pair where the sum is 0 from a given SORTED array. E.g., [-5, -1, 0, 2, 5] //-5 + 5

Instinctively, we write something like the following:

function pairSum(arr) {
    for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr.length; j++) {
            if (arr[i] + arr[j] === 0) return `${arr[i]} + ${arr[j]}`;
        }
    }
}

The big problem here is that our time complexity is quadratic O(n^2) because we walk through the array twice. But, we can solve it by using Multiple Pointers to walk through the array only once:

function pairSum(arr) {
  let left = 0;
  let right = arr.length - 1;

  while (left < right) {
    const sum = arr[left] + arr[right];
    if (sum === 0) {
      return `${arr[left]} + ${arr[right]}`;
    } else if (sum < 0)   
 {
      left++;
    } else {
      right--;
    }
  }

  return null;
}

Now, we have a linear time complexity O(n).

Let's get deeper into the above solution:

• We set up two pointers: left with the initial position and right with the last position.

• The loop will be running until left < right.

• We store the first sum.

• If sum === 0, we found our pair.

• If not and sum < 0, we will move our left pointer to the right by incrementing it.

• If sum > 0, move the right pointer to the left by decrementing it.

• If nothing was found, return null.

Let's suppose we have the following SORTED array:

[-6, -5, -1, 0, 2, 3, 4, 5, 10]

1.
[-6, -5, -1, 0, 2, 3, 4, 5, 10]
  ^                          ^
 left                      right

 sum = -6 + 10 = 4

 As 4 > 0, we move our right pointer to the left

 [-6, -5, -1, 0, 2, 3, 4, 5, 10]
   ^                      ^
 left                   right

 sum = -6 + 5 = -1

 -1 < 0, we move the left pointer to the right

 [-6, -5, -1, 0, 2, 3, 4, 5, 10]
       ^                  ^
      left              right

sum = -5 + 5 = 0

Pair found: -5, 5.

Here's a factorial algorithm as an example:

function factorial(num) {
// End of the recursion
if (num === 1) return num;
// Calls itself decreasing the input by 1
return num * factorial(num - 1);
}

\You can generate a stack overflow here by just using any number smaller than 1*

The processes are stored in a structure called a call stack, which pushes the processes—calls—into the stack and pops them when they are finished.

All recursion algorithms should have the following:

• Return something to get out of the stack

• A condition that ends the recursion (base case)

• A code that changes the input (e.g., incrementing the input)

Benefits:

• Readability of the code

• Elegant solution

• Breakdown the problem into smaller pieces (divide-and-conquer problem approach)

Drawbacks:

• Performance problems with deeply nested calls

• Stack overflow (no base case, no return or returning wrong thing)

• In some cases, more inefficient than iterate solutions (loops)

Where we find recursion in JS:

• JSON.parse() / JSON.stringfy()

• DOM traversal algorithms

• Object traversal algorithms

More deeply into call stack:

• The maximum size depends on the system and browsers (Chrome around 10-20k calls, Node.js around 100k calls)

• In node, you can set the maximum call stack size by calling node --stack-size=Xmb

• To calculate the approximate space consumed by a function call: stack_size = sizeof(arguments) + sizeof(local_variables) + sizeof(return_value) + sizeof(context)

Because of that, a lot of developers are facing the error message:

ProductNotSupportedError: The client noticed that the server is not a supported distribution of Elasticsearch

If you use the official Node.js client for Elasticsearch, elasticsearch-js, I recommend you downgrade the module version to version 7.12.0.

Example in a package.json file:

"@elastic/elasticsearch": "~7.12.0"

Best, Luiz Celso