रूबी में सरणी और हैश को कैसे क्रमबद्ध करें (उदाहरण शामिल हैं)

रूबी में एक सरणी को छाँटना आसान है!

आपको कोई फैंसी एल्गोरिदम लिखने की आवश्यकता नहीं है मनचाहा परिणाम पाने के लिए।

फिर क्या चाहिए?

रूबी की अंतर्निहित छँटाई विधियों को समझना।

ये :

• क्रमबद्ध करें
• सॉर्ट_बाय
• क्रमबद्ध करें!

ये तरीके कैसे काम करते हैं और ये अलग क्यों हैं?

इस लेख में आप यही पाएंगे।

आप sort . से शुरू करके, किसी ऐरे को सॉर्ट करने के विभिन्न तरीकों के बारे में जानेंगे विधि, फिर sort_by . पर एक नज़र डालें उन्नत छँटाई के लिए (एकाधिक मानों द्वारा) और अधिक।

चलो यह करते हैं!

सॉर्ट और सॉर्ट करना सीखें! रूबी तरीके

छँटाई का सबसे बुनियादी रूप रूबी सॉर्ट विधि द्वारा प्रदान किया जाता है, जिसे एन्यूमरेबल मॉड्यूल द्वारा परिभाषित किया जाता है।

आइए एक उदाहरण देखें :

numbers = [5,3,2,1]

numbers.sort
# [1,2,3,5]

ध्यान दें कि sort परिणामों के साथ एक नई सरणी लौटाएगा।

क्रमबद्ध तत्वों की एक सरणी!

sort! . का उपयोग करके "इन-प्लेस" को सॉर्ट करना भी संभव है विधि।

इसका मतलब है कि मूल सरणी बदल जाएगी एक नया बनाने के बजाय, जो प्रदर्शन के लिए अच्छा हो सकता है।

सॉर्ट_बाय के साथ अनुकूलित सॉर्टिंग

sort_by के साथ विधि आप अधिक उन्नत और दिलचस्प छँटाई कर सकते हैं।

आप सक्षम होंगे :

• स्ट्रिंग लंबाई के आधार पर छाँटें
• स्ट्रिंग सामग्री के आधार पर छाँटें
• क्रमबद्ध करें कि कोई संख्या सम है या विषम है

आप इसे sort_by . के साथ कर सकते हैं विधि और एक रूबी ब्लॉक।

उदाहरण के लिए :

strings = %w(foo test blog a)

strings.sort_by(&:length)

# ["a", "foo", "test", "blog"]

यह कैसे काम करता है?

खैर, sort_by विधि एक संख्यात्मक मान की अपेक्षा करती है, इसलिए length काम करता है।

यदि आप इसे समझते हैं, तो आप इस पद्धति का उपयोग अच्छी चीजों को करने के लिए कर सकते हैं, जैसे कि बड़े अक्षर से शुरू होने वाले शब्दों को छांटना और बाकी सब कुछ जगह पर छोड़ देना।

इसे पसंद करें :

def sort_by_capital_word(text)
  text
    .split
    .sort_by { |w| w[0].match?(/[A-Z]/) ? 0 : 1 }
    .join(" ")
end

sort_by_capital_word("calendar Cat tap Lamp")

# "Cat Lamp calendar tap"

नियमित sort . का उपयोग करके कस्टम सॉर्टिंग करना भी संभव है एक ब्लॉक के साथ विधि।

यहां एक उदाहरण दिया गया है :

strings = %w(foo test blog a)

strings.sort { |a,b| a.length <=> b.length }

# ["a", "foo", "test", "blog"]

नोट :यह <=> प्रतीक को "स्पेसशिप ऑपरेटर" कहा जाता है और यह एक ऐसी विधि है जिसे आप अपनी कक्षा में लागू कर सकते हैं। इसे 1 (इससे बड़ा), 0 (बराबर) या -1 (इससे कम) वापस करना चाहिए।

सामान्य तौर पर, मैं sort_by . को प्राथमिकता देता हूं विधि क्योंकि इरादा अधिक स्पष्ट है, इसे पढ़ना आसान है और यह थोड़ा तेज़ भी है।

उलटे क्रम में क्रमित करें

उल्टे क्रम में लगाने के बारे में क्या?

आप reverse . का उपयोग कर सकते हैं छँटाई के बाद विधि, या आप एक ब्लॉक का उपयोग कर सकते हैं और जिस चीज़ को आप छाँट रहे हैं उसके सामने एक ऋण चिह्न लगा सकते हैं।

मैं आपको एक उदाहरण दिखाता हूं :

strings = %w(foo test blog a)

strings.sort_by { |str| -str.length }

# ["blog", "test", "foo", "a"]

फैंसी नहीं है, लेकिन यह काम करता है!

अल्फ़ान्यूमेरिक सॉर्टिंग

मान लें कि आप संख्याओं वाली स्ट्रिंग की सूची को संख्यात्मक रूप से क्रमबद्ध करना चाहते हैं।

इसे पसंद करें :

music = %w(21.mp3 10.mp3 5.mp3 40.mp3)

डिफ़ॉल्ट रूप से, आप इस सूची को अपनी इच्छानुसार क्रमबद्ध नहीं कर पाएंगे।

उदाहरण :

music.sort

# ["10.mp3", "21.mp3", "40.mp3", "5.mp3"]

लेकिन आप sort_by . का उपयोग करके इसे ठीक कर सकते हैं :

music.sort_by { |s| s.scan(/\d+/).first.to_i }

# ["5.mp3", "10.mp3", "21.mp3", "40.mp3"]

मैंने रेगुलर एक्सप्रेशन का इस्तेमाल किया (\d+ ) संख्याओं का मिलान करने के लिए, फिर पहला नंबर प्राप्त करें (first ) और इसे एक पूर्णांक वस्तु में परिवर्तित करें (to_i )।

रूबी में हैश को कैसे सॉर्ट करें

आप सरणियों को छाँटने तक सीमित नहीं हैं, आप हैश भी छाँट सकते हैं।

उदाहरण :

hash = {coconut: 200, orange: 50, bacon: 100}

hash.sort_by(&:last)

# [[:orange, 50], [:bacon, 100], [:coconut, 200]]

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

हैश को सॉर्ट करते समय आपको एक बहु-आयामी सरणी मिलती है।

इसे वापस हैश में बदलने के लिए आप Array#to_h विधि का उपयोग कर सकते हैं।

एकाधिक मानों के आधार पर क्रमित करना

हो सकता है कि आप किसी चीज़ को कई विशेषताओं के आधार पर क्रमित करना चाहें, जिसका अर्थ है कि आप पहले दिनांक के अनुसार क्रमित करते हैं (उदाहरण के लिए), लेकिन क्योंकि आपके पास एक ही तिथि के साथ कई चीज़ें हैं तो आपके पास एक टाई है।

टाई को तोड़ने के लिए आप एक सेकेंडरी एट्रिब्यूट का उपयोग कर सकते हैं।

उदाहरण :

Event = Struct.new(:name, :date)
events = []

events << Event.new("book sale", Time.now)
events << Event.new("course sale", Time.now)
events << Event.new("new subscriber", Time.now)
events << Event.new("course sale", Time.now + 1.day)

events.sort_by { |event| [event.date, event.name] }

यहाँ कुंजी sort_by . के अंदर की सरणी है ब्लॉक करें।

जहां आप प्राथमिक सॉर्टिंग विशेषता को सरणी के पहले तत्व के रूप में सेट करते हैं (event.date ) और फिर द्वितीयक टाई-ब्रेकर विशेषता (event.name )।

क्विकसॉर्ट इंप्लीमेंटेशन

केवल मनोरंजन के लिए आइए हम अपनी स्वयं की छँटाई विधि लागू करें। यह अंतर्निहित सॉर्ट विधियों की तुलना में धीमा होने वाला है, लेकिन यदि आप कंप्यूटर विज्ञान पसंद करते हैं तो यह अभी भी एक दिलचस्प अभ्यास है।

def quick_sort(list)
  return [] if list.empty?

  groups = list.group_by { |n| n <=> list.first }

  less_than    = groups[-1] || []
  first        = groups[0]  || []
  greater_than = groups[1]  || []

  quick_sort(less_than) + first + quick_sort(greater_than)
end

p quick_sort [3, 7, 2, 1, 8, 12]

# [1, 2, 3, 7, 8, 12]

त्वरित क्रम का विचार यादृच्छिक रूप से एक संख्या चुनना है और फिर उस सूची को विभाजित करना है जिसे हम दो समूहों में क्रमबद्ध कर रहे हैं।

एक समूह चुनी हुई संख्या से छोटी संख्या है और दूसरा समूह चुनी गई संख्या से बड़ी संख्या है।

फिर हम इस ऑपरेशन को तब तक दोहराते हैं जब तक कि सूची क्रमबद्ध न हो जाए।

बेंचमार्क

आइए देखें कि प्रदर्शन के मामले में ये सभी छँटाई के तरीके एक-दूसरे से कैसे तुलना करते हैं।

रूबी 2.4.0 :

  sort!:                1405.8 i/s
  sort:                 1377.6 i/s - same-ish: difference falls within error
  sort_by reverse:      196.6  i/s - 7.15x  slower
  sort_by:              183.7  i/s - 7.65x  slower
  sort_by minus:        172.3  i/s - 8.16x  slower
  sort with block:      164.1  i/s - 8.57x  slower

जैसा कि आप देख सकते हैं, नियमित sort विधि sort_by . से बहुत तेज़ है , लेकिन यह उतना लचीला नहीं है जब तक आप किसी ब्लॉक का उपयोग नहीं करते।

वीडियो

सारांश

आपने sort का उपयोग करना सीख लिया है और sort_by अपने सरणियों और हैश को अलग-अलग तरीकों से सॉर्ट करने के तरीके। आपने प्रदर्शन अंतर और क्विकसॉर्ट एल्गोरिथम को लागू करने के तरीके के बारे में भी सीखा है।

यहां बताया गया है कि आपको क्या याद रखना चाहिए :

• आप sort का उपयोग कर सकते हैं किसी सरणी, हैश, या किसी अन्य संख्यात्मक वस्तु पर विधि और आपको डिफ़ॉल्ट सॉर्टिंग व्यवहार मिलेगा (<=> के आधार पर क्रमबद्ध करें) ऑपरेटर)
• आप sort का उपयोग कर सकते हैं एक ब्लॉक और दो ब्लॉक तर्कों के साथ, यह परिभाषित करने के लिए कि एक वस्तु दूसरे से कैसे भिन्न है (ब्लॉक को 1, 0, या -1 वापस करना चाहिए)
• आप sort_by का उपयोग कर सकते हैं एक ब्लॉक, और एक तर्क के साथ, प्रत्येक ऑब्जेक्ट के लिए एक विशेषता को परिभाषित करने के लिए जिसे सॉर्टिंग (सरणी लंबाई, ऑब्जेक्ट विशेषता, अनुक्रमणिका, आदि) के आधार के रूप में उपयोग किया जा रहा है। ब्लॉक को एक पूर्णांक मान लौटाना चाहिए जो क्रमबद्ध सरणी में ऑब्जेक्ट की स्थिति निर्धारित करता है।

इस पोस्ट को शेयर करना न भूलें ताकि और लोग सीख सकें।