Question

var o = [1,2,3,5,6,7,8]

var res = o.reduce(function(x,y){

   return !((y-x)===1)?y-1:'Nothing'

})
console.log(res)//7

输出应为4，想知道是否可以使用reduce或功能（不通过循环）？它仅在缺失值在数组的最后一个值之前时才有效。

Answer 1

您可以使用reduce计算所有元素的实际总和，然后从目标总和（n(a0+an)/2）中减去它。这为您提供了缺失的数字。

var o = [1,2,3,5,6,7,8];

var len = o.length;
var sum = (len + 1) * (o[0] + o[len - 1]) / 2;
var res = sum  - o.reduce((x,y) => x + y);

console.log(res);

请注意，这适用于任何起始值和任何步骤，例如对于[3,5,7,11]，它会正确打印9。唯一的要求是o应该是算术级数。

Answer 2

您可以使用起始值并检查前一个元素和实际元素。

＆＃13;

var o = [1, 2, 3, 5, 6, 7, 8],
    res = o.reduce(function(r, a, i, aa) {
        return !i || r !== undefined || aa[i - 1] + 1 === a ? r : aa[i - 1] + 1;
    }, undefined);

console.log(res);

＆＃13;

Answer 3

而不是reduce您可以使用find，一旦找到缺失值，它就不再显示了：{/ p>

const o = [1,2,3,5,6,7,8];
const res = o.find( (x,i) => o[i+1]-x > 1 ) + 1;
console.log(res)//4

Answer 4

你可以使用每一个，下面将适用于你指定的任何序列间隔 - 如果所有元素都是顺序的，它将返回-1，或者不适合的元素：

var o = [1, 4, 7, 10, 11]
var seqInterval = 3;

function getMissing(arr, interval) {
  var hit = -1;
  var res = arr.every(function(e, i) {
    hit = i === 0 ? hit : ((e - interval) === arr[i - 1] ? -1 : e);
    return hit === -1;
  });
  return hit;
}

console.log(getMissing(o, seqInterval));

var o1 = [1,2,3,5,6,7,8];
var seqInterval1 = 1;
console.log(getMissing(o1, seqInterval1));

Answer 5

这是一个使用Array.reduce和ES6箭头功能的简单解决方案。

＆＃13;

const o = [1, 2, 3, 5, 6, 7, 8];
const result = o.reduce((x, y) => y > x ? x : y + 1, 1)
console.log(result);

＆＃13;

通过一些重构，我们可以开始使解决方案更通用。

＆＃13;

const sequence = [1, 2, 3, 5, 6, 7, 8];
const result = sequence.reduce(missingLinkReducer, sequence[0])

function missingLinkReducer(expected, actual) {
  return expected === actual ?  nextValue(expected) : expected;
}

function nextValue(value) {
  return value + 1;
}

console.log(result);

＆＃13;

进一步说，我们可以做到这一点，以便可以插入不同的函数来计算下一个值。

＆＃13;

    const sequence = [1, 2, 3, 5, 6, 7, 8];
    const result = sequence.reduce(createMissingLinkReducer(increment), sequence[0]);
    console.log(result + ' is missing from ' + sequence);


    const sequenceB = [1, 2, 4, 8, 16, 64, 128];
    const resultB = sequenceB.reduce(createMissingLinkReducer(double), sequenceB[0]);
    console.log(resultB + ' is missing from ' + sequenceB);


    function createMissingLinkReducer(nextValue) {
      return function missingLinkReducer(expected, actual) {
        return expected === actual ?  nextValue(expected) : expected;
      }
    }

    function increment(value) {
      return value + 1;
    }

    function double(value) {
      return value * 2;
    }

＆＃13;

Answer 6

总结这些工作总是好的。因此，您应该为算法提供一系列描述符函数，以查找系列中缺少的项目。我们来做吧;

function findMissingItem(a,s){
  return s(a[a.findIndex((f,i,a) => i ? f !== s(a[i-1]) : false)-1]);
}
var data1 = [1,2,3,5,6,7,8],
    data2 = [1,4,9,16,36,49,64,81],
  series1 = n => n+1,
  series2 = n => Math.pow(Math.sqrt(n)+1,2);
     res1 = findMissingItem(data1,series1),
     res2 = findMissingItem(data2,series2);
console.log(res1);
console.log(res2);

使用.reduce在序列中查找缺失的数字

6 个答案: