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 . का उपयोग कर रहा हूं विधि यहाँ।

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

गिनना, मैप करना और खोजना

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

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

[2, 2, 4]

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

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

कितने से?

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

differences = [2, 2, 4]

differences.max_by { |n| differences.count(n) }
# 2
# This is the increase between numbers in the sequence

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

यह रहा कोड :

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 का उपयोग करते हैं विधि ताकि हम स्वर रेगेक्स और गैर-स्वर रेगेक्स के बीच स्विच करना जारी रख सकें।
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. एल्गोरिदम का वास्तविक "प्रगति करना" भाग (इंडेक्स + 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 . का उपयोग कर सकते हैं विधि।

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

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 , और उसका मित्र 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 एक तर्क लेता है, जिस वस्तु से हम शुरुआत करना चाहते हैं। यह तर्क दूसरा ब्लॉक पैरामीटर बन जाता है।
• हम स्ट्रिंग को वर्णों की एक सरणी में बदल रहे हैं (char ) और फिर वापस एक स्ट्रिंग पर जब हम कर रहे हैं (join )।
• हम यह तय करने के लिए एक टर्नरी ऑपरेटर का उपयोग कर रहे हैं कि क्या करना है, इससे कोड छोटा हो जाता है।

सारांश

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

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

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