使用.reduce查找序列中的缺失編號

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

您可以使用起始值並檢查前一個元素和實際元素。

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

Answer 2

您可以使用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 3

相反的reduce你可以使用find，不會看任何進一步一旦發現缺少值：

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箭頭功能的簡單解決方案。

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

---

隨着一點點的重構，我們就可以開始讓解決方案更加通用。

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

---

去一個遠一點，我們可以讓這個不同的功能可以計算下一個值被插入。

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

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