Массивы - Найти пропущенные числа в последовательности

Question

Я пытаюсь найти простой способ циклически повторять массив, чтобы найти все пропущенные числа в последовательности, массив будет выглядеть примерно так, как показано ниже.

var numArray = [0189459, 0189460, 0189461, 0189463, 0189465];

Для указанного выше массива мне потребуется 0189462 и 0189464 вышли из системы.

ОБНОВЛЕНИЕ : это точное решение, которое я использовал из ответа Суфианы.

var numArray = [0189459, 0189460, 0189461, 0189463, 0189465];
var mia= [];

    for(var i = 1; i < numArray.length; i++) 
    {     
        if(numArray[i] - numArray[i-1] != 1) 
        {         
            var x = numArray[i] - numArray[i-1];
            var j = 1;
            while (j<x)
            {
                mia.push(numArray[i-1]+j);
                j++;
            }
        }
    }
alert(mia) // returns [0189462, 0189464]

UPDATE

Вот более аккуратная версия с использованием .reduce

var numArray = [0189459, 0189460, 0189461, 0189463, 0189466];
var mia = numArray.reduce(function(acc, cur, ind, arr) {
  var diff = cur - arr[ind-1];
  if (diff > 1) {
    var i = 1;
    while (i < diff) {
      acc.push(arr[ind-1]+i);
      i++;
    }
  }
  return acc;
}, []);
console.log(mia);

Answer 1

Если вы знаете, что числа сортируются и увеличиваются:

for(var i = 1; i < numArray.length; i++) {
    if(numArray[i] - numArray[i-1] != 1) {
           //Not consecutive sequence, here you can break or do whatever you want
    }
}

Answer 2

Следите за своими ведущими нулями, они будут сброшены при интерпретации массива-

var A = [0189459, 0189460, 0189461, 0189463, 0189465]

(A возвращает [189459,189460, 188461, 188463, 188465])

function absent(arr){
    var mia= [], min= Math.min.apply('',arr), max= Math.max.apply('',arr);
    while(min<max){
        if(arr.indexOf(++min)== -1) mia.push(min);
    }
    return mia;
}

var A = [0189459, 0189460, 0189461, 0189463, 0189465];alert (отсутствует (A))

/ * возвращаемое значение: (Array) 189462,189464 * /

Answer 3

Чтобы найти пропущенное число в последовательности, прежде всего, нам нужно отсортировать массив. Затем мы можем определить, какой номер отсутствует. Я предоставляю здесь полный код с некоторыми тестовыми сценариями. этот код будет идентифицировать только пропущенное положительное число, если вы передадите отрицательные значения даже тогда, оно даст положительное число.

function findMissingNumber(inputAr) {
  // Sort array
  sortArray(inputAr);

  // finding missing number here
  var result = 0;
  if (inputAr[0] > 1 || inputAr[inputAr.length - 1] < 1) {
    result = 1;
  } else {
    for (var i = 0; i < inputAr.length; i++) {
      if ((inputAr[i + 1] - inputAr[i]) > 1) {
        result = inputAr[i] + 1;
      }
    }
  }
  if (!result) {
    result = inputAr[inputAr.length - 1] + 1;
  }
  return result;
}

function sortArray(inputAr) {
  var temp;
  for (var i = 0; i < inputAr.length; i++) {
    for (var j = i + 1; j < inputAr.length; j++) {
      if (inputAr[j] < inputAr[i]) {
        temp = inputAr[j];
        inputAr[j] = inputAr[i];
        inputAr[i] = temp;
      }
    }
  }
}

console.log(findMissingNumber([1, 3, 6, 4, 1, 2]));
console.log(findMissingNumber([1, 2, 3]));
console.log(findMissingNumber([85]));
console.log(findMissingNumber([86, 85]));
console.log(findMissingNumber([0, 1000]));

Answer 4

const findMissing = (arr) => {
const min = Math.min(...arr);
const max = Math.max(...arr);
// add missing numbers in the array
let newArr = Array.from(Array(max-min), (v, i) => {
    return i + min
});
// compare the full array with the old missing array
let filter = newArr.filter(i => {
    return !arr.includes(i)
})
return filter;
};

Answer 5

ES6-Style

var arr = [0189459, 0189460, 0189461, 0189463, 0189465]; 
var [min,max] = [Math.min(...arr), Math.max(...arr)];
var out = Array.from(Array(max-min),(v,i)=>i+min).filter(i=>!arr.includes(i));

Результат: [189462, 189464]

Answer 6

let missing = [];
let numArray = [3,5,1,8,9,36];
const sortedNumArray = numArray.sort((a, b) => a - b);
sortedNumArray.reduce((acc, current) => {
  let next = acc + 1;
  if (next !== current) {
    for(next; next < current; next++) {
      missing.push(next);
    }
  }
  return current;
});

Answer 7

Пожалуйста, проверьте ниже код .....

function solution(A) {
   var max = Math.max.apply(Math, A);
   if(A.indexOf(1)<0) return 1;
   var t = (max*(max+1)/2) - A.reduce(function(a,b){return a+b});
   return t>0?t:max+1;
}

Answer 8

function missingNum(nums){
    const numberArray = nums.sort((num1, num2)=>{
      return num1 - num2;
   });
   for (let i=0; i < numberArray.length; i++){
      if(i !== numberArray[i]){
        return i;
      }
   }
 }
 console.log(missingNum([0,3,5,8,4,6,1,9,7]))

Answer 9

Вот вариант функции @Mark Walters , которая добавляет возможность указать нижнюю границу для вашей последовательности, например, если вы знаете, что ваша последовательность всегда должна начинаться с 0189455, или с какого-то другого числа.как 1.

Также можно настроить этот код для проверки верхней границы, но в данный момент он может искать только нижние границы.

//Our first example array.
var numArray = [0189459, 0189460, 0189461, 0189463, 0189465];
//For this array the lowerBoundary will be 0189455
var numArrayLowerBoundary = 0189455;

//Our second example array.
var simpleArray = [3, 5, 6, 7, 8, 10, 11, 13];
//For this Array the lower boundary will be 1
var simpleArrayLowerBoundary = 1;

//Build a html string so we can show our results nicely in a div
var html = "numArray = [0189459, 0189460, 0189461, 0189463, 0189465]<br>"
html += "Its  lowerBoundary is \"0189455\"<br>"
html += "The following numbers are missing from the numArray:<br>"
html += findMissingNumbers(numArray, numArrayLowerBoundary);
html += "<br><br>"
html += "simpleArray = [3, 5, 6, 7, 8, 10, 11, 13]<br>"
html += "Its  lowerBoundary is \"1\".<br>"
html += "The following numbers are missing from the simpleArray:<br>"
html += findMissingNumbers(simpleArray, simpleArrayLowerBoundary);

//Display the results in a div
document.getElementById("log").innerHTML=html;

//This is the function used to find missing numbers!
//Copy/paste this if you just want the function and don't need the demo code.
function findMissingNumbers(arrSequence, lowerBoundary) {
  var mia = [];
  for (var i = 0; i < arrSequence.length; i++) {
    if (i === 0) {
      //If the first thing in the array isn't exactly
      //equal to the lowerBoundary...
      if (arrSequence[i] !== lowerBoundary) {
        //Count up from lowerBoundary, incrementing 1
        //each time, until we reach the
        //value one less than the first thing in the array.
        var x = arrSequence[i];
        var j = lowerBoundary;
        while (j < x) {
          mia.push(j); //Add each "missing" number to the array
          j++;
        }
      } //end if
    } else {
      //If the difference between two array indexes is not
      //exactly 1 there are one or more numbers missing from this sequence.
      if (arrSequence[i] - arrSequence[i - 1] !== 1) {
        //List the missing numbers by adding 1 to the value
        //of the previous array index x times.
        //x is the size of the "gap" i.e. the number of missing numbers
        //in this sequence.      
        var x = arrSequence[i] - arrSequence[i - 1];
        var j = 1;
        while (j < x) {
          mia.push(arrSequence[i - 1] + j); //Add each "missing" num to the array
          j++;
        }
      } //end if
    } //end else
  } //end for
  //Returns any missing numbers, assuming that lowerBoundary is the
  //intended first number in the sequence.
  return mia;
}

<div id="log"></div> <!-- Just used to display the demo code -->

Answer 10

Я использую рекурсивную функцию для этого.

function findMissing(arr, start, stop) {

    var current = start,
        next = stop,
        collector = new Array();

    function parseMissing(a, key) {
        if(key+1 == a.length) return;

        current = a[key];
        next = a[key + 1];

        if(next - current !== 1) {
            collector.push(current + 1);
            // insert current+1 at key+1
            a = a.slice( 0, key+1 ).concat( current+1 ).concat( a.slice( key +1 ) );
            return parseMissing(a, key+1);
        }

        return parseMissing(a, key+1);
    }

    parseMissing(arr, 0);
    return collector;
}

Не самая лучшая идея, если вы просматриваете огромный набор цифр.ЧЕСТНОЕ ПРЕДУПРЕЖДЕНИЕ: рекурсивные функции являются ресурсоемкими (указатели и прочее), и это может дать вам неожиданные результаты, если вы работаете с огромными числами.Вы можете увидеть jsfiddle .Это также предполагает, что у вас есть отсортированный массив.

По сути, вы передаете функции "findMissing ()" массив, который вы хотите использовать, начальный номер и конечный номер, и отпускаете его оттуда.

Итак:

var missingArr = findMissing(sequenceArr, 1, 10);