बूलियन द्वारा संख्या रूबी और संख्या

Question

मैं रुबी 1.8.7 का उपयोग कर रहा हूं। मेरे पास हैश की निम्न सरणी है। मुझे पहले बूलियन मान द्वारा क्रमबद्ध करने की आवश्यकता है, लेकिन उन परिणामों को मूल क्रम में भी आदेश दिया जाना चाहिए। मुझे मूल रूप से सरणी के शीर्ष पर सभी सच्चे हैंश को स्थानांतरित करने की आवश्यकता है लेकिन मूल क्रम को बनाए रखना है।

किसी भी मदद की सराहना की जाएगी!

array = [{:id => 1, :accepts => false}, 
     {:id => 2, :accepts => false}, 
     {:id => 3, :accepts => true}, 
     {:id => 4, :accepts => false}, 
     {:id => 5, :accepts => true}] 

sorted = array.sort do |x, y| 
    if x[:accepts] == y[:accepts] 
    0 
    elsif x[:accepts] == true 
    -1 
    elsif x[:accepts] == false 
    1 
    end 
end 

इस तरह है कि मैं पैदावार है:

5 - सच
3 - सच
2 - झूठी
4 - झूठी
1 - झूठी उपज के लिए

मैं इसे की जरूरत है :

3 - सत्य
5 - tr ue
1 - झूठी
2 - झूठी
4 - झूठी

Answer 1

यह काम करता है:

array.sort{|a,b| (a[:accepts] == b[:accepts]) ? ((a[:id] < b[:id]) ? -1 : 1) : (a[:accepts] ? -1 : 1)} 

Answer 2

array = [{:id => 1, :accepts => false}, 
     {:id => 2, :accepts => false}, 
     {:id => 3, :accepts => true}, 
     {:id => 4, :accepts => false}, 
     {:id => 5, :accepts => true}] 

sorted = array.sort do |x, y| 
    if x[:accepts]^y[:accepts] 
     x[:accepts] ? -1 : 1 
    else 
     x[:id] <=> y[:id] 
    end 
end 

puts sorted 

या ^ के बजाय !=, यदि आप चाहें तो।

Answer 3

आप इस प्रकार :id कुंजी पर एक अतिरिक्त जांच जोड़ सकता है अगर :accepts बराबर है,:

array = [{:id => 1, :accepts => false}, 
    {:id => 2, :accepts => false}, 
    {:id => 3, :accepts => true}, 
    {:id => 4, :accepts => false}, 
    {:id => 5, :accepts => true}] 

sorted = array.sort do |x, y| 
    if x[:accepts] == y[:accepts] 
    if x[:id] == y[:id] 
     0 
    elsif x[:id] > y[:id] 
     1 
    elsif x[:id] < y[:id] 
     -1 
    end 
  elsif x[:accepts] == true 
    -1 
  elsif x[:accepts] == false 
    1 
  end 
end 

Answer 4

a.sort_by { |x| (x[:accepts] ? 0 : 99999) + x[:id] } 

अद्यतन: ठीक है, जाहिर है, इसके लिए x[:id].respond_to? "+" की आवश्यकता है और इसके अतिरिक्त स्थिरांक के सापेक्ष इसकी सीमा पर प्रतिबंध हैं।

हालांकि, यह सबसे छोटा और शायद सबसे तेज़ उत्तर है, अगर यह स्पष्ट रूप से सबसे संदिग्ध भी है।

वास्तव में महत्वपूर्ण सबक यह है कि यह दर्शाता है कि Array (या जो कुछ भी) से परे देखना चाहिए और में Enumerable देखें। ये प्रश्न और उनके दर्शक अक्सर "" के उत्तर के बाद अक्सर रूबी के बारे में मुझे क्या सीखना चाहिए, मुझे संदेह है कि अन्य तरीके "हैं।

इस सुलझाने के लिए एक अच्छा तरीका है (वैसे यह संदेहास्पद है) इस उत्तर #sort_by और बस डॉक्स #sort_by के लिए खोजने (यह सरणी में नहीं है) अभी शुरुआत करने के लिए एक छोटी लेकिन महत्वपूर्ण सबक सिखा देगा पता चलता है या न करें।

Answer 5

इन चीजों के लिए sort_by का उपयोग करें, sort नहीं!

array.sort_by {|h| [h[:accepts] ? 0 : 1,h[:id]]} 

Answer 6

ऐसा इसलिए है क्योंकि रूबी 1.8 में सॉर्टिंग।7 स्थिर नहीं है

• http://redmine.ruby-lang.org/issues/show/1089
• http://en.wikipedia.org/wiki/Stable_sort#Stability

सभी आप अपनी तरह ब्लॉक करने की जरूरत है 0 वापस नहीं:

sorted = array.sort do |x, y| 
    if x[:accepts] == y[:accepts] 
    x[:id] <=> y[:id] # not 0 
    elsif x[:accepts] 
    -1 
    else 
    1 
    end 
end 

(कोई स्पष्ट रूप से एक बूलियन तुलना करने के लिए की जरूरत true और false)

Answer 7

ठीक है, आपके प्रश्न से मैं आपको वास्तव में :accepts मान से परिणामों को समूहित करना चाहता हूं और दोनों परिणाम एक सरणी में वापस सेट करना चाहता हूं। यह करने के लिए मेरे समाधान किया गया है जाएगा:

array.select {|where| where[:accepts] } | array.reject {|where| where[:accepts] } 
# => [{:accepts=>true, :id=>3}, 
#  {:accepts=>true, :id=>5}, 
#  {:accepts=>false, :id=>1}, 
#  {:accepts=>false, :id=>2}, 
#  {:accepts=>false, :id=>4}] 

यह :id कुंजी पर किसी भी प्रकार जिसका अर्थ बिना मूल आदेश को बनाए रखेगा। इसका मतलब है कि आपको ऑर्डर को सुरक्षित रखने के लिए एक सहायक कुंजी की आवश्यकता नहीं होगी, और आप पहुंचे गए डेटा के बावजूद परिणाम पर ऑर्डर को सुरक्षित रख सकते हैं।

यह भी उपयोगी हो सकता है (और शायद वास्तव में आप आगे के मूल्यांकन के लिए क्या जरूरत है):

array.group_by {|where| where[:accepts] } 
# => {false=>[{:accepts=>false, :id=>1}, 
#    {:accepts=>false, :id=>2}, 
#    {:accepts=>false, :id=>4}], 
#  true=>[{:accepts=>true, :id=>3}, 
#    {:accepts=>true, :id=>5}]} 

फिर से, कोई कृत्रिम प्रकार शामिल ... group_by 1.8.7 में नया है।

पीएस: यदि आप नहीं चाहते हैं कि पहला कोड स्निपेट आपके सरणी से डुप्लीकेट हटा दें, बार ऑपरेटर को प्लस ऑपरेटर के साथ प्रतिस्थापित करें। "|" theory of sets (संघ) के अनुसार दो सेट विलय करते हैं जबकि "+" दो सेटों को जोड़ता है (परिणाम वास्तव में एक सेट नहीं बल्कि एक सादा सरणी है)।