डेवलपर्स के लिए 7 अवश्य देखने योग्य रूबी कोड उदाहरण

नई रूबी ट्रिक्स, पैटर्न और मेथड्स सीखने का एक तरीका है दूसरों द्वारा लिखे गए कोड को पढ़ना।

लेकिन आप पढ़ने लायक दिलचस्प कोड कहां ढूंढते हैं?

हमारे पास कई ओपन सोर्स प्रोजेक्ट्स हैं, और कोडिंग चैलेंज साइट्स जो आपको अन्य डेवलपर्स के समाधान देखने की अनुमति देती हैं एक बार जब आप अपना सबमिट कर देते हैं।

इस लेख में:

मैंने 7 उदाहरण संकलित किए हैं जो मुझे लगता है कि आपको पसंद आएंगे।

मैं प्रत्येक उदाहरण पर कुछ कमेंट्री भी देने जा रहा हूं ताकि आप इससे अधिकतम लाभ उठा सकें।

दो संख्याओं का योग

इस उदाहरण में हम यह पता लगाना चाहते हैं कि दी गई यूनिक संख्याओं की एक ऐरे दी गई है, क्या दो संख्याओं का एक संयोजन है जो एक टार्गेट नंबर तक जोड़ता है।

कोड:

def sum_eq_n?(arr, n)
  return true if arr.empty? && n == 0
  arr.product(arr).reject { |a,b| a == b }.any? { |a,b| a + b == n }
end

यह दिलचस्प है क्योंकि मैं यहाँ product मेथड का उपयोग कर रहा हूँ।

जब आप इस मेथड का उपयोग करते हैं तो यह ऐरे A में सभी मानों को ऐरे B में सभी मानों के साथ संयोजित करने वाले लूप के अंदर एक लूप की तरह होता है।

काउंटिंग, मैपिंग और फाइंडिंग

मान लें कि आप एक अंकगणितीय अनुक्रम में लापता संख्या ढूंढना चाहते हैं, जैसे (2,4,6,10)।

हम एक रणनीति का उपयोग कर सकते हैं जहां हम संख्याओं के बीच का अंतर निकालते हैं।

[2, 2, 4]

यहां हमारा लक्ष्य यह पता लगाना है कि अनुक्रम क्या है।

क्या यह बढ़ रहा है या घट रहा है?

कितना?

यह कोड अनुक्रम को प्रकट करता है:

differences = [2, 2, 4]
differences.max_by { |n| differences.count(n) } # 2
# यह अनुक्रम में संख्याओं के बीच की वृद्धि है

एक बार जब हम अनुक्रम जान लेते हैं तो हम लापता संख्या को ढूंढने के लिए सभी संख्याओं की तुलना कर सकते हैं।

यहाँ कोड है:

def find_missing(sequence)
  consecutive = sequence.each_cons(2)
  differences = consecutive.map { |a,b| b - a }
  sequence = differences.max_by { |n| differences.count(n) }
  missing_between = consecutive.find { |a,b| (b - a) != sequence }
  missing_between.first + sequence
end
find_missing([2,4,6,10]) # 8

यहां गिनें कि हम कितनी रूबी मेथड्स का उपयोग कर रहे हैं जो हमारे लिए कठिन काम करती हैं 🙂

रेगुलर एक्सप्रेशन उदाहरण

यदि आप स्ट्रिंग्स के साथ काम कर रहे हैं और पैटर्न ढूंढना चाहते हैं तो रेगुलर एक्सप्रेशंस आपके दोस्त हैं।

वे थोड़े ट्रिकी हो सकते हैं, लेकिन अभ्यास से महारत हासिल होती है!

अब:

मान लें कि हम यह पता लगाना चाहते हैं कि दी गई स्ट्रिंग VOWEL से NON-VOWEL कैरेक्टर्स के पैटर्न का पालन करती है या नहीं।

इस तरह:

"ateciyu"

तब हम इसे समझने के लिए match? मेथड के साथ एक रेगुलर एक्सप्रेशन का उपयोग कर सकते हैं।

यहाँ कोड उदाहरण है:

def alternating_characters?(s)
  type = [/[aeiou]/, /[^aeiou]/].cycle
  if s.start_with?(/[^aeiou]/)
    type.next
  end
  s.chars.all? { |ch| ch.match?(type.next) }
end
alternating_characters?("ateciyu") # true

कुछ चीजें नोट करें:

1. हम cycle मेथड का उपयोग करते हैं ताकि हम VOWEL रेगेक्स और NON-VOWEL रेगेक्स के बीच स्विच करते रहें।
2. हम chars के साथ स्ट्रिंग को कैरेक्टर्स की ऐरे में बदलते हैं ताकि हम all? मेथड का उपयोग कर सकें।

रिकर्सन और स्टैक उदाहरण

रिकर्सन तब होता है जब एक मेथड समाधान की दिशा में प्रगति करने के तरीके के रूप में खुद को कई बार कॉल करता है।

कई दिलचस्प समस्याओं को रिकर्सन से हल किया जा सकता है।

लेकिन चूंकि रिकर्सन की अपनी सीमाएं हैं, आप इसके बजाय एक स्टैक डेटा संरचना का उपयोग कर सकते हैं।

अब:

आइए एक उदाहरण देखें जहां हम दी गई ऐरे का "पावर सेट" ढूंढना चाहते हैं। पावर सेट ऐरे से बनाए जा सकने वाले सभी सबसेट्स का एक सेट है।

रिकर्सन के साथ एक उदाहरण यहाँ है:

def get_numbers(list, index = 0, taken = [])
  return [taken] if index == list.size
  get_numbers(list, index+1, taken) + get_numbers(list, index+1, taken + [list[index]])
end
get_numbers([1,2,3])

स्टैक का उपयोग करके उसी समस्या का समाधान यहाँ है:

def get_numbers_stack(list)
  stack = [[0, []]]
  output = []
  until stack.empty?
    index, taken = stack.pop
    next output << taken if index == list.size
    stack.unshift [index + 1, taken]
    stack.unshift [index + 1, taken + [list[index]]]
  end
  output
end

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

हम दोनों परिणामों को आजमाने के लिए शाखा बनाते हैं ताकि हम सभी संभावित संयोजन उत्पन्न कर सकें।

एक पेड़ की कल्पना करें जहां प्रत्येक पत्ती समाधानों में से एक है।

कुछ चीजें नोट करने योग्य:

1. रिकर्सन समाधान छोटा है
2. एल्गोरिदम का वास्तविक "प्रगति करना" भाग (index + 1) लगभग समान है
3. हम जिस स्टैक का उपयोग कर रहे हैं वह सिर्फ एक ऐरे है क्योंकि रूबी में Stack क्लास नहीं है

मेथड चेनिंग उदाहरण

यह मेरा पसंदीदा उदाहरण है क्योंकि यह दिखाता है कि रूबी कितनी शक्तिशाली है।

मेथड्स को संयोजित करने से आप एक मेथड द्वारा उत्पादित आउटपुट ले सकते हैं और इसे दूसरे में पास कर सकते हैं।

बस एक फैक्ट्री प्रोडक्शन लाइन की तरह!

आप कुछ कच्चे माल (इनपुट) से शुरू करते हैं, फिर इन मेथड्स को कॉल करने की प्रक्रिया के माध्यम से, आप धीरे-धीरे कच्चे माल को वांछित परिणाम में बदल देते हैं।

यहाँ एक उदाहरण है:

def longest_repetition(string)
  max = string
    .chars
    .chunk(&:itself)
    .map(&:last)
    .max_by(&:size)
  max ? [max[0], max.size] : ["", 0]
end
longest_repetition("aaabb") # ["a", 3]

दी गई स्ट्रिंग को देखते हुए, यह कोड सबसे लंबे दोहराए गए कैरेक्टर को ढूंढेगा।

नोट:

• यह कोड पठनीयता को अधिकतम करने के लिए कैसे फॉर्मेट किया गया है
• Symbol#to_proc पैटर्न का उपयोग (&:size)

वैसे, इसे "डेमेटर के नियम" के साथ भ्रमित न करें।

वह "नियम" किसी अन्य ऑब्जेक्ट के इंटरनल्स तक पहुंचने के बारे में है।

यहां हम केवल ऑब्जेक्ट्स को ट्रांसफॉर्म कर रहे हैं।

With Index उदाहरण

क्या आप आइटम्स के संग्रह पर पुनरावृति करते समय वर्तमान इंडेक्स रखना चाहेंगे?

आप with_index मेथड का उपयोग कर सकते हैं।

यहाँ एक उदाहरण है:

def reverse_alternate(string)
  string.gsub(/[^\s]+/).with_index { |w, idx| idx.even? ? w : w.reverse }
end
reverse_alternate("Apples Are Good") # "Apples erA Good"

नोटिस करें:

• हम वर्तमान शब्द को उल्टा करना है या नहीं यह पता लगाने के लिए with_index और even? को संयोजित करते हैं
• ब्लॉक के बिना Gsub एक Enumerator ऑब्जेक्ट लौटाता है, जो आपको इसे अन्य मेथड्स के साथ चेन करने की अनुमति देता है

Each With Object उदाहरण

एक और दिलचस्प मेथड है each_with_object, और इसका दोस्त with_object।

आप इन दो मेथड्स का उपयोग तब कर सकते हैं जब आपको परिणामों को रखने के लिए एक ऑब्जेक्ट की आवश्यकता होती है।

यहाँ एक उदाहरण है:

def clean_string(str)
  str
    .chars
    .each_with_object([]) { |ch, obj| ch == "#" ? obj.pop : obj << ch }
    .join
end
clean_string("aaa#b")

इस उदाहरण में, जब हमें # सिंबल मिलता है तो हम अंतिम कैरेक्टर को हटाना चाहते हैं।

नोटिस करें:

• each_with_object एक आर्गुमेंट लेता है, जो वह ऑब्जेक्ट है जिसके साथ हम शुरू करना चाहते हैं। यह आर्गुमेंट दूसरा ब्लॉक पैरामीटर बन जाता है।
• हम स्ट्रिंग को कैरेक्टर्स की ऐरे में बदल रहे हैं (chars) और जब हम काम पूरा कर लेते हैं तो वापस स्ट्रिंग में (join)।
• हम यह तय करने के लिए टर्नरी ऑपरेटर का उपयोग कर रहे हैं कि क्या करना है, इससे कोड छोटा होता है।

सारांश

इस लेख में, आपने मेरी कमेंट्री और व्याख्याओं के साथ कुछ दिलचस्प कोड उदाहरण देखे हैं जो आपको बेहतर रूबी कोड लिखने में मदद करेंगे।

इस लेख को शेयर करना न भूलें ताकि अधिक लोग इसका आनंद ले सकें।

पढ़ने के लिए धन्यवाद!