Überprüfen Sie, ob Javascript Array-Werte in aufsteigender Reihenfolge sind

Question

Angenommen, ich habe ein Array von ganzen Zahlen in Javascript, das ich überprüfen möchte, ob alle seine Werte in aufsteigender Reihenfolge sind. Ich möchte den Array-Schlüssel in einem anderen Array speichern, falls der Algorithmus einen Wert findet, der niedriger (oder gleich) ist und nicht nur den unmittelbar vorherigen vergleicht, sondern auch einen Wert, der davor liegt. Was ich tat, war dies:

arr = [], nonvalid = []; 

for (var j = 1; j < arr.length; j++){ 
    if (arr[j+1] <= arr[j]){ 
     nonvalid.push(j); 
    } 
} 

Offensichtlich sind die oben algorightm prüft nur für Werte, die vor dem unteren Vergleich der eins sind.

könnte ein Array-Werte wie diese enthalten:

arr = 1, 2, 3, 10, , 11, 12, , , 25

den ungültigen Werte sind die Fettwerte. Wenn ich die obige Schleife laufe, "fängt" sie nicht die zweitletzte(), weil sie höher ist als ihr nächster linker Bruder, aber nicht so hoch wie alle linken Brüder.

EDIT:

versucht, die folgenden Lösungen und keine Rückkehr alle nonvalid Werte für dieses Array außer mir. :(

Sie kehrten die letzten beiden Werte correctedly, aber nicht die zweite. Ich verstehe nicht, warum though.

[24398, 24397 , 25004, 25177, 26302, 28036, 29312, 29635, 29829, 30476, 32595, 33732, 34995, 36047, 36363, 37310, 38022, 38882, 40746, 41212, 42846, 43588, 44029, 44595, 44846, 45727, 46041, 47293, 48002, 48930, 49858, 51184, 51560, 53895, 54247, 54614, 55713, 56813, 57282, 57480, 57875, 58073, 58403, 60321, 61469, 62051, 62310, 62634, 63217, 64505, 65413, 65677, 65940, 66203, 66572, 67957, 68796, 68964, 69098, 69233, 69435, 69759, 71496, 72577, 72823, 73007, 73252, 73743, 73866, 76405, 77037, 77416, 77669, 79691, 80885, 81339, 81794, 82067, 82431, 8324 4, 84861, 86836, 88632, 89877, 90296, 91049, 91885, 92351, 92614, 93141, 93733, 93930, 94531, 95206, 95882, 96895, 97732, 97973, 99261, 99422, 99583, 100332, 100599, 101666, 102066, 102600, 103504, 104432, 105174, 107216, 109.085, 110.181, 110.679, 111.177, 111.988, 112.553, 113.005, 113.457, , ]

Answer 1

Wenn Sie ein Element finden aus Ordnen Sie sich die nächsten Elemente an, bis sie nicht mehr außer Betrieb sind vor der außer Betrieb eins.

Fügen Sie dem zweiten Array die Out-of-Order-Elemente hinzu und fahren Sie mit dem neuen In-Order-Element fort.

var outs= [], L= A.length, i= 0, prev; 
while(i<L){ 
    prev= A[i]; 
    while(A[++i]<prev) outs.push(i); 
} 
alert(outs) 

Answer 2

Copy das Array erster, entfernt jedes Element, das ist nicht in der Reihenfolge mit array.splice(index, 1), und weiter. Auf diese Weise muss jedes Element größer als das vorherige sein, aber das eine Recht davor wird immer das Maximum sein.

Answer 3

Behalten Sie den größten Wert, den Sie gesehen haben (see the fiddle):

function find_invalid_numbers(arr) { 
    var nonvalid, i, max; 

    nonvalid = []; 

    if (arr.length !== 0) { 
     max = arr[0]; 

     for (i = 1; i < arr.length; ++i) { 
      if (arr[i] < max) { 
       nonvalid.push(arr[i]); 
      } else { 
       max = arr[i]; 
      } 
     } 
    } 

    return nonvalid; 
} 

Answer 4

Warum nicht compare with the last known good number?

var arr = [1, 2, 3, 10, 5, 11, 12, 2, 4, 25], 
    nonvalid = [], 
    lastGoodValue = 0; 

for (var j = 1; j < arr.length; j++) { 
    if (j && arr[j] <= lastGoodValue) { 
     //if not the first number and is less than the last good value 
     nonvalid.push(arr[j]); 
    } else { 
     //if first number or a good value 
     lastGoodValue = arr[j]; 
    } 
} 

console.log(arr, nonvalid) 

Answer 5

Ich habe meine eigene Frage beantwortet, nachdem ich Ihre Ratschläge genommen habe. Ich habe das folgende Algorightm versucht. Es scheint seinen Job zu machen, aber es ist ein bisschen übertrieben.

for (var i = 0; i < arr.length; i ++) {

for (var j = 1; j < arr.length; j++){ 

    if (arr[j] > 0 && arr[i] > 0 && j != i){ 

     if (arr[j] <= arr[i] && j > i){ 

      if (jQuery.inArray(j, nonvalid) == - 1) nonvalid.push(j); 
     } 
    } 
} } 

Answer 6

DEMO

var arr = [24398, 24397, 25004, 25177, 26302, 28036, 29312, 29635, 29829, 30476, 32595, 33732, 34995, 36047, 36363, 37310, 38022, 38882, 40746, 41212, 42846, 43588, 44029, 44595, 44846, 45727, 46041, 47293, 48002, 48930, 49858, 51184, 51560, 53895, 54247, 54614, 55713, 56813, 57282, 57480, 57875, 58073, 58403, 60321, 61469, 62051, 62310, 62634, 63217, 64505, 65413, 65677, 65940, 66203, 66572, 67957, 68796, 68964, 69098, 69233, 69435, 69759, 71496, 72577, 72823, 73007, 73252, 73743, 73866, 76405, 77037, 77416, 77669, 79691, 80885, 81339, 81794, 82067, 82431, 83244, 84861, 86836, 88632, 89877, 90296, 91049, 91885, 92351, 92614, 93141, 93733, 93930, 94531, 95206, 95882, 96895, 97732, 97973, 99261, 99422, 99583, 100332, 100599, 101666, 102066, 102600, 103504, 104432, 105174, 107216, 109085, 110181, 110679, 111177, 111988, 112553, 113005, 113457, 600, 600], 
    nonvalid = [], 
    max = arr[0]; 

for(var j=0; j<arr.length; j++){ 
    var test= arr[j+1]<=max ? nonvalid.push(arr[j+1]) : max=arr[j]; 
} 

alert(nonvalid); // 24397, 600, 600 

Answer 7

eine einfache funktionale Möglichkeit, es ohne Schleifen oder Variablen inline zu tun:

arr.filter(function(a,b,c){ 
    return Math.max.apply(Math, c.slice(0,b)) > a ; 
}); 

Answer 8

Eine andere sehr schöne funktionelle Art und Weise, dies zu tun sein könnte;

var isAscending = a => a.slice(1) 
 
         .map((e,i) => e > a[i]) 
 
         .every(x => x); 
 
         
 
console.log(isAscending([1,2,3,4])); 
 
console.log(isAscending([1,2,5,4]));