javascript - अवरोही क्रम में संख्याओं को क्रमबद्ध करना लेकिन शुरुआत में `0` के साथ




arrays sorting (7)

आप b के डेल्टा और a (अवरोही सॉर्टिंग के लिए) को क्रमबद्ध कर सकते हैं और शून्य जैसे Number.MAX_VALUE मूल्यों के लिए 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);

मेरे पास जावास्क्रिप्ट में एक चुनौती है कि मैं कुछ समय के लिए पहले ही पता लगाने की कोशिश कर रहा हूं।

इस सरणी पर विचार करें:

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]

किसी को भी इस पर हल करने के लिए कोई सुझाव है?


आप इसे इस तरह से कर सकते हैं:

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)


दूसरी बार सरणी को छाँटने के साथ इसे आज़माएँ:

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

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

बस अपने तुलनात्मक फ़ंक्शन की स्थिति को इस तरह संशोधित करें -

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

console.log(arr);


यदि यह पहले से मौजूद है तो अपनी खुद की सांख्यिक छँटाई न लिखें। आप जो करना चाहते हैं वही आप शीर्षक में कहते हैं; प्रारंभ में शून्य को छोड़कर अवरोही क्रम में क्रमबद्ध संख्याएँ।

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

ऐसा कोई कोड न लिखें, जिसकी आपको आवश्यकता न हो; आपको यह गलत लग सकता है।

टाइप करें कि आप किस प्रकार की संख्या को संभालना चाहते हैं, उसके आधार पर टाइप करें। फ्लोट64 एक अच्छा डिफ़ॉल्ट है क्योंकि यह सभी सामान्य जेएस नंबरों को संभालता है।


यहां कोड गोल्फ नहीं खेलना:

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


जैसा कि mdn डॉक्स कहते हैं:

यदि ए और बी दो तत्वों की तुलना की जा रही है, तो:

अगर compareFunction(a, b) 0 से कम रिटर्न देता है, तो b तुलना में कम इंडेक्स को compareFunction(a, b) यानी पहले आता है)।

यदि compareFunction(a, b) रिटर्न 0 है, तो ए और बी को एक दूसरे के संबंध में अपरिवर्तित छोड़ दें, लेकिन सभी विभिन्न तत्वों के संबंध में क्रमबद्ध हैं। नोट: ECMAscript मानक इस व्यवहार की गारंटी नहीं देता है, इस प्रकार, सभी ब्राउज़र (जैसे मोज़िला संस्करण कम से कम 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);






sorting