เรียงลำดับตัวเลขจากมากไปหาน้อย แต่ด้วย `0 'ตอนเริ่มต้น

ฉันมีความท้าทายใน JavaScript ที่ฉันพยายามคิดอยู่พักหนึ่งแล้ว

พิจารณาอาร์เรย์นี้:

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

ฉันต้องแสดงผลลัพธ์นี้:

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

ฉันกำลังตามสายของตรรกะนี้เพื่อวางตำแหน่งศูนย์ด้านหน้าปรับค่าดัชนี:

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

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

    return y - x;
});

แต่ฉันติดอยู่กับผลลัพธ์นี้:

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

ใครบ้างมีเคล็ดลับในการแก้ปัญหานี้?

คุณสามารถจัดเรียงตามเดลต้าของbและa(สำหรับการเรียงลำดับจากมากไปน้อย) และรับNumber.MAX_VALUEสำหรับค่าที่ผิดพลาดเช่นศูนย์

นี้:

Number.MAX_VALUE - Number.MAX_VALUE

เท่ากับศูนย์

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 docs พูดว่า:

หาก a และ b เป็นสององค์ประกอบที่ถูกเปรียบเทียบดังนั้น:

ถ้าcompareFunction(a, b)ผลตอบแทนน้อยกว่า0ให้เรียงaตามดัชนีที่ต่ำกว่าb(เช่น a มาก่อน)

ถ้า compareFunction(a, b)ส่งคืนค่า 0 ปล่อยให้ a และ b ไม่เปลี่ยนแปลงตามความเคารพซึ่งกันและกัน แต่เรียงลำดับตามส่วนต่าง ๆ ทั้งหมด หมายเหตุ: มาตรฐาน ECMAscript ไม่ได้รับประกันการทำงานนี้ดังนั้นไม่ใช่ทุกเบราว์เซอร์ (เช่นรุ่น Mozilla ย้อนหลังไปจนถึงอย่างน้อยปี 2003) เคารพสิ่งนี้

หากcompareFunction(a, b) ผลตอบแทนมากกว่า 0 เรียงbตามดัชนีที่ต่ำกว่า (เช่นbมาก่อน)

compareFunction(a, b)จะต้องส่งคืนค่าเดิมเสมอเมื่อได้รับองค์ประกอบaและคู่ที่เฉพาะเจาะจงbเป็นอาร์กิวเมนต์สองตัว หากส่งคืนผลลัพธ์ที่ไม่สอดคล้องกันลำดับการเรียงจะไม่ถูกกำหนด

ดังนั้นฟังก์ชั่นเปรียบเทียบมีรูปแบบดังต่อไปนี้:

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

หากคุณสนใจเกี่ยวกับประสิทธิภาพก็อาจจะเร็วที่สุดเพื่อกรองศูนย์แรก คุณไม่ต้องการที่sortจะเสียเวลาแม้แต่จะมองพวกเขาให้เพิ่มงานพิเศษลงในการเรียกกลับการเปรียบเทียบของคุณเพื่อจัดการกรณีพิเศษนั้น

โดยเฉพาะอย่างยิ่งถ้าคุณคาดหวังว่ามีเลขศูนย์จำนวนมากหนึ่งข้อมูลที่ผ่านการกรองข้อมูลจะดีกว่าการจัดเรียง O (N log N) ขนาดใหญ่กว่าที่จะดูแต่ละศูนย์หลาย ๆ ครั้ง

คุณสามารถเติมเลขศูนย์ได้อย่างมีประสิทธิภาพหลังจากเสร็จสิ้น

นอกจากนี้ยังง่ายต่อการอ่านรหัสผลลัพธ์ ผมใช้ TypedArray เพราะมันเป็นเรื่องที่มีประสิทธิภาพและทำให้การเรียงลำดับตัวเลขง่าย แต่คุณสามารถใช้เทคนิคนี้กับอาร์เรย์ปกติใช้สำนวนมาตรฐานสำหรับ(a,b)=>a-b.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()นั้น.reverseเร็วกว่าการใช้ฟังก์ชันการเปรียบเทียบแบบกำหนดเองเพื่อเรียงลำดับจากมากไปน้อย หรือถ้าเราสามารถคัดลอกและย้อนกลับได้ทันทีด้วยตัววนซ้ำ

นอกจากนี้ยังมีมูลค่าการพิจารณา: ใช้เพียงหนึ่ง TypedArray ของความยาวเต็มรูปแบบ

แทนที่จะใช้.filterให้วนรอบมันและสลับค่าศูนย์ไปที่ด้านหน้าของอาร์เรย์ในขณะที่คุณไป การดำเนินการนี้จะส่งผ่านข้อมูลของคุณหนึ่งครั้ง

จากนั้นใช้.subarray()เพื่อรับมุมมอง TypedArray ใหม่ขององค์ประกอบที่ไม่เป็นศูนย์ของ ArrayBuffer ต้นแบบเดียวกัน การเรียงลำดับที่จะทำให้คุณมีอาร์เรย์เต็มโดยเริ่มต้นที่ศูนย์และหางเรียงด้วยการเรียงลำดับที่เคยดูที่องค์ประกอบที่ไม่ใช่ศูนย์เท่านั้น

ฉันไม่เห็นฟังก์ชันพาร์ติชันในวิธี Array หรือ TypedArray แต่ฉันแทบจะไม่รู้จัก JavaScript ด้วย JIT ที่ดีการวนซ้ำไม่ควรแย่ไปกว่าวิธีการในตัว (โดยเฉพาะอย่างยิ่งเมื่อวิธีนั้นเกี่ยวข้องกับการเรียกกลับเช่น.filterและเว้นแต่ว่ามันจะใช้reallocภายใต้ประทุนเพื่อลดขนาด

ฉันใช้อาร์เรย์ปกติ.filter() ก่อนที่จะแปลงเป็น TypedArray หากอินพุตของคุณเป็น TypedArray อยู่แล้วคุณไม่มีปัญหานี้และกลยุทธ์นี้ก็น่าดึงดูดยิ่งขึ้น

เพียงแค่ปรับสภาพของฟังก์ชั่นการเปรียบเทียบของคุณเช่นนี้ -

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

ไม่เล่นรหัสกอล์ฟที่นี่:

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

อย่าเขียนการเรียงลำดับตัวเลขของคุณเองหากมีอยู่แล้ว สิ่งที่คุณต้องการจะทำคือสิ่งที่คุณพูดในชื่อ; เรียงลำดับตัวเลขจากมากไปน้อยยกเว้นเลขศูนย์เมื่อเริ่มต้น

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

อย่าเขียนโค้ดใด ๆ ที่คุณไม่จำเป็นต้อง; คุณอาจเข้าใจผิด

เลือกTypedArrayตามประเภทของตัวเลขที่คุณต้องการให้ Array จัดการ Float64 เป็นค่าเริ่มต้นที่ดีเนื่องจากรองรับหมายเลข JS ทั้งหมดปกติ

คุณสามารถทำสิ่งนี้ได้:

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)

หรือคุณสามารถทำสิ่งนี้:

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)