freecodecamp 挑戰 - 尋找和毀滅

Question

我正在努力解決這個挑戰 Seek and Destroy。 我不知道出了什么問題。 有什么幫助嗎？

Seek and Destroy 您將獲得一個初始數組（destroyer 函數中的第一個參數），然后是一個或多個參數。 從初始數組中刪除與這些參數具有相同值的所有元素。

這是下面的初始代碼：

 function destroyer(arr) { // Remove all the values return arr; } destroyer([1, 2, 3, 1, 2, 3], 2, 3);

這是我的代碼如下：

 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);

提前致謝！

Answer 1

您可以創建一個包含所有應該刪除的值的數組。 然后使用Array.filter過濾掉這些值。

注意： Array.splice會改變原來的數組。

 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

 function destroyer(arr) { /* Put all arguments in an array using spread operator and remove elements starting from 1 using slice intead of splice so as not to mutate the initial array */ const args = [...arguments].slice(1); /* Check whether arguments include elements from an array and return all that do not include(false) */ return arr.filter(el => !args.includes(el)); } console.log(destroyer([1, 2, 3, 1, 2, 3], 2, 3));

Answer 3

這對我有用：

 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

//解決 FreeCodeCamp 上的 Seek 和 Destroy 挑戰的兩種方法 //我試圖簡化此代碼，請發布您的解決方案，簡化代碼 //盡可能多

 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

這是我的代碼：

 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

這是我的“尋找與毀滅”版本。 我假設輸入中沒有零元素（該假設允許通過挑戰）。 但這樣我可以使找到的元素等於零，然后將它們過濾掉。 在 for 循環中刪除元素時，它非常簡單，並且沒有索引混亂。

 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; } console.log(destroyer([1, 2, 3, 1, 2, 3], 2, 3));

Answer 7

 function destroyer(arr) { var args = Array.prototype.slice.call(arguments, 1); return arr.filter(destroyNum); function destroyNum(element) { return !args.includes(element); } } console.log(destroyer([1, 2, 3, 1, 2, 3], 2, 3));

Answer 8

試一試，它不那么復雜：

 function destroyer(arr) { // arr1 is equal to the array inside arr var arr1 = arr.slice(arguments); // arr2 becomes an array with the arguments 2 & 3 var arr2 = Array.prototype.slice.call(arguments, 1); // this function compares the two and returns an array with elements not equal to the arguments return arr1.concat(arr2).filter(function(item) { return !arr1.includes(item) || !arr2.includes(item) }) } destroyer([1, 2, 3, 1, 2, 3], 2, 3);

Answer 9

您將獲得一個初始數組（destroyer 函數中的第一個參數），然后是一個或多個參數。 從初始數組中刪除與這些參數具有相同值的所有元素。

接受的解決方案返回一個新數組，而不是從現有數組中刪除元素。

這可以通過反向迭代數組並刪除與任何過濾器參數匹配的任何元素來有效地實現。

 function destroy(original, ...matches) { if('length' in original) { let index = original.length while(--index > -1) { if(matches.includes(original[index])) { original.splice(index, 1) } } } return original; } const original = [1, 2, 3, 1, 2, 3] destroy(original, 2, 3) console.log(original);

Answer 10

我的回答與上一個類似，但我沒有使用indexOf 。 相反，我檢查了循環中的值，但編譯器警告我不要在循環中聲明函數。

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 11

我們可以得到數組后面的參數，即需要刪除的數字並將它們存儲到列表中。 然后，我們可以只使用過濾器來過濾掉需要刪除的數字。

function destroyer(arr) {
 let removeList=[...arguments].slice(1);
 return arr.filter(e=>removeList.indexOf(e)===-1);
}

Answer 12

我知道這不是最短的方法，但我認為在中級水平上更容易理解。

 function destroyer(arr, ...elements) { var i =0; while(i<=arr.length){ //for each element into array for(let j =0; j<elements.length; j++){ //foreach "elements" if(arr[i]==elements[j]){ // Compare element arr==element arr.splice(i,1); //If are equal delete from arr i--; //Check again the same position j=0; break; //Stop for loop } } i++; } return arr; } console.log(destroyer(["possum", "trollo", 12, "safari", "hotdog", 92, 65, "grandma", "bugati", "trojan", "yacht"], "yacht", "possum", "trollo", "safari", "hotdog", "grandma", "bugati", "trojan")); console.log(destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3));

Answer 13

function destroyer(arr) {
let newArray = Array.from(arguments).splice(1)
  return arr.filter(item => !(newArray.includes(item)))
}