So Entfernen Sie Alle Ungeraden Zahlen In Ein Array Mit Javascript?

Kann jemand diese debug-code? Ich kann nicht für das Leben von mir finden, die (Laufzeit -) Fehler:

function generate_fibonacci(n1, n2, max, out){
    var n = n1+n2;
    if(n<max){
        out.push(n);
        generate_fibonacci(n2, n, max, out);
    }
}

function generate_fibonacci_sequence(max){
    var out = [1];
    generate_fibonacci(0, 1, max, out);
    return out;
}

function remove_odd_numbers(arr){
    for (var i = 0; i < arr.length; i++) {
        if(!(arr[i]%2==0)){
            arr.splice(i, 1);
        }
    }
    return arr;
}

function sum(array){
    var total = 0;
    for (var i = 0; i < array.length; i++) {
        total+=array[i];
    }
    return total;
}

var fib_sq = generate_fibonacci_sequence(4000000);

console.log("Before: " + fib_sq);

remove_odd_numbers(fib_sq);

console.log("After: " + fib_sq);

console.log("WTH?: " + remove_odd_numbers([1,2,3,4,5,6,7,8,9]));

Ausgabe:

Before: 1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578
After: 1,2,5,8,21,34,89,144,377,610,1597,2584,6765,10946,28657,46368,121393,196418,514229,832040,2178309,3524578
WTH?: 2,4,6,8
[Finished in 0.3s]

Ich bin verrückt oder so etwas. Für einige Grund, alle ungeraden zahlen sind nicht entfernt. Aber wie man am Ende sehen, es funktioniert perfekt. Ich habe keine Ahnung, was Los ist.

  • Was ist eigentlich der Fehler?
  • Für meine fib_sq, alle ungeraden zahlen sind nicht entfernt. Betrachten Sie die Ausgabe, insbesondere "Nach". Können Sie den code ausführen?
  • Sie reden von einem (Laufzeit -) Fehler; in der Regel bezieht sich auf einen Fehler, ausgelöst durch JavaScript selbst. Ich denke was du meintest ist, dass Sie ein unerwartetes Ergebnis.
  • Ah, bin ich dankbar für die Klarstellung!
InformationsquelleAutor user2316667 | 2013-08-19
  1. 8

    Das problem im ursprünglichen code ist, dass beim entfernen der ersten 1 bei index 0, das array verschoben wird; jetzt arr[i] ist, enthält die zweite 1; aber Sie haben einfach überspringen.

    Müssen Sie verwenden, während, statt, wenn Sie hier, oder kopieren Sie es in eine separate Liste. Dies ist ein Beispiel für die Verbindung:

    function remove_odd_numbers1(arr){
    for (var i = 0; i < arr.length; i++) {
        //here
        while (arr[i] % 2) {
            arr.splice(i, 1);
        }
    }
    return arr;
}

    Aber es wird langsam aber. Besser zum erstellen eines neuen array:

    function remove_odd_numbers2(arr){
    var rv = [];
    for (var i = 0; i < arr.length; i++) {
        if (! (arr[i] % 2)) {
            rv.push(arr[i]);
        }
    }
    return rv;
}

    In der Regel der beste Algorithmus ist jedoch die Verwendung der gleichen array, wenn das original nicht benötigt wird, so dass keine zusätzlichen Speicher erforderlich ist (obwohl auf javascript, dies ist von etwas zweifelhaftem Wert):

    function remove_odd_numbers3(arr){
    var out = 0; 
    for (var i = 0; i < arr.length; i++) {
        if (! (arr[i] % 2)) {
            arr[out++] = arr[i]; 
        }
    }
    arr.length = out;
    return arr;
}

    Beachten Sie jedoch, dass im Gegensatz zum splice-Algorithmus, dieser läuft in O(n) Zeit.

    Auch das Array.der Prototyp.filter() ist nicht schlecht, ein builtin. Außerdem wird ein neues array erstellt und ist somit vergleichbar mit der 2.

    • Ahh! Danke!!!
    • Sie brauchen nicht eine innere Schleife, und Sie nicht brauchen, um eine Kopie zu erstellen. Alle, die erforderlich ist, um entweder Durchlaufen in umgekehrter anpassen oder den index, die beide bevorzugt Lösungen.
    • Die Sache ist die, reverse-Spleißen wird immer noch langsam sein. Die index-Anpassung funktioniert.
    • Was ist der "index-Anpassung"?
    • Dekrement i jedes mal, wenn Sie eine splice. @Antti: Warum sollte Durchlaufen in umgekehrter langsam sein? Jedenfalls, wenn die performance war ein Problem, dann die angrenzenden Klebestellen sollten gestapelt werden.
    • 2) ist falsch, es gibt alle ungeraden zahlen.
    • verrückter Zug: der Spleiß wird immer langsamer sein, als es schiebt, die Komplexität des Algorithmus in O(n^2).
    • Oh, du meinst langsamer als die .push(). Problem ist, dass es tatsächlich nichts entfernt, wie der name der Methode vermuten lässt.
    • Guter Punkt, ich bin damit einverstanden, dass der name könnte vermuten lassen, es ändern das ursprüngliche Objekt. Aber, wie würden Sie den Namen ein Methode, nicht? Ich denke, Sie müssen nur bewusst zu sein, die Umsetzung.

    InformationsquelleAutor Antti Haapala
  2. 2

    Ich bin mir nicht sicher, aber ich bezweifle, dass mit splice ist effizient im Vergleich zur Erstellung eines neuen Arrays.

    function remove_odd_numbers(arr) {
    var notOdd = [],
        i = 0,
        len = arr.length,
        num;

    for (; i < len; i++) {
        !((num = arr[i]) % 2) && notOdd.push(num);
    }

    return notOdd;
}

    BEARBEITEN: Sie sollten wahrscheinlich verwenden Sie die native - filter Funktion, wie vorgeschlagen von @Jack. Lasse ich diese Antwort als Referenz.

    InformationsquelleAutor plalx
  3. 2

    Hier ist eine wirklich einfache, schnelle Weg, es zu tun. Mithilfe Ihrer Daten, es dauerte nur 48ms zu vervollständigen. Hoffe, das hilft..

    function noOdds(values){
  return values.filter(function (num) {
    return num % 2 === 0;
  });
}
    InformationsquelleAutor Tabetha Moe
  4. 1

    Weil splice() ändert das array, der index wird aus in der nächsten iteration; Sie müssen verringern Sie entweder die loop-variable, verwenden Sie eine while Schleife wie Antti vorgeschlagen oder rückwärts Durchlaufen wie Verrückt Trainieren erwähnt.

    Sagte, die Verwendung von splice() ist umständlich, mit zu arbeiten, weil es ändert das array in-place. Diese Funktionalität kann einfach durch die Verwendung eines filter Funktion:

    function remove_odd_numbers(arr) 
{
    return arr.filter(function(value) {
        return value % 2 == 0;
    });
}

    Diese erstellt und gibt einen neuen array mit nur die geraden Werte.

    Angesichts der Aktualität dieser Funktion überprüfen Sie die im Abschnitt "Kompatibilität" zu behandeln, wie Browser IE < 9. Viele populäre Bibliotheken wie jQuery, underscore, etc. übernehmen diese Arbeit für Sie.

    Update

    Anstelle von filtern das array danach, es wäre mehr Speicher effizient zu nur hinzufügen, die noch Werte, wie Sie die Rekursion:

    function generate_fibonacci(previous, current, max, callback)
{
    var next = previous + current;

    if (next < max) {
        callback(next);
        generate_fibonacci(current, next, max, callback);
    }
}

function generate_fibonacci_sequence(max, callback)
{
    callback(1);
    callback(1);
    generate_fibonacci(1, 1, max, callback);
}

var out = [];
generate_fibonacci_sequence(4000000, function(value) {
    if (value % 2 == 0) {
        out.push(value);
    }
});

    Statt der übergabe der out array, ich bin übergeben Sie eine Funktion aufgerufen werden, wenn eine neue Sequenz ein Wert erzeugt wird; die Filterung erfolgt innerhalb Rückruf.

    InformationsquelleAutor Ja͢ck
  5. 0

    ES6-version von "Tabetha Moe" Antwort

    function noOdds(arr) {
    return arr.filter(value => value % 2 === 0);
}
    InformationsquelleAutor Aminetech84
Schreibe einen Kommentar