Sắp xếp các số theo thứ tự giảm dần nhưng với `0` khi bắt đầu

Tôi có một thách thức trong JavaScript mà tôi đang cố gắng tìm ra trong một thời gian.

Hãy xem xét mảng này:

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

Tôi phải xuất kết quả này:

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

Tôi đang theo dòng logic này để định vị các số 0 ở phía trước, điều chỉnh giá trị chỉ mục:

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

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

    return y - x;
});

Nhưng tôi bị kẹt ở kết quả này:

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

Có ai có bất cứ lời khuyên về cách giải quyết điều này?

Bạn có thể sắp xếp theo delta bvà a(để sắp xếp giảm dần) và lấy Number.MAX_VALUE, cho các giá trị sai lệch như 0.

Điều này:

Number.MAX_VALUE - Number.MAX_VALUE

bằng không.

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

Như các tài liệu mdn nói:

Nếu a và b là hai yếu tố được so sánh, thì:

Nếu compareFunction(a, b)trả về ít hơn 0, sắp xếp atheo chỉ mục thấp hơn b(tức là đến trước).

Nếu compareFunction(a, b)trả về 0, không thay đổi a và b đối với nhau, nhưng được sắp xếp theo tất cả các yếu tố khác nhau. Lưu ý: tiêu chuẩn ECMAscript không đảm bảo hành vi này, do đó, không phải tất cả các trình duyệt (ví dụ: các phiên bản Mozilla có từ ít nhất 2003) đều tôn trọng điều này.

Nếu compareFunction(a, b) trả về lớn hơn 0, sắp xếp btheo chỉ mục thấp hơn một (tức là bđến trước).

compareFunction(a, b)phải luôn trả về cùng một giá trị khi được cung cấp một cặp phần tử cụ thể avà bnhư hai đối số của nó. Nếu kết quả không nhất quán được trả về, thì thứ tự sắp xếp không được xác định.

Vì vậy, hàm so sánh có dạng sau:

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

Nếu bạn quan tâm đến hiệu quả, có lẽ nhanh nhất để lọc các số không trước . Bạn không muốn sortlãng phí thời gian thậm chí nhìn vào chúng, chứ đừng nói đến việc thêm công việc vào cuộc gọi lại so sánh của bạn để xử lý trường hợp đặc biệt đó.

Đặc biệt, nếu bạn mong đợi một số lượng không đáng kể, một lần chuyển dữ liệu để lọc chúng sẽ tốt hơn nhiều so với thực hiện một loại O (N log N) lớn hơn sẽ nhìn vào mỗi số 0 nhiều lần.

Bạn có thể chuẩn bị một cách hiệu quả số lượng không đúng sau khi hoàn thành.

Nó cũng dễ đọc mã kết quả. Tôi đã sử dụng TypedArray vì nó hiệu quả và giúp việc sắp xếp số dễ dàng . Nhưng bạn có thể sử dụng kỹ thuật này với Array thông thường, sử dụng thành ngữ chuẩn của (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);
*/

Tôi không biết nếu TypedArray .sort()và sau đó .reversenhanh hơn sử dụng chức năng so sánh tùy chỉnh để sắp xếp theo thứ tự giảm dần. Hoặc nếu chúng ta có thể sao chép và đảo ngược khi đang di chuyển bằng một trình vòng lặp.

Cũng đáng xem xét: chỉ sử dụng một TypedArray có độ dài đầy đủ .

Thay vì sử dụng .filter, lặp qua nó và hoán đổi các số không về phía trước của mảng khi bạn đi. Điều này có một vượt qua dữ liệu của bạn.

Sau đó sử dụng .subarray()để có được chế độ xem TypedArray mới về các phần tử khác không của cùng một ArrayBuffer bên dưới. Sắp xếp sẽ để lại cho bạn toàn bộ mảng với bắt đầu bằng 0 và đuôi được sắp xếp, với sắp xếp chỉ nhìn vào các phần tử khác không.

Tôi không thấy hàm phân vùng trong các phương thức Array hoặc TypedArray, nhưng tôi hầu như không biết JavaScript. Với JIT tốt, một vòng lặp không nên quá tệ hơn so với phương thức tích hợp. (Đặc biệt là khi phương thức đó liên quan đến một cuộc gọi lại như thế .filter, và trừ khi nó sử dụng reallocdưới mui xe để thu nhỏ, nó phải tìm ra bao nhiêu bộ nhớ để phân bổ trước khi nó thực sự lọc).

Tôi đã sử dụng Array thường xuyên .filter() trước khi chuyển đổi thành TypedArray. Nếu đầu vào của bạn đã là TypedArray, bạn không gặp phải vấn đề này và chiến lược này thậm chí còn hấp dẫn hơn.

Chỉ cần sửa đổi điều kiện của chức năng so sánh của bạn như thế này -

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

Không chơi golf ở đây:

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

Đừng viết sắp xếp số của riêng bạn nếu nó đã tồn tại. Những gì bạn muốn làm là chính xác những gì bạn nói trong tiêu đề; sắp xếp các số theo thứ tự giảm dần trừ số 0 khi bắt đầu.

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

Đừng viết bất kỳ mã nào bạn không cần phải làm; bạn có thể hiểu sai

Chọn TypedArray dựa trên Loại số bạn muốn Mảng xử lý. Float64 là một mặc định tốt vì nó xử lý tất cả các số JS bình thường.

Bạn có thể làm điều này như thế này:

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)

hoặc bạn có thể làm điều này:

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)