Sortieren von Zahlen in absteigender Reihenfolge, jedoch mit "0" am Anfang

Ich habe eine Herausforderung in JavaScript, die ich bereits seit einiger Zeit herausfinden möchte.

Betrachten Sie dieses Array:

let arr = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5];

Ich muss dieses Ergebnis ausgeben:

arr = [0, 0, 0, 0, 0, 5, 4, 3, 2, 1]

Ich folge dieser Logik, um die Nullen vorne zu positionieren und den Indexwert anzupassen:

arr.sort((x, y) => {
    if (x !== 0) {
        return 1;
    }

    if (x === 0) {
        return -1;
    }

    return y - x;
});

Aber ich stecke bei diesem Ergebnis fest:

arr = [0, 0, 0, 0, 0, 1, 2, 3, 4, 5]

Hat jemand irgendwelche Tipps, wie man das löst?

Sie können nach dem Delta von bund a(für absteigende Sortierung) sortieren und Number.MAX_VALUEfür falsche Werte wie Null nehmen.

Diese:

Number.MAX_VALUE - Number.MAX_VALUE

ist gleich Null.

let array = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5];

array.sort((a, b) => (b || Number.MAX_VALUE) - (a || Number.MAX_VALUE));

console.log(...array);

Wie mdn docs sagt:

Wenn a und b zwei Elemente sind, die verglichen werden, dann:

Wenn compareFunction(a, b)weniger als zurückgegeben wird 0, sortieren Sie anach einem Index, der niedriger als ist b(dh a steht an erster Stelle).

Wenn compareFunction(a, b)0 zurückgegeben wird, lassen Sie a und b unverändert zueinander, aber sortiert nach allen verschiedenen Elementen. Hinweis: Der ECMAscript-Standard garantiert dieses Verhalten nicht. Daher respektieren dies nicht alle Browser (z. B. Mozilla-Versionen aus mindestens 2003).

Wenn eine compareFunction(a, b) Rückgabe größer als 0 ist, sortieren Sie bnach einem Index kleiner als a (dh bsteht an erster Stelle).

compareFunction(a, b)muss immer den gleichen Wert zurückgeben, wenn ein bestimmtes Elementpaar aund bseine beiden Argumente angegeben werden. Wenn inkonsistente Ergebnisse zurückgegeben werden, ist die Sortierreihenfolge undefiniert.

Die Vergleichsfunktion hat also die folgende Form:

function compare(a, b) {
  if (a is less than b by some ordering criterion) {
    return -1;
  }
  if (a is greater than b by the ordering criterion) {
    return 1;
  }
  // a must be equal to b
  return 0;
}

let arr = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5];

arr.sort((x, y) => {
    if (x > 0 && y > 0) {
        return y - x;
    }
    return x - y;
});

console.log(arr);

Wenn Sie Wert auf Effizienz legen, ist es wahrscheinlich am schnellsten, zuerst die Nullen herauszufiltern . Sie möchten keine sortZeit damit verschwenden, sie sich anzusehen, geschweige denn Ihrem Vergleichsrückruf zusätzliche Arbeit hinzuzufügen, um diesen Sonderfall zu behandeln.

Insbesondere wenn Sie eine signifikante Anzahl von Nullen erwarten, sollte ein Durchlauf über die Daten zum Herausfiltern viel besser sein als eine größere O (N log N) -Sortierung, bei der jede Null mehrmals betrachtet wird.

Sie können die richtige Anzahl von Nullen effizient voranstellen, nachdem Sie fertig sind.

Genauso einfach ist es, den resultierenden Code zu lesen. Ich habe TypedArray verwendet, weil es effizient ist und das numerische Sortieren vereinfacht . Sie können diese Technik jedoch mit regulären Arrays verwenden, wobei Sie die Standardsprache (a,b)=>a-bfor verwenden .sort.

let arr = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5];

let nonzero_arr = Int32Array.from(arr.filter(n => n != 0));
let zcount = arr.length - nonzero_arr.length;
nonzero_arr.sort();      // numeric TypedArray sorts numerically, not alphabetically

// Reverse the sorted part before copying into the final array.
nonzero_arr.reverse();

 // efficient-ish TypedArray for main result
let revsorted = new Int32Array(arr.length);   // zero-filled full size
revsorted.set(nonzero_arr, zcount);           // copy after the right number of zeros

console.log(Array.from(revsorted));      // prints strangely for TypedArray, with invented "0", "1" keys

/*
   // regular Array result
let sorted = [...Array(zcount).fill(0), ...nonzero_arr]  // IDK if this is efficient
console.log(sorted);
*/

Ich weiß nicht, ob TypedArray .sort()und dann .reverseschneller als die Verwendung einer benutzerdefinierten Vergleichsfunktion zum Sortieren in absteigender Reihenfolge. Oder wenn wir mit einem Iterator im laufenden Betrieb kopieren und umkehren können.

Ebenfalls erwägenswert: Verwenden Sie nur ein TypedArray in voller Länge .

Anstatt zu verwenden .filter, schleifen Sie darüber und tauschen Sie die Nullen an die Vorderseite des Arrays, während Sie fortfahren. Dies dauert einen Durchgang über Ihre Daten.

Verwenden Sie dann .subarray(), um eine neue TypedArray-Ansicht der Nicht-Null-Elemente desselben zugrunde liegenden ArrayBuffers abzurufen. Durch die Sortierung erhalten Sie das gesamte Array mit einem Nullstart und einem sortierten Ende, wobei die Sortierung immer nur die Nicht-Null-Elemente betrachtet.

Ich habe keine Partitionsfunktion in den Array- oder TypedArray-Methoden gesehen, kenne aber kaum JavaScript. Mit einer guten JIT sollte eine Schleife nicht zu viel schlechter sein als eine integrierte Methode. (Insbesondere wenn diese Methode einen Rückruf wie beinhaltet .filterund nicht reallocunter der Haube zum Verkleinern verwendet wird, muss sie herausfinden, wie viel Speicher zugewiesen werden muss, bevor sie tatsächlich gefiltert wird.)

Ich habe .filter() vor der Konvertierung in ein TypedArray ein reguläres Array verwendet. Wenn Ihre Eingabe bereits ein TypedArray ist, haben Sie dieses Problem nicht und diese Strategie wird noch attraktiver.

Ändern Sie einfach den Zustand Ihrer Vergleichsfunktion wie folgt:

let arr = [-1, 0, 1, 0, 2, -2, 0, 3, -3, 0, 4, -4, 0, 5, -5];
arr.sort((a, b) => {
   if(a && b) return b-a;
   if(!a && !b) return 0;
   return !a ? -1 : 1;
});

console.log(arr);

Hier kein Code Golf spielen:

let arr = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5, -1];
arr.sort(function(a, b) {
  if (a === 0 && b !== 0) {
    // a is zero b is nonzero, a goes first
    return -1;
  } else if (a !== 0 && b === 0) {
    // a is nonzero b is zero, b goes first
    return 1;
  } else {
    // both are zero or both are nonzero, sort descending
    return b - a;
  }
});
console.log(arr.toString());

Schreiben Sie keine eigene numerische Sortierung, wenn diese bereits vorhanden ist. Was Sie tun möchten, ist genau das, was Sie im Titel sagen. Sortieren Sie die Nummern in absteigender Reihenfolge mit Ausnahme von Nullen am Anfang.

const zeroSort = arr => [...arr.filter(n => n == 0),
                         ...new Float64Array(arr.filter(n => n != 0)).sort().reverse()];

console.log(zeroSort([0, 1, 0, 2, 0, 3, 0, 4, 0, 500]));

Schreiben Sie keinen Code, den Sie nicht benötigen. Sie könnten es falsch verstehen.

Wählen Sie das TypedArray basierend auf dem Typ der Zahlen aus, die das Array verarbeiten soll. Float64 ist eine gute Standardeinstellung, da alle normalen JS-Nummern verarbeitet werden.

Sie können dies folgendermaßen tun:

let arr = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5];

let result = arr.sort((a,b) => {
  if(a == 0 || b == 0)
    return a-b;
  return b-a;
})
console.log(result)

oder Sie können dies tun:

let arr = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5];

let result = arr.sort().sort((a,b) => {
  if(a > 0 && b > 0)
    return b-a
  return 0
})

console.log(result)