Sayıları azalan sırada ama başlangıçta `0`larla sıralama

JavaScript'te bir süredir anlamaya çalıştığım bir zorluk var.

Şu diziyi düşünün:

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

Bu sonucu çıkarmak zorundayım:

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

İndeks değerini ayarlayarak sıfırları öne konumlandırmak için bu mantık satırını takip ediyorum:

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

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

    return y - x;
});

Ama bu sonuca takılı kaldım:

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

Herkes bunu çözmek için herhangi bir ipucu var mı?

bVe a(azalan sıralama için) deltalarına göre sıralayabilir ve Number.MAX_VALUEsıfır gibi yanlış değerler için alabilirsiniz .

Bu:

Number.MAX_VALUE - Number.MAX_VALUE

sıfıra eşittir.

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

Mdn belgelerinin dediği gibi:

A ve b karşılaştırılan iki öğeyse, o zaman:

Eğer compareFunction(a, b)daha küçük döndürürse, daha düşük bir dizine 0sıralayın (yani önce bir gelir).ab

Eğer compareFunction(a, b)getiri 0, bir ayrılıp birbirlerine göre b değişmeden, ancak tüm farklı unsurları açısından sıralanmış. Not: ECMAscript standardı bu davranışı garanti etmez, bu nedenle tüm tarayıcılar (örneğin, en az 2003'e dayanan Mozilla sürümleri) buna saygı göstermez.

Eğer compareFunction(a, b) sıralama 0'dan büyük getiriler, bbir dizin için daha düşük (yani bönce gelir).

compareFunction(a, b)elemanların belirli bir çift verilen her zaman aynı değeri gerekir ave biki bağımsız değişken olarak. Tutarsız sonuçlar döndürülürse, sıralama düzeni tanımsızdır.

Yani, karşılaştırma işlevi aşağıdaki forma sahiptir:

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

Verimliliği önemsiyorsanız, öncelikle sıfırları filtrelemek en hızlı yöntemdir . Bu sortözel durumu ele almak için karşılaştırma geri aramanıza fazladan iş ekleyerek, onlara bakmakla bile zaman kaybetmek istemezsiniz .

Özellikle önemli sayıda sıfır bekliyorsanız, bunları filtrelemek için verilerin üzerinden bir geçiş, her sıfıra birden çok kez bakacak daha büyük bir O (N log N) türünden çok daha iyi olmalıdır.

Şunları yapabilirsiniz verimli bitirdiniz sonra sıfır doğru sayıda getirebilirsiniz.

Ortaya çıkan kodu okumak da kolaydır. Ben verimli ve sayısal sıralama kolaylaştırır çünkü TypedArray kullandım . Ancak bu tekniği (a,b)=>a-bfor için standart deyimi kullanarak normal Array ile kullanabilirsiniz .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);
*/

TypedArray .sort()olup olmadığını bilmiyorum ve sonra .reverseazalan düzende sıralamak için özel bir karşılaştırma işlevi kullanarak daha hızlı. Ya da bir yineleyici ile anında kopyalayıp geri çevirebilirsek.

Ayrıca dikkate değer: sadece tam uzunlukta bir TypedArray kullanın .

Kullanmak yerine, .filterüzerine gelin ve sıfırları dizinin önüne kaydırın . Bu, verilerinizin üzerinden bir kez geçer.

Ardından .subarray(), aynı temel ArrayBuffer öğesinin sıfır olmayan öğelerinin yeni bir TypedArray görünümünü elde etmek için kullanın . Sıralamayı sıfırdan farklı elemanlara bakacak şekilde sıfır başlangıcı ve sıralı kuyruğu ile tam dizi bırakacak sıralama.

Array veya TypedArray yöntemlerinde bir bölüm işlevi görmedim, ancak JavaScript'i zar zor biliyorum. İyi JIT ile, bir döngü yerleşik bir yöntemden çok daha kötü olmamalıdır. (Özellikle bu yöntem bir geri çağırma içeriyorsa .filterve büzülmek reallociçin kaputun altında kullanılmadıkça, gerçekten filtrelenmeden önce ne kadar bellek ayıracağını bulmalıdır).

Bir TypedArray dönüştürmeden .filter() önce düzenli Array kullandım . Girişiniz zaten bir TypedArray ise, bu sorunla karşılaşmazsınız ve bu strateji daha da cazip hale gelir.

Karşılaştırma işlevinizin durumunu şu şekilde değiştirin -

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

Burada kod golf oynamıyor:

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

Zaten varsa, kendi sayısal sıralamanızı yazmayın. Ne yapmak istediğiniz tam olarak başlıkta söylediklerinizdir; sayıları başlangıçtaki sıfırlar dışında azalan sırada sıralayın.

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

İhtiyacınız olmayan herhangi bir kod yazmayın; yanlış anlayabilirsin.

Dizinin işlemesini istediğiniz sayı türüne göre TypedArray öğesini seçin . Float64, tüm normal JS numaralarını işlediğinden iyi bir varsayılan değerdir.

Bunu şu şekilde yapabilirsiniz:

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)

ya da bunu yapabilirsiniz:

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)