सारणी - एक अनुक्रम

Question

मैं एक दृश्य में सभी लापता संख्या को खोजने के लिए लूप (पुनरावृति) एक सरणी से अधिक करने के लिए एक आसान तरीका खोजने की कोशिश कर रहा हूँ में लापता संख्या का पता लगाएं, सरणी नीचे एक जैसे दिखते हैं जाएगा।

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

सरणी ऊपर मैं 0189462 और 0189464 की आवश्यकता होगी के लिए लॉग आउट।

कोई विचार?

अद्यतन

मदद के लिए धन्यवाद,

क्षमा Kennebec सही ढंग से अंत में काम नहीं हो सकता है आपके कार्य करने के लिए। अपने उत्तर के नीचे टिप्पणी देखें।

EDIT: यह सही समाधान है जिसे मैंने सॉफियान के उत्तर से उपयोग किया था।

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

आप जानते हैं कि संख्या छाँटे गए और वृद्धि हो रही है, तो:

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

यह सरणी सॉर्ट करने के लिए काफी सरल हो जाएगा: तब

numArray.sort(); 

, क्या के लिए सबसे आसान था पर निर्भर करता है आप:

1. आप कर सकते थे बस सरणी को पार करें, अनुक्रमिक पैटर्न को पकड़ें और उन्हें जाने के दौरान जांचें।
2. आप सरणी को अनुक्रमिक संख्याओं के एकाधिक सरणी में विभाजित कर सकते हैं और फिर उन अलग-अलग सरणी जांच सकते हैं।
3. आप सॉर्ट किए गए सरणी को जोड़ों की एक सरणी में कम कर सकते हैं जहां प्रत्येक जोड़ी एक प्रारंभ और अंत अनुक्रम है और फिर उन अनुक्रमों की तुलना अपने अन्य डेटा से शुरू/समाप्त करें।

Answer 3

अपने अग्रणी शून्य देखो, वे जब सरणी interpreted-

वर एक = [0,189,459, 0,189,460, 0,189,461, 0,189,463, 0,189,465]

(ए रिटर्न है गिरा दिया जाएगा [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; 
} 

वर एक = [0,189,459, 0,189,460, 0,189,461, 0,189,463, 0,189,465]; चेतावनी (अनुपस्थित (ए))

/* दिए गए मान: (सरणी) 189462,189464 */

Answer 4

मैं इस के लिए एक पुनरावर्ती समारोह का उपयोग करें।

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

Answer 5

यहाँ का एक प्रकार है @Mark वाल्टर्स के function जो, अपने दृश्य के लिए एक कम सीमा निर्दिष्ट करने की क्षमता कहते हैं, उदाहरण के लिए यदि आप जानते हैं कि आपके अनुक्रम हमेशा 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 6

एक दृश्य में एक लापता संख्या जानने के लिए, सबसे पहले, हम एक सरणी सॉर्ट करने के लिए की जरूरत है। फिर हम पहचान सकते हैं कि कौन सा नंबर गुम है। मैं यहां कुछ परीक्षण परिदृश्यों के साथ पूर्ण कोड प्रदान कर रहा हूं। यह कोड केवल यादृच्छिक संख्या की पहचान करेगा, यदि आप ऋणात्मक मान भी पास करते हैं तो यह सकारात्मक संख्या देता है।

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