freecodecamp Herausforderungen - Suche und Zerstöre

Question

Ich versuche, diese Herausforderung zu lösen Suche und zu zerstören. Ich kann nicht herausfinden, was falsch ist. Irgendeine Hilfe ?

Suchen und zerstören Sie erhalten ein erstes Array (das erste Argument in der Zerstörerfunktion), gefolgt von einem oder mehreren Argumenten. Entfernen Sie alle Elemente aus dem ursprünglichen Array, die denselben Wert wie diese Argumente haben.

Dies ist der erste Code unten:

function destroyer(arr) { 
 
    // Remove all the values 
 
    return arr; 
 
} 
 

 
destroyer([1, 2, 3, 1, 2, 3], 2, 3);

Dies ist mein Code unten:

function destroyer(arr) { 
 
    var letsDestroyThis = []; 
 
    var i =1 ; while (i<arguments.length) { 
 
    letsDestroyThis.push(arguments[i]); 
 
    i++; 
 
    } 
 
    
 
    for(var j=0 ; j< arguments[0].length; j++) { 
 
    for (var k= 0; k< letsDestroyThis.length; k++) { 
 
     if(arguments[0][j] === letsDestroyThis[k]){ 
 
     arguments[0].splice(j, 1); 
 
     } 
 
    } 
 
    } 
 
    
 
    return arguments[0]; 
 
} 
 

 
destroyer([2, 3, 2, 3], 2, 3);

Vielen Dank im Voraus!

Answer 1

Sie können ein Array aller Werte erstellen, die entfernt werden sollen. Verwenden Sie dann Array.filter, um diese Werte herauszufiltern.

Hinweis: Array.splice wird ursprünglichen Array ändern.

function destroyer() { 
 
    var arr = arguments[0]; 
 
    var params = []; 
 

 
    // Create array of all elements to be removed 
 
    for (var k = 1; k < arguments.length; k++) 
 
    params.push(arguments[k]); 
 
    
 
    // return all not matching values 
 
    return arr.filter(function(item) { 
 
    return params.indexOf(item) < 0; 
 
    }); 
 
} 
 

 
console.log(destroyer([1, 2, 3, 1, 2, 3], 2, 3));

Answer 2

ist Meine Antwort auf vorherige ähnliche, aber ich habe indexOf nicht verwenden. Stattdessen überprüfte ich die Werte im Zyklus, aber der Compiler warnt mich davor, die Funktion im Zyklus zu deklarieren.

function destroyer(arr) { 
// Remove all the values 
var temp = []; 
for (var i = 1; i < arguments.length; i++) { 
    temp.push(arguments[i]); 
    arr = arguments[0].filter(function(value) { 
     return (value !== temp[i - 1]) ; 
    }); 
} 
return arr; 
} 
destroyer([1, 2, 3, 1, 2, 3], 2, 3); 

Answer 3

Das ist für mich gearbeitet:

function destroyer(arr) { 
// Remove all the values 

var args = Array.from(arguments); 
var filter = []; 

for (i = 0; i < args[0].length; i++){ 
for(j = 1; j < args.length; j++){ 
    if (args[0][i] === args[j]){ 
    delete args[0][i]; 
    } 
} 
} 

return args[0].filter(function(x){ 
return Boolean(x); 
}); 
} 

console.log(
destroyer([1, 2, 3, 1, 2, 3], 2, 3) 
); 

Answer 4

// zwei Möglichkeiten, die Sucht zu lösen und zerstören Herausforderung auf dem FreeCodeCamp // Ich habe versucht, den Code zu vereinfachen, bitte posten Sie Ihre Lösungen, vereinfacht der Code // so viel hat seinen möglichen

function destroyer1 (arr){ 
    //get array from arguments 
    var args = Array.prototype.slice.call(arguments); 
    args.splice(0,1); 
    for (var i = 0; i < arr.length; i++){ 
    for(var j = 0; j < args.length; j++){ 
     if(arr[i]===args[j]){ 
     delete arr[i]; 
     } 
    } 
} 
return arr.filter(function(value){ 
    return Boolean(value); 
}); 
} 

// ------------------------------- -------

function destroyer(arr) { 
    // Remove all the values 
    //Get values from arguments of the function to an array, index 0(arr[0] will be "arr", 
    //rest of indexes will be rest of arguments. 

    var args = Array.from(arguments); 
    for (var i = 0 ; i < args[0].length; i++){ 
    for (var j = 1; j < args.length; j++){ 
     if(args[0][i] === args[j]){ 
      delete args[0][i]; 
     } 
    } 
    } 
    return args[0].filter(function(value){ 
    return Boolean(value); 
    }); 
} 

console.log(destroyer([1, 2, 3, 1, 2, 3], 2, 3)); 
console.log(destroyer1([1,6,3,9,8,1,1], 3,1)); 

Answer 5

Das ist mein Code:

function destroyer(arr) { 
 
    var argsBeRemove = [...arguments]; 
 
    argsBeRemove.shift(); 
 
    return arr.filter(val => { 
 
    return argsBeRemove.indexOf(val) == -1; 
 
    }); 
 
} 
 

 
console.log(destroyer([1, 2, 3, 1, 2, 3], 2, 3));

Answer 6

Hier ist meine Version von Seek and Destroy. Ich nehme an, dass es keine Nullelemente in der Eingabe gibt (diese Annahme erlaubt es, die Herausforderung zu bestehen). Aber so kann ich gefundene Elemente gleich Null machen und sie dann einfach ausfiltern. Beim Löschen von Elementen in for-Schleifen ist es ziemlich einfach und kein Index-Chaos.

function destroyer(arr) { 
// Remove all the values 
var args = Array.prototype.slice.call(arguments); 

var temp=[]; 
    temp = arguments[0].slice(); 

    for (j=1; j<args.length; j++){ 

    for (i=0; i<arguments[0].length; i++){ 

    if(arguments[0][i]==arguments[j]){ 

    temp[i]=0;    
    } 
    } 
} 

function isZero(value) { 
return value !== 0; 
} 

var filtered = temp.filter(isZero); 

return filtered; 

}

Answer 7

function destroyer(arr) { 

    var args = Array.prototype.slice.call(arguments, 1); 
    return arr.filter(destroyNum); 

    function destroyNum(element) { 
     return !args.includes(element); 
    } 
} 

Answer 8

Versuchen Sie folgendes:

function destroyer(arr) { 
    /* Put all arguments in an array using spread operator and remove elements 
    starting from 1 */ 
    const args = [...arguments].splice(1); 
    /* Check whether arguments include elements from an array and return all that 
    do not include(false) */ 
    return arr.filter(el => !args.includes(el)); 
} 

destroyer([1, 2, 3, 1, 2, 3], 2, 3); // [1, 1]