Question

我试图找出如何找到这样的数字序列的第一个缺失数字（1,2,3,5,6,9,10,15）

我想将第一个缺失的数字＃4放入一个变量供以后使用，但不知道怎么做？

我试过这个，但这只给了我最后一个数字：

var mynumbers=new Array(1,2,3,6,9,10);
for(var i = 1; i < 32; i++) {
    if(mynumbers[i] - mynumbers[i-1] != 1) {
        alert("First missing number id: "+mynumbers[i]);
        break;
    }
}

首先，它给出了numberequence中“hole”之后的第一个数字，其次，如果我没有插入一个中断，它会继续警告所有在“洞”之后出现的数字。我只想要从1到32的第一个缺失数字序列。我该怎么做？

希望得到帮助并提前感谢; - ）

Answer 1

O（n）解决方案很容易，但这是一个常见的面试问题，通常我们会寻找O（log n）时间解决方案。这是javascript代码。它基本上是一个修改过的二进制搜索。

function misingNumInSeq(source, min = 0, max = source.length - 1){
    if(min >= max){
        return min + 1;
    }
    let pivot = Math.floor((min + max)/2);
    // problem is in right side. Only look at right sub array
    if(source[pivot] === pivot + 1){
        return misingNumInSeq(source, pivot + 1, max);
    } else {
        return misingNumInSeq(source, min , pivot);
    }
}

输出

misingNumInSeq([1,2,3,5,6,9,10,15])
4

Answer 2

这个怎么样

var mynumbers = new Array(1,2,3,6,9,10);
var missing;

for(var i=1;i<=32;i++)
{    
   if(mynumbers[i-1] != i){
        missing = i;
        alert(missing);
        break;
   }
}

Answer 3

按if(mynumbers[i] - mynumbers[i-1] != 1)，您的意思是说系列将始终按1递增？

var missing = (function (arr) {
    var i;
    for (i = 0; i < arr.length; ++i) {
        if (i + arr[0] !== arr[i]) return i + arr[0];
    }
    if (i < 32)            // if none missing inside array and not yet 32nd
        return i + arr[0]; // return next
}([1,2,3,6,9,10])); // 4
alert(missing);

Answer 4

无论如何，你都需要休息。这就是它的用途;阻止循环继续到结束。你应该使用数组的长度而不是硬编码32作为结束条件，因为你的数字最多只能达到32，但是列表中可能有空洞，因此数组中不会有32个元素。

由于您知道每个元素应该比前一个元素多1个，因此洞中的数字显然是mynumbers[i - 1] + 1。

var mynumbers = new Array(1,2,3,6,9,10);
for(var i = 1; i < mynumbers.length; i++) {
    if(mynumbers[i] - mynumbers[i-1] != 1) {
        alert("First missing number id: " + (mynumbers[i - 1] + 1));
        break;
    }
}

编辑：这只适用于丢失的数字不是1.要抓住它，您需要检查if (mynumbers[0] != 1)

Answer 5

编辑：

function findFirstMissing(array) {
    for (var i = 0; i < array.length; i++) {
        if (i+1 !== array[i]) {
            return i+1;
        }
    }
}

function findFirstMissing(array) {
    for (var i = 0; i < array.length; i++) {
        if (array[i+1] - array[i] !== 1) {
            return array[i] + 1;
        }
    }
}

如果你这样做，那么将它存储在变量中很容易：

var missing = findFirstMissing(array);

Answer 6

const firstNonConsecutive = arr => arr.find((el, i, arr) => (arr[i] - arr[i-1]) !== 1 && i !== 0)

此解决方案适用于一组正数。

Answer 7

使用array.reduce查找第一个正缺失整数的解决方案。

function solution(A) {
  return [...A].sort().reduce((acc, curr, i, arr) => {
    if (acc > curr) {
      arr.splice(1);
      return acc;
    }
    else if (arr[i + 1] - curr > 1 || arr.length === i + 1) {
      arr.splice(1);
      return curr + 1;
    }
    return acc;
  }, 1);
}

以下是一些测试用例：

console.log('solution([1, 3, 6, 4, 1, 2])',  solution([1, 3, 6, 4, 1, 2]) === 5)
console.log('solution([1, 3, 2, 8, 4])', solution([1, 3, 2, 8, 4]) === 5)
console.log('solution([1])', solution([1]) === 2)
console.log('solution([-1])', solution([-1]) === 1)
console.log('solution([0])', solution([0]) === 1)
console.log('solution([-1, -4, -5, -6, -190343])', solution([-1, -4, -5, -6, -190343]) === 1)

Answer 8

有时候，如果您知道它是一个小数组，则只想简单一点即可。

let numbers = [1,2,3,6,9,10]
let m = 0

for (const i of numbers) if (i > ++m) break

console.log(m) // 4

如果您从数组开头删除1，则有效：

numbers = [2,3,6,9,10]
m = 0

for (const i of numbers) if (i > ++m) break

console.log(m) // 1

如果数组可以是连续的，并且如果要连续第二个数字，则：

numbers = [1,2,3,4,5,6,7,8,9]
m = 0

for (const i of numbers) if (i > ++m) break
if (m == Math.max(...numbers)) m++

console.log(m) // 10

又甜又甜！

Answer 9

我认为这是仅两步解决方案的最简单和最佳形式。

我认为，没有比这个问题更好的解决方案了。

此代码使用最小编号。变量，循环，条件，内置函数以及所有糟糕，草率，不必要的代码组成。

此代码可以处理任何长度的数组。

var mynumbers = new Array(76,77,78,79,80,81,82,83,84,125);

if(mynumbers.length > 1) {

  for(var i=0; i<=mynumbers.length-1; i++) {

    if(mynumbers[i+1] - 1 !== mynumbers[i]) { 

      alert("First Missing Term is : "+parseInt(mynumbers[i]+1));
      break;
    }

  }

}

Answer 10

//Find the missing number in a series
//output must be 12 in a table of 3 given in below series
let abc = [3, 6, 9, 15, 18, 21, 24];
var def = [],
  ghi = [];
for (var i = 1; i <= abc.length; i++) {
  if (i !== abc.length) {
    var diff = abc[i] - abc[i - 1];
    if (def.includes(diff) === false) {
      def.push(diff);
    } else {
      ghi.push(diff);
    }
  }
}

var finalArr = [];
if (ghi.length > def.length) finalArr = ghi;
else finalArr = def;
var finaldiff = finalArr[0];
var finalVal = abc.find((e, i) => {
  if (e !== abc.length) {
    var diff = abc[i] - abc[i - 1];
    return diff > finaldiff;
  }
})

console.log(finalVal - diff);

Answer 11

for(var i = 1; i < mynumbers.length; i++) {
    if(mynumbers[i] - mynumbers[i-1] != 1) {
        alert("First missing number id: "+mynumbers[i-1]+1);
        i = mynumbers.length; // Replace the break
    }
}

如果您愿意，可以添加初步检查：if (mynumbers[0] != 1) { ... }

在一系列数字中找到第一个缺失的数字

11 个答案: