सरणी में रूबी सबसे लंबा शब्द

Question

मैंने इस विधि को एक सरणी में सबसे लंबा शब्द खोजने के लिए बनाया है, लेकिन मुझे आश्चर्य है कि ऐसा करने का एक बेहतर तरीका है या नहीं। मैं रूबी के लिए काफी नया हूं, और इसे inject विधि सीखने के लिए एक अभ्यास के रूप में किया।

यह या तो सरणी में सबसे लंबा शब्द या बराबर सबसे लंबे शब्दों की सरणी देता है।

class Array 
    def longest_word 
    # Convert array elements to strings in the event that they're not. 
    test_array = self.collect { |e| e.to_s } 
    test_array.inject() do |word, comparison| 
     if word.kind_of?(Array) then 
     if word[0].length == comparison.length then 
      word << comparison 
     else 
      word[0].length > comparison.length ? word : comparison 
     end 
     else 
     # If words are equal, they are pushed into an array 
     if word.length == comparison.length then 
      the_words = Array.new 
      the_words << word 
      the_words << comparison 
     else 
      word.length > comparison.length ? word : comparison 
     end 
     end 
    end 
    end 
end 

Answer 1

मैं क्या करना होगा

class Array 
    def longest_word 
    group_by(&:size).max.last 
    end 
end 

Answer 2

रूबी के पास अधिकतम मूल्य वाले किसी सूची में तत्व लौटने के लिए एक मानक विधि है।

anArray.max{|a, b| a.length <=> b.length} 

या आप अधिकतम लंबाई के साथ सभी तत्वों को प्राप्त करने के लिए max_by विधि

anArray.max_by(&:length) 

उपयोग कर सकते हैं

max_length = anArray.max_by(&:length).length 
all_with_max_length = anArray.find_all{|x| x.length = max_length} 

Answer 3

एक दो लाइनर:

vc = ['asd','s','1234','1235'].sort{|a,b| b.size <=> a.size} 
vc.delete_if{|a| a.size < vc.first.size} 


#Output 
["1235", "1234"] 

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

test_array.inject{ |ret,word| 
    ret = [ret] unless ret.kind_of?(Array) 

    ret << word if word.size == ret.first.size 
    ret = [word] if word.size > ret.first.size 
    ret 
} 

Answer 4

module Enumerable 
    def longest_word 
    (strings = map(&:to_s)). 
     zip(strings.map(&:length)). 
     inject([[''],0]) {|(wws, ll), (w, l)| 
     case l <=> ll 
     when -1 then [wws, ll] 
     when 1 then [[w], l] 
     else   [wws + [w], ll] 
     end 
     }.first 
    end 
end 

यह विधि केवल सामान्य Enumerable तरीकों पर निर्भर करता है, वहाँ कुछ भी नहीं Array इसके बारे में विशिष्ट है, इसलिए हम इसे खींच सकते हैं Enumerable मॉड्यूल, जहां यह भी Set या Enumerator रों लिए उपलब्ध हो जाएगा में, न केवल Array एस।

Answer 5

यहाँ inject का उपयोग कर एक (एक खाली सरणी के लिए काम नहीं करता है) है:

words.inject(['']){|a,w| 
    case w.length <=> a.last.length 
    when -1 
    a 
    when 0 
    a << w 
    when 1 
    [w] 
    end 
} 

जो उन लोगों के लिए

words.inject(['']){|a,w| 
    [a + [w], [w], a][w.length <=> a.last.length] 
} 

को छोटा किया जा सकता गोल्फ पसंद है।

Answer 6

यह समाधान, एक सरणी में सबसे लंबे समय तक तार जमा करने के लिए सुई विधि का उपयोग करता है तो उच्चतम लंबाई के साथ लोगों को चुनता है।

जानवरों = [ "माउस", "बिल्ली", "पक्षी", "भालू", "मूस"]

animals.inject (Hash.new {| ज, कश्मीर | ज [k] = [ ]}) {| एसीसी, ई | एसीसी [e.size] < < ई; एसीसी} .sort.last [1]

यह रिटर्न: [ "माउस" "माउस"]