Question

我正在努力解决以下问题，

给定一个数组和一个值，删除该值的所有实例放置并返回新的长度。

我为它写了下面的代码，但它总是返回一个空数组。

/**
 * @param {number[]} nums
 * @param {number} val
 * @return {number}
 */
var removeElement = function(nums, val) {
    for (var i=0; i< nums.length; i++)
    {
            if (nums[i] == val)
                nums.slice(i);
    }
    return nums;
};

Answer 1

使用数组SPLICE而不是切片

＆＃13;

var removeElement = function(nums, val) {
    for (var i=nums.length - 1; i >=0; i--) {
        if (nums[i] == val) {
            nums.splice(i,1);
        }
    }
    return nums.length;
};
var n = [1,2,3,2,1,2,3,2,1];
console.log(removeElement(n , 1));
console.log(n);

＆＃13;

另外，请注意函数返回nums.length - 因为您声明的要求是函数返回数组的新长度

Answer 2

正如其他人所指出的，使用slice根本不会取得任何成就。但是，正如许多答案所暗示的那样，使用splice既低效又不必要，并且会产生尴尬，例如需要向后遍历数组或调整循环索引。

相反，您可以简单地遍历数组，将要保留的元素复制到原始元素之上，使用变量j来跟踪我们保留的项目数量远。然后我们调整数组的长度（并返回它，因为那是规范）：

// Filter an array in place, removing elements equal to some value.
var removeElement = function(nums, val) {
    for (var i=0, j=0; i< nums.length; i++) {
      if (nums[i] !== val) nums[j++] = nums[i];
    }
    return nums.length = j;
};

但是，此代码仅用于过滤特定条件，即元素不等于某个特定值。写一个通用的＆＃34;就地过滤＆＃34;会更有用。功能：

// Filter an array in place, based on a condition.
function filterInPlace(arr, condition) {
  let j = 0;

  for (let i = 0; i < arr.length; i++) 
    if (condition(arr[i], i, arr)) arr[j++] = arr[i];

  return arr.length = j;
}

现在我们可以解决原来的问题如下：

// Remove a particular value from an array, in-place.
function removeElement(nums, val) {
  return filterInPlace(nums, function(value) { return value !== val; });
}

我们设计condition时采用与传递给(val, index, array)的函数相同的Array#filter签名，以防万一，即使这里没有使用最后两个参数

Answer 3

首先，slice()不会删除数组中的项目，因此请先将其更改为splice()。其次，删除元素时需要减少i，这样就不会跳过任何元素。

＆＃13;

var removeElement = function(nums, val) {
    for (var i=0; i< nums.length; i++)
    {
            if (nums[i] == val) {
                nums.splice(i,1);
                i--;
            }
    }
    return nums.length;
};

var nums = [5,2,3,6,1,2,4,2,5,6,1,3,6,2,4];
console.log(removeElement(nums,2));
console.log(nums);

＆＃13;

Answer 4

您可以使用 reduceRight 迭代数组并删除与要删除的值匹配的元素。您可以确定是否应使用==或===进行比较。

reduceRight 从右到左很方便，因此删除元素不会影响要检查的下一个元素的索引。

＆＃13;

/**
 * @param {number[]} nums - array of numbers to filter
 * @param {number} val    - value to remove from nums
 * @return {number} length of reduced array
 */
function removeElement(nums, val) {
  return nums.length? nums.reduceRight(function(acc, value, i) {
    if (value == val) nums.splice(i, 1);
    return nums
  }, null).length : 0;
};

var nums = [1,2,3,4,5,6,4];
var val  = 4;
console.log('Initial nums: ' + nums);
console.log('Value to remove: ' + val);
console.log('New length  : ' + removeElement(nums, val));
console.log('Final nums  : ' + nums);

＆＃13;

Answer 5

使用拼接方法，如：

nums.splice(i,1);

因此，代码将如下所示：

＆＃13;

var removeElement = function(nums, val) {
    for (var i=0; i <nums.length; i++) {
        if (nums[i] == val) {
            nums.splice(i,1);
            i--;
        }
    }
    return nums;
};
var arr = [5,3,7,8,5,5,2,5,55,4];
arr = removeElement(arr , 5);
console.log(arr);
console.log(arr.length);

＆＃13;

它只会删除特定元素而不是从第i个位置到结尾的序列

Answer 6

使用过滤器：

var words = ["spray", "spray", "spray", "spray", "destruction", "present"];

var removeElement = function(nums, val) {
 return words.filter(function(word){
      return word !== val;
    }).length;
}

Answer 7

在函数中，找到nums数组中与val匹配的第一个位置。如果未找到匹配项，则索引为-1，函数返回nums数组的长度。另一方面，如果匹配，则删除该项，并以递归方式再次调用该函数，直到不再有任何匹配为止。

/**
 * @param {number[]} nums
 * @param {number} val
 * @return {number}
 */
var removeElement = function(nums, val) {
  const position = nums.findIndex(number => number === val);

  if(position === -1) {
    return nums.length;
  } else {
    nums.splice(position, 1);
  }

  return removeElement(nums, val);
};

从阵列中删除所有出现的数字

7 个答案: