Wie überprüft man, ob ein Array in Javascript zunimmt?

Question

Ich folge einem Javascript-Kurs und bin mit etwas festgefahren. Wir bekommen eine Website voller Übungen und müssen alle Testfälle grün werden lassen.

Wir müssen prüfen, ob ein Array zunimmt, und in diesem Fall true zurückgeben. Wenn der nächste Wert derselbe wie der vorherige ist, muss die Funktion auch true zurückgeben. Alle meine Testfälle geben aus irgendeinem Grund falsch aus? Und wenn ich das else entferne, ist nur einer der Testfälle falsch (dieser: [0,1,2,3,4,5,0]). Here are the test cases.

function isIncreasing(xs) { 
    var result = false; 
    if (xs.length == 1 || xs.length === 0) { 
     return true; 
    } 
    for (var i = 0; i <= xs.length - 1; i++) { 
     if (xs[i] == xs[i + 1] - 1 || xs[i] == xs[i + 1]) { 
      result = true; 
     } 
     else return false; 
    } 
    return result; 
} 

Answer 1

Gehen Sie mit dem Debugger durch Ihren Code, stoppen Sie bei interessanten Zeilen und untersuchen Sie die Werte. Sie sollten in der Lage sein, das Problem bald genug zu finden.

Wenn Sie eine for Schleife verwenden mögen, können Sie Ihren Code, und lassen Sie das spezielle Gehäuse für 0 und 1, während der Festsetzung der Oberseite der Schleifenbedingung vereinfachen:

function isIncreasing(xs) { 
    var prev, cur; 

    for (var i = 0; i < xs.length; i++) { 
    cur = xs[i]; 
    if (i && cur !== prev && cur !== prev + 1) return false; 
    prev = cur; 
    } 

    return true; 
} 

Wenn Sie erlaubt sind ES5 Array Methoden zu verwenden, kann dies nutzen every:

[1, 2, 3].every(function(elt, idx, arr) { 
    var prev = arr[idx - 1]; 
    return !idx || elt === prev || elt === prev + 1; 
}) 

Wenn Sie Ihren Code semantischen und lesbar machen, eine gut benannte Funktion definieren:

function sameOrGreater(elt, idx, arr) { 
    var prev = arr[idx - 1]; 
    return !idx || elt === prev || elt === prev + 1; 
} 

[1, 2, 3].every(sameOrGreater) 

Um mit dieser Faktorisierung fortzufahren, können wir zwei Aspekte der Lösung trennen. Die erste besteht darin, zu sehen, ob ein Wert gleich oder größer als der andere ist. Die zweite besteht darin, Paare benachbarter Elemente in einem Array aufzunehmen.Mit anderen Worten, würden wir die Lösung, wie in der Lage sein mag

pairs(xs).every(sameOrGreater) 

sameOrGreater ist einfach zu schreiben:

function sameOrGreater(x, y) { return x === y || x === y - 1; } 

pairs wie folgt geschrieben werden kann:

function pairs(array) { 
    return array.slice(1).map(function(elt, idx, arr) { 
    return [array[idx], elt]; 
    }); 
} 

> pairs([1, 2, 3]) 
< [[1, 2], [2, 3]] 

Sie bevorzugen könnten zu schreiben pairs mit einem Generator:

function* pairs(array) { 
    let prev; 
    for (const x of array) { 
    yield [prev, x]; 
    prev = x; 
    } 
} 

Alternativ könnten wir eine Version von map schreiben, die eine Funktion, auf die fed Paare nimmt, wie folgt:

function mapPairs(xs, fn) { 
    var result = []; 
    for (var i = 1; i < xs.length); i++) { 
    result.push(fn(x[i - 1], x[i])); 
    } 
    return result; 
} 

Jetzt können wir das ganze Problem als

mapPairs(xs, sameOrGreater).every(Boolean) 

Answer 2

der Schleife versucht, ein Element außerhalb der Arraygrenzen auf der letzten Iteration (i == xs.length - 1 und dann xs[i+1]) zuzugreifen. Ein saubererer Weg wäre, stattdessen mit dem zweiten Elem zu beginnen und sich mit dem vorherigen, nicht dem nächsten zu vergleichen.

function isIncreasing(xs) { 
 
    
 
    for (var i = 1; i < xs.length; i++) { 
 
     if (xs[i] !== xs[i - 1] && xs[i] != xs[i - 1] + 1) { 
 
      return false; 
 
     } 
 
    } 
 
    
 
    return true; 
 
} 
 

 
console.log(isIncreasing([])); 
 
console.log(isIncreasing([1])); 
 
console.log(isIncreasing([1,2,3,4,4,5])); 
 
console.log(isIncreasing([0,1,2,3,4,5,0]))

Beachten Sie auch, wie Sie Ihre Funktion (Länge überprüft und das Ergebnis Variable sind eigentlich nicht erforderlich) vereinfacht werden kann.