एक विशेषता द्वारा ऑब्जेक्ट्स की रूबी सरणी को सॉर्ट करना जो

Question

हो सकता है मेरे पास ऑब्जेक्ट्स की एक सरणी है जिसे मुझे एक स्थिति विशेषता द्वारा क्रमबद्ध करने की आवश्यकता है जो एक पूर्णांक या शून्य हो सकता है, और मुझे उन ऑब्जेक्ट्स की आवश्यकता है जिनके पास शून्य स्थिति है सरणी के अंत में हो। अब, मैं स्थिति को शून्य के बजाए कुछ मूल्य वापस करने के लिए मजबूर कर सकता हूं ताकि array.sort विफल न हो, लेकिन यदि मैं 0 को इस डिफ़ॉल्ट के रूप में उपयोग करता हूं, तो यह उन वस्तुओं को क्रम के सामने रखता है। इस तरह से करने का सबसे अच्छा तरीका क्या है? क्या मुझे सिर्फ कुछ हद तक नील मानों को कुछ हास्यास्पद उच्च संख्या में सेट करना चाहिए जो 'लगभग' हमेशा अंत में होने की गारंटी है? या क्या कोई अन्य तरीका है कि मैं array.sort विधि को सरणी के अंत में शून्य विशेषता ऑब्जेक्ट्स डालने का कारण बन सकता हूं? अब

class Parent 
    def sorted_children 
    children.sort{|a, b| a.position <=> b.position} 
    end 
end 

class Child 
    def position 
    category ? category.position : #what should the else be?? 
    end 
end 

, अगर मैं 1000000000 तरह 'शेष' कुछ करना है, तो यह सबसे अधिक संभावना वाला उन्हें सरणी के अंत में डाल दिया है, लेकिन यह है के रूप में मैं इस समाधान पसंद नहीं है: कोड इस तरह दिखता है मनमाने ढंग से

Answer 1

कैसे Child<=> परिभाषित करने में category के रूप में हमेशा एक category के साथ उन लोगों की तुलना में अधिक के बिना पर category.position अगर category मौजूद आधारित होना करने के बारे में है, और छँटाई आइटम?

class Child 
    # Not strictly necessary, but will define other comparisons based on <=> 
    include Comparable 
    def <=> other 
    return 0 if !category && !other.category 
    return 1 if !category 
    return -1 if !other.category 
    category.position <=> other.category.position 
    end 
end 

फिर Parent में आप सिर्फ children.sort कॉल कर सकते हैं।

Answer 2

मैं रूबी एक समय में नहीं किया है, लेकिन आप छंटाई से अशक्त की जाँच विभाजित सकता है (और सिर्फ बाल # स्थिति अशक्त लौटने की अनुमति देने):

def sorted_children 
    children.reject{|c| c.position.nil?}.sort_by(&:position) + 
    children.select{|c| c.position.nil?} 
end 

वैसे यह सबसे नहीं है कुशल समाधान, लेकिन इसमें कोई जादू संख्या नहीं है।

Answer 3

निष्पक्ष होने के लिए, मैं रूबी से बहुत परिचित नहीं हूं, इसलिए इसे कोड कोड के बजाए एल्गोरिदम विचार के रूप में अधिक ले जाएं ... और ऑपरेटर को फिर से लिखना चाहिए: ऑपरेटर जिसे रूबी के पास क्लीनर है।

तुम सिर्फ तुलना में शून्य के लिए जाँच नहीं कर सकते:

class Parent 
    def sorted_children 
    children.sort{|a,b|(a and b) ? a <=> b : (a ? -1 : 1) } 
    end 
end 

Glenra के कोड है, जो मेरा रूप में, लेकिन कोड के एक छोटे (और शायद पढ़ने में आसान) राशि में एक ही बात लागू करता है उपयोग करने के लिए संपादित किया गया ।

Answer 4

मैं आपके पिछले प्रकार nil आइटम को अंतिम बार रखने के लिए ट्विक कर दूंगा। इस तरह कुछ कोशिश करो।

foo = [nil, -3, 100, 4, 6, nil, 4, nil, 23] 

foo.sort { |a,b| a && b ? a <=> b : a ? -1 : 1 } 

=> [-3, 4, 4, 6, 23, 100, nil, nil, nil] 

का कहना है कि: अगर ए और बी दोनों गैर-शून्य उन्हें सामान्य रूप से सॉर्ट लेकिन अगर उनमें से एक नहीं के बराबर है, एक स्थिति है कि सॉर्ट करता है कि एक बड़ा वापस जाएँ।

Answer 5

मैं इस तरह चीजों के इन प्रकार संभाल:

children.sort_by {|child| [child.position ? 0 : 1,child.position || 0]} 

Answer 6

आप एक नया तुलना विधि को परिभाषित करते हुए अंतरिक्ष यान ऑपरेटर अधिभावी के बिना यह कर सकते हैं।

class Child 
    include Comparable 
    def compare_by_category(other) 
    return 0 if !category && !other.category 
    return 1 if !category 
    return -1 if !other.category 
    category.position <=> other.category.position 
    end 
end 

sort विधि एक ब्लॉक ले जा सकते हैं, ताकि आप तो तरह इस नई विधि का उपयोग कर सकते हैं: "? .nil"

children.sort {|a,b| a.compare_by_category(b) }