मैं पहले निर्दिष्ट तत्वों को छोड़ने वाले सरणी के माध्यम से कैसे लूप कर सकता हूं? - रूबी, सरणी

क्या दो सरणियों के माध्यम से लूप करने का एक तरीका है और क्या वे हर बार एक निश्चित तत्व का उल्लेख करते हैं? उदाहरण के लिए:

first_array = ["a", "b", "c", "d"]
second_array = ["e", "f", "g", "h"]

first_array.each |item| puts item.get(second_array)

परिणाम कुछ इस तरह दिखेंगे:

a would work with e
b would work with f
c would work with g
d would work with h

मैं इसे बनाने की कोशिश कर रहा हूं ताकि जब एक चर first_array के साथ काम करने के लिए पारित किया है second_array, यह अगले चर में ले जाता है second_array, पहले उपयोग किए गए चर को लंघन।

उत्तर:

अर्थात् zip.

first_array.zip(second_array){|e1, e2| ...}

आप ऐसा कुछ कर सकते हैं:

first_array.each_with_index { |v, i| puts "#{v} can work with #{second_array[i]}" }
# a would work with e
# b would work with f
# c would work with g
# d would work with h

यह मानते हुए, कि आपके उदाहरण में, दो सरणियाँ समान आकार हैं, आप उपयोग कर सकते हैं सरणी # पक्षांतरित:

a1 = %w{a b c d}
#=> ["a", "b", "c", "d"]
a2 = %w{e f g h}
#=> ["e", "f", "g", "h"]
[a1,a2].transpose { |s1,s2| puts "#{s1} and #{s2}" }
#-> a and e
#   b and f
#   c and g
#   d and h

जब भी आप किसी ऐरे से काम कर रहे हों a समान आकार के सरणियों (यहां) [a1,a2]) और पर काम करना चाहते हैं [a[0][i],a[1][i],..] प्रत्येक के लिए i, आपके पास हमेशा उपयोग करने का विकल्प होता है transpose या सरणी # ज़िप। एक मायने में, वे हैं यिन और यांग.

आप केवल सूचकांकों का उपयोग कर सकते हैं:

a1.each_index { |i] puts "#{a1[i]} and #{a2[i]}" }

दिया गया दूसरा सरणी हमेशा कम से कम है जब तक कि पहले

first_array.each_with_index |item,index| do
puts "#{item} would work with #{second_array[index]}"
end