रूबी सॉर्टिंग में महारत: व्यावहारिक उदाहरणों के साथ सरणी और हैश तकनीकें

रूबी में सरणी को सॉर्ट करना आसान है!

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

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

रूबी के बिल्ट-इन सॉर्टिंग मेथड्स को समझना।

ये:

• sort
• sort_by
• sort!

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

यही आप इस लेख में खोजेंगे।

आप सरणी को सॉर्ट करने के विभिन्न तरीके सीखेंगे, sort मेथड से शुरू करके, फिर sort_by को उन्नत सॉर्टिंग (कई मूल्यों द्वारा) और अधिक के लिए देखेंगे।

चलिए करते हैं!

रूबी सॉर्ट और सॉर्ट! मेथड्स का उपयोग करना सीखें

सॉर्टिंग का सबसे बुनियादी रूप रूबी सॉर्ट मेथड द्वारा प्रदान किया जाता है, जिसे Enumerable मॉड्यूल द्वारा परिभाषित किया गया है।

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

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

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

सॉर्ट किए गए तत्वों की एक सरणी!

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

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

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

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 मेथड्स का उपयोग करके अपनी सरणियों और हैश को विभिन्न तरीकों से कैसे सॉर्ट करें। आपने प्रदर्शन अंतर और क्विकसॉर्ट एल्गोरिदम को लागू करने के तरीके के बारे में भी सीखा।

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

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

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