Published in

CodeX

# Seek and Destroy — The JavaScript Algorithm

During our algorithm practice, some exercises are boring, others will be fun, and others you can’t help but blog about them. That’s the case with this fun algorithm I came across a few days ago. Seek and Destroy, the algorithm that made me hear James Hetfield sing out load Searching, Seek and destroy with his recognizable voice. Yes, I’m talking about Metallica and an algorithm that will search the values on an initial array that will be the same as the arguments followed after that array and destroy them.

For example, `seekAndDestroy([1, 2, 3, 5, 1, 2, 3], 2, 3)` should return `[1, 5, 1]`.

So let’s blast our headsets with Seek and Destroy and check out some solutions.

# Nested Loops

For the first solution, we’re creating an array using `Object.values(arguments).slice(1)` and storing it in the variable `valuesToRemove` to compare against arr. We start a basic for loop to iterate through `arr`. Then, nest another for loop inside the first, changing the integer variable `j` and `arr` to `valuesToRemove`. This second loop will iterate through `valuesToRemove`. Within the second loop create an if statement, checking strictly `===` that the current value of arr[i] is equal to `valuesToRemove[j]`. If the value at the current index is equal in both arrays, we’ll delete it from `arr`. Outside of the nested loops: return the modified array, filtering out any nulls created by the `delete` operator.

You might think this code is too complicated, and that’s correct. When we add nested iterations through the input will increase the complexity. According to the Big O Notation, this is an O(n2) function, and it represents a function whose complexity is directly proportional to the square of the input size. Thus, increasing the complexity. In other words, the response will be slower, it will take more memory, and that’s worst than St. Anger’s snare sound. Pretty bad.

# Array Iteration Methods

Our second solution would be the most common JavaScript solution, the Enter Sandman of this exercise. It is iterating the new array with the `.filter` and `.includes` methods. As we can see, this is a way cleaner code. Iteration methods such as `.filter` have a time complexity of O(n), which increases linearly in direct proportion to the number of inputs. At first, the iteration methods can look confusing. Once we understand how to use them, these methods, implementing them as needed, will be as natural as singing along to Enter Sandman in karaoke night.

# Rest Parameters

The third and final example is my favorite of it all. This one is Cliff Burton (RIP) playing bass solo epic level. In this solution, we’re using the rest parameters syntax. We allow a function to accept an indefinite number of arguments as an array using three dots `…` . Then, we return the filtered array with the `.includes` methods. This solution is some beautiful ES6 code.

So there we have it, a fun algorithm that we can name after a Metallica song. I hope you learned something new with this read and enjoyed it as much as I enjoyed writing it. So keep studying those algorithms and have fun finding something about your favorite music or pop culture to reference it.

Happy coding!

# Summary:

1. Introduction to the “Seek and Destroy” algorithm.
2. Nested Loops
3. Array Iteration Methods
4. Rest Parameters Syntax

# References:

1. Learning Big O Notation With O(n) Complexity by Newton, Dan.
2. Time complexity Big 0 for Javascript Array methods and examples by Castillo, Luis.
3. MDN Web Docs, Rest Parameters

--

--