Ordinamento dei numeri in ordine decrescente ma con `0`s all'inizio

Ho una sfida in JavaScript che sto cercando di capire già da un po '.

Considera questo array:

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

Devo produrre questo risultato:

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

Sto seguendo questa linea di logica per posizionare gli zeri in primo piano, regolando il valore dell'indice:

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

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

    return y - x;
});

Ma sono bloccato a questo risultato:

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

Qualcuno ha qualche consiglio su come risolverlo?

È possibile ordinare in base al delta di be a(per l'ordinamento decrescente) e prendere Number.MAX_VALUE, per valori falsi come zero.

Questo:

Number.MAX_VALUE - Number.MAX_VALUE

è uguale a zero.

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

Come dice mdn docs:

Se aeb sono due elementi da confrontare, quindi:

Se compareFunction(a, b) restituisce meno di 0, ordina in base aa un indice inferiore a b(ovvero, viene prima).

Se compareFunction(a, b)restituisce 0, lasciare aeb invariati l'uno rispetto all'altro, ma ordinati in base a tutti i diversi elementi. Nota: lo standard ECMAscript non garantisce questo comportamento, quindi non tutti i browser (ad esempio versioni di Mozilla risalenti almeno al 2003) lo rispettano.

Se compareFunction(a, b) restituisce maggiore di 0, ordina in base ba un indice inferiore a (ovvero bviene prima).

compareFunction(a, b)deve sempre restituire lo stesso valore quando viene fornita una coppia specifica di elementi ae bi suoi due argomenti. Se vengono restituiti risultati incoerenti, l'ordinamento non è definito.

Quindi, la funzione di confronto ha la seguente forma:

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

Se ti interessa l'efficienza, probabilmente è più veloce prima filtrare gli zeri . Tu non vuoisort perdere tempo nemmeno a guardarli, figuriamoci aggiungendo lavoro extra al tuo callback di confronto per gestire quel caso speciale.

Soprattutto se ti aspetti un numero significativo di zeri, un passaggio sui dati per filtrarli dovrebbe essere molto meglio che fare un ordinamento O (N log N) più grande che guarderà ogni zero più volte.

Puoi anteporre in modo efficiente il giusto numero di zeri dopo aver finito.

È anche facile leggere il codice risultante. Ho usato TypedArray perché è efficiente e semplifica l'ordinamento numerico . Ma puoi usare questa tecnica con un array normale, usando il linguaggio standard di (a,b)=>a-bfor .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);
*/

Non so se TypedArray .sort()e quindi .reversesia più veloce dell'utilizzo di una funzione di confronto personalizzata per ordinare in ordine decrescente. O se possiamo copiare e invertire al volo con un iteratore.

Vale anche la pena considerare: utilizzare solo un TypedArray per l'intera lunghezza .

Invece di usare .filter, passaci sopra e scambia gli zeri nella parte anteriore dell'array mentre procedi. Questo richiede un passaggio sui tuoi dati.

Quindi utilizzare .subarray() per ottenere una nuova vista TypedArray degli elementi diversi da zero dello stesso ArrayBuffer sottostante. L'ordinamento che ti lascerà l'array completo con un inizio zero e una coda ordinata, con l'ordinamento sempre e solo guardando gli elementi diversi da zero.

Non ho visto una funzione di partizione nei metodi Array o TypedArray, ma conosco a malapena JavaScript. Con una buona JIT, un ciclo non dovrebbe essere troppo peggio di un metodo integrato. (Soprattutto quando quel metodo prevede un callback simile .filtere se non lo usarealloc sotto il cofano per ridursi, deve capire quanta memoria assegnare prima di filtrare effettivamente).

Ho usato un array normale .filter() prima di convertirlo in un TypedArray. Se il tuo input è già un TypedArray non hai questo problema e questa strategia diventa ancora più attraente.

Basta modificare le condizioni della funzione di confronto in questo modo -

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

Non giocare a code golf qui:

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

Non scrivere il tuo ordinamento numerico se esiste già. Quello che vuoi fare è esattamente quello che dici nel titolo; ordina i numeri in ordine decrescente tranne zero all'inizio.

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

Non scrivere alcun codice che non è necessario; potresti sbagliarti.

Scegli l' array Typed in base al tipo di numeri che desideri che l'array gestisca. Float64 è un buon valore predefinito poiché gestisce tutti i normali numeri JS.

Puoi farlo in questo modo:

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)

oppure puoi farlo:

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)