Estoy tratando de encontrar una manera fácil de bucle (iterar) a través de una matriz para encontrar todos los números que faltan en una secuencia, la matriz se ven un poco como la de abajo.

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

Para la matriz anterior necesitaría 0189462 y 0189464 la sesión.

ACTUALIZACIÓN : esta es exactamente la solución que se usa desde Soufiane la respuesta.

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]

ACTUALIZACIÓN

Aquí una prolija versión de usar .reducir

JS:

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

  • Puede recorrer la matriz y comparar cada uno de los dos elementos.
InformationsquelleAutor Mark Walters | 2011-09-06

11 Comentarios

  1. 29

    Si usted sabe que los números están ordenados en aumento:

    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
        }
    }
    • Gracias Soufiane, es el que se va a capturar cada ocurrencia en la matriz de la matriz contendrá aprox 100 números y cómo puedo registrar el hecho número que no está allí, otra vez yo pueda ser un ser de espesor.
    • Cada número entre numArray[i] y numArray[i-1], si la diferencia es mayor que 1, no está en la matriz.
    • Sí, usted va a ir a través de cada elemento de la matriz, y para coger el número que falta, cuando la diferencia es X (X != 1), los números que faltan son : numArray[i-1] + j (j>0 y j<X)
    • Felix: gracias a ambos
  2. 5

    Ver sus ceros a la izquierda, se quitarán cuando la matriz es interpretado-

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

    (Un devuelve [189459,189460,189461,189463,189465])

    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 Un= [0189459, 0189460, 0189461, 0189463, 0189465];
    alert(ausente(A))

    /* valor devuelto: (Matriz)
    189462,189464
    */

  3. 3

    Para encontrar un número que falta en una secuencia, Primero de todo, Tenemos que ordenar una matriz. A continuación, podemos identificar qué número es el que falta. Me estoy dando aquí el código completo con algunos de los escenarios de prueba. este código identificará sólo faltan número positivo, si se pasa de valores negativos, incluso, a continuación, se da un número positivo.

    JS:

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

  4. 0

    Sería bastante sencillo para ordenar la matriz:

    numArray.sort();

    Luego, dependiendo de lo que fue más fácil para usted:

    1. Sólo se podía atravesar la matriz, la captura de patrones secuenciales y comprobación de las mismas a medida que avanza.
    2. Se podría dividir la matriz en varias matrices de números secuenciales y, a continuación, revise cada una de las diferentes matrices.
    3. Podría reducir la matriz ordenada a un array de pares, donde cada par es un inicio y final de la secuencia y, a continuación, compare los de la secuencia de inicio/extremos de otros datos.
  5. 0

    Yo uso una función recursiva para esto.

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

    No es la mejor idea si usted está buscando a través de un enorme conjunto de números. FERIA de ADVERTENCIA: funciones recursivas son intensiva de recursos (punteros y esas cosas) y esto puede dar resultados inesperados si se trabaja con números enormes. Usted puede ver el jsfiddle. Esto también supone que el array ordenado.

    Básicamente, se pasa a la «findMissing()» función de la matriz que desea utilizar, el número de partida y parada número y deje que se vaya de allí.

    Así:

    var missingArr = findMissing(sequenceArr, 1, 10);
  6. 0
    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]))
  7. 0

    Por favor marque a continuación el código…..

    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;
    }
  8. 0

    ES6-Estilo

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

    Resultado: [189462, 189464]

  9. 0
    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;
    };
  10. -1

    Esta es una variante de @Mark Walters del la función que añade la capacidad para especificar un límite inferior para la secuencia, por ejemplo, si usted sabe que su secuencia debe comenzar siempre en 0189455, o algún otro número como 1.

    También debe ser posible ajustar este código para comprobar un límite superior, pero en el momento en que sólo puede mirar para bajar límites.

    JS:

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

    HTML:

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

  11. -1

    JS:

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

    • Esto no cuenta para los secuencial de los valores perdidos, entre algunos otros temas. Intente con este ejemplo: const numArray = [3,5,1,8,9]

Dejar respuesta

Please enter your comment!
Please enter your name here