fcc算法中级

范围内的数字求和

给出一个含有两个数字的数组，我们需要写一个函数，让它返回这两个数字间所有数字（包含这两个数字）的总和。注意，较小数不一定总是出现在数组的第一个元素。

水体，比较两个临界值的大小，再循环相加即可

function sumAll(arr) {
   
  if(arr[0] > arr[1]){
   
    let temp = arr[0]
    arr[0] = arr[1]
    arr[1] = temp
  }
  let sum = 0;
  for(var i = arr[0]; i <= arr[1]; i++){
   
    sum += i
  }
  return sum;
}

sumAll([1, 4]);

但是这里比较大小也太low了吧！具有学习精神的程序员表示不能忍受

改用Math方法比较大小

  var max = Math.max(arr[0], arr[1]);
  var min = Math.min(arr[0], arr[1]);

还有因为传入的参数是数组，使用js扩展运算符

for (var i = Math.min(...arr); i <= Math.max(...arr); i++) {
   
    sum += i;
  }

区分两个数组

在这道题目中，我们需要写一个函数，比较两个数组，返回一个新的数组。这个新数组需要包含传入的两个数组所有元素中，仅在其中一个数组里出现的元素。如果某个元素同时出现在两个数组中，则不应包含在返回的数组里。换言之，我们需要返回这两个数组的对称差。

注意：
返回数组中的元素顺序不会影响测试结果

让两数组去重，可以使用循环和indexOf()的方法

简单粗暴的方法：

function diffArray(arr1, arr2) {
   
  var newArr = [];
  // 这是一个党异伐同的过程
  for(var i = 0; i< arr1.length; i++)
  {
   
    if(arr2.indexOf(arr1[i]) === -1)
    {
   
      newArr.push(arr1[i])
    }
  }
  for(var i = 0; i< arr2.length; i++)
  {
   
    if(arr1.indexOf(arr2[i]) === -1)
    {
   
      newArr.push(arr2[i])
    }
  }
  return newArr;
}

diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]);

是用filter()循环并筛选，indexOf()方法比较是否存在

function diffArray(arr1, arr2) {
   
  return arr1.concat(arr2)
  .filter((e)=>{
   
    // 去除既在第一个数组中存在又在第二个数组中存在的值
    return !(arr1.indexOf(e) !== -1 && arr2.indexOf(e) !== -1)
  })
}

diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]);

瞄准和消灭

在这道题目中，我们要写一个叫destroyer的函数。传给它的第一个参数是数组，我们称他为初始数组。后续的参数数量是不确定的，可能有一个或多个。你需要做的是，从初始数组中移除所有与后续参数相等的元素，并返回移除元素后的数组。

注意：
你可以使用arguments对象，也可以使用...，即“剩余参数”（Rest Parameters）语法。

查阅MDN arguments对象的用法，MDN arguments

使用arguments对象，构造一个除第一个数组外的值的数组，再使用filter()排除和该数组相同的值

function destroyer(arr) {
   
  // 删掉那些值
  var args = Array.from(arguments).slice(1);
  return arr.filter(function(val) {
   
    return !args.includes(val);
  });
}

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

使用剩余参数的方法，第一个数组后面的参数构造成一个数组

const destroyer = (arr, ...val) => {
   
  return arr.filter(e=>{
   
    return !val.includes(e)
  })
}

// 函数只有一条语句，可以省略return,优美！
const destroyer = (arr, ...val) => arr.filter(e => !val.includes(e))