- Trova numeri mancanti in una sequenza

Question

Sto provando a trovare un modo semplice per eseguire il ciclo (iterare) su un array per trovare tutti i numeri mancanti in una sequenza, l'array avrà un aspetto simile a quello riportato di seguito.

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

Per la matrice sopra avrei bisogno 0189462 e 0189464 disconnesso.

Qualche idea?

UPDATE

Grazie per l'aiuto,

spiacenti Kennebec non potrebbe ottenere la vostra funzione di funzionare correttamente, alla fine. Vedi il commento sotto la tua risposta.

EDIT: questa è la soluzione esatta che ho usato dalla risposta di Soufiane.

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] 

Answer 1

Se si sa che i numeri sono ordinati e in 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 
    } 
} 

Answer 2

Sarebbe abbastanza semplice per ordinare l'array:

numArray.sort(); 

Poi, a seconda di ciò che è stato più facile per tu:

1. Potresti basta attraversare la matrice, catturando sequenze sequenziali e controllandole man mano che si procede.
2. È possibile dividere l'array in più array di numeri sequenziali e quindi controllare ciascuno di questi array separati.
3. È possibile ridurre la matrice ordinata a una matrice di coppie in cui ogni coppia è una sequenza di inizio e fine e quindi confrontare tali inizio/fine sequenza con gli altri dati.

Answer 3

Guarda i tuoi zeri iniziali, che verrà eliminato subito dopo l'array è interpreted-

var A = [0.189.459, 0.189.460, 0.189.461, 0.189.463, 0.189.465]

(A ritorna [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 A = [0.189.459, 0.189.460, 0.189.461, 0.189.463, 0.189.465]; avviso (assente (A))

/* valore restituito: (Array) 189462,189464 */

Answer 4

utilizzo una funzione ricorsiva per questo.

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

Non è la migliore idea se si guarda attraverso un enorme insieme di numeri. FAIR WARNING: le funzioni ricorsive sono ad uso intensivo di risorse (puntatori e materiale) e questo potrebbe darti risultati inaspettati se stai lavorando con numeri enormi. Puoi vedere lo jsfiddle. Ciò presuppone anche che l'array sia ordinato.

Fondamentalmente, si passa la funzione "findMissing()" alla matrice che si desidera utilizzare, il numero iniziale e il numero di arresto e si lascia andare da lì.

Quindi:

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

Answer 5

Ecco una variante di function che aggiunge la possibilità di specificare un limite inferiore per la sequenza, ad esempio, se si sa che la sequenza deve cominciare 0189455, o qualche @ Mark Walters altro numero come 1.

Dovrebbe anche essere possibile regolare questo codice per verificare un limite superiore, ma al momento può solo cercare i limiti inferiori.

//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 6

Per trovare un numero mancante in una sequenza, Prima di tutto, abbiamo bisogno di ordinare un array. Quindi possiamo identificare quale numero manca. Fornisco qui il codice completo con alcuni scenari di test. questo codice identificherà solo il numero positivo mancante, se si superano i valori negativi anche in quel caso si ottiene un numero positivo.

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