Javascript 查找数字序列中第一个缺失的数字

我想知道如何找到像这样的数字序列（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;
    }
}

var mynumbers=新数组（1,2,3,6,9,10）；
对于（变量i=1；i<32；i++）{
如果（mynumbers[i]-mynumbers[i-1]！=1）{
警报（“第一个缺失编号id:+MyNumber[i]）；
打破
}
}

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

希望提前得到帮助和感谢；-）

for（变量i=1；i

---

如果需要，可以添加初始检查：

If（mynumbers[0]！=1）{…}

无论发生什么情况，您都需要中断。这就是它的目的；阻止循环继续到底。您应该使用数组的长度，而不是硬编码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;
    }
}

var mynumbers=新数组（1,2,3,6,9,10）；
对于（变量i=1；i

编辑：这仅适用于不为1的缺失数字。为了抓住这一点，您需要通过检查

if（mynumbers[0]！=1）

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

var缺失=（函数（arr）{
var i；
对于（i=0；i

编辑：

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

这个怎么样

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

var mynumbers=新数组（1,2,3,6,9,10）；
var缺失；
对于（var i=1；i来说，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

此解决方案适用于正数数组。
使用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)

有时，如果您知道它是一个小数组，您只需要简单：

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

简短而甜蜜！
我认为这是两步解决方案的最简单和最佳形式

我认为对于这个问题没有比这个更好的解决办法了

这段代码使用了最少数量的变量、循环、条件、内置函数和所有糟糕的、草率的、不必要的代码

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

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

  }

}

var mynumbers=新数组（76,77,78,79,80,81,82,83,84125）；
如果（mynumbers.length>1）{
对于（var i=0；i
//查找序列中缺少的数字
//在以下系列中给出的3个表中，输出必须为12
设abc=[3,6,9,15,18,21,24]；
变量def=[]，
ghi=[]；
对于（变量i=1；定义长度）finalArr=ghi；
else finalArr=def；
var finaldiff=finalArr[0]；
var finalVal=abc.find（（e，i）=>{
如果（e！==abc.长度）{
var diff=abc[i]-abc[i-1]；
返回差>最终差；
}
})
控制台日志（finalVal-diff）；
对于您希望实现的目标，您可以将想法合并到中，但如果我删除#1，它仍然会给我4作为第一个缺失的数字？它不应该是1吗？如果序列必须开始
1
，请替换所有硬编码的
arr[0]
对于
1
，我假设你是从一个任意的数字开始的，因为你的测试是任意的。我喜欢这样，尽管问题与上面的解决方案相同。如果我删除数字1…第一个缺失的数字不应该是1吗？实际上…这是最简单的。干得好，谢谢；-）如果有人给了你这个问题。他/她肯定不是在寻找这个解决方案。他可能是在寻找一个更优化的解决方案。我不明白你为什么不必要地将简单的解决方案复杂化。你可以看看我的答案。虽然它很简单，但效率很高。
let numbers = [1,2,3,6,9,10]
let m = 0

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

console.log(m) // 4

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

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

  }

}

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