Seek and destroy solution confusion

I got to the algorithmic thinking challenges and found some of them tricky, but with patience worked my way to a solution. This one though, I really struggled. I eventually stumbled to github, followed the hints, and was still lost. Eventually (don’t judge) I peeked at all ur solution. And all I can say is I’m baffled. I really don’t understand it. I read through the filter page and found the extra parameters really confusing. This is the solution I found.

function destroyer(arr) {
var args =;
args.splice(0, 1);
return arr.filter(function(element) {
return args.indexOf(element) === -1;

Can anyone help me understand how it is working? What does it mean when it says element and how does this term get understood by the computer?

This is the same solution in ES6

const destroyer = (arr) => {
  let args = [...arguments].slice (1);
  return arr.filter (val => (args.indexOf (val) == -1));


We have a function destroyer with the first argument arr where are all the elements we have to “purify”.
First we call the others arguments where are the elements to remove from arr, but in arguments there is also the first argument ( arr ) and we already have it, then we delete it with slice(1) ( remove first element from an array, Array.prototype.slice ).
The last action we have to do is filter the array arr, ie remove the elements. I think you was confuse by this function. ( To understand better: Array.prototype.filter )

You can see it in this way:

var start_array = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

function filter_callback (element) {
 if ( element % 2 == 0 ) return true;
 return false;

console.log (start_array.filter (filter_callback));

For each element in start_array filter call the filter_callback function and this filter_callback returns “true” if the element is pair. When filter returns false the element is removed from the main array.

In my, and in your solution, this callback is defined directly as argument and what do this callback? It checks if the current element in arr is somewhere in args through the indexOf function, this last function returns -1 if the element passed as argument doesn’t exist in the array on which is called.
Have done that, you have your solution.


/* Build a function called "destroyer" */
function destroyer (arr) {
  /* Get the elements to remove in arr. 
  * Example: destroyer ([1, 2, 3], 2, 1);
  * var args = [ [1, 2, 3], 2, 1]
  var args = (arguments);
  /* Remove the first element from args because we already have it as "arr" */
  args.splice (0, 1);

  /* Return the filter result, every arr's element is passed as argument to
   * the callback function */
  return arr.filter (function (element) {

    /* For each element check if exist in args. If it doesn't exist ( === -1 )
     * return true, else false 
    return args.indexOf (element) === -1;

This is still absolutely confusing.