रूबी में सूचकांक के साथ नक्शा कैसे करें?

Question

परिवर्तित करने का सबसे आसान तरीका क्या है

[x1, x2, x3, ... , xN]

सेवा

[[x1, 2], [x2, 3], [x3, 4], ... , [xN, N+1]]

Answer 1

यदि आप रूबी 1.8.7 या 1.9 का उपयोग कर रहे हैं, तो आप इस तथ्य का उपयोग कर सकते हैं कि जैसे कि इटरेटर विधियाँ each_with_index, जब बिना किसी ब्लॉक के Enumeratorकॉल की जाती हैं, तो एक ऑब्जेक्ट लौटाते हैं , जिस पर आप Enumerableविधियों को कॉल कर सकते हैं map। तो आप कर सकते हैं:

arr.each_with_index.map { |x,i| [x, i+2] }

1.8.6 में आप कर सकते हैं:

require 'enumerator'
arr.enum_for(:each_with_index).map { |x,i| [x, i+2] }

Comments

धन्यवाद! क्या आप मुझे प्रलेखन के लिए एक संकेतक दे सकते हैं .each_with_index.map?

— मीशा मोरशको १५'११

@ मीशा: हमेशा mapकी Enumerableतरह एक तरीका है । each_with_index, जब एक ब्लॉक के बिना कहा जाता है, एक रिटर्न Enumeratorवस्तु (1.8.7+ में), जिसमें घोला जा सकता है Enumerable, तो आप कॉल कर सकते हैं map, select, rejectबस एक सरणी, हैश पर की तरह आदि उस पर, सीमा आदि

— sepp2k

IMO यह 1.8.7+ में सरल और बेहतर पठन है:arr.map.with_index{ |o,i| [o,i+2] }

— Phrogz

@Phrogz: map.with_index1.8.7 में काम नहीं करता है ( mapएक सरणी देता है जब 1.8 में एक ब्लॉक के बिना कहा जाता है)।

— sepp2k

यह नोट करने के लिए महत्वपूर्ण .map के साथ काम नहीं करता है! यदि आप सीधे उस सरणी को प्रभावित करना चाहते हैं जिस पर आप लूपिंग कर रहे हैं।

— ऐश ब्लू

Answer 2

रूबी है गणनाकार # with_index (ऑफसेट = 0) , इसलिए पहले का उपयोग कर एक प्रगणक को सरणी परिवर्तित वस्तु # to_enum या सरणी # नक्शा :

[:a, :b, :c].map.with_index(2).to_a
#=> [[:a, 2], [:b, 3], [:c, 4]]

Comments

मेरा मानना ​​है कि यह बेहतर उत्तर है, क्योंकि यह मानचित्र के साथ काम करेगा! foo = ['d'] * 5; foo.map!.with_index { |x,i| x * i }; foo #=> ["", "d", "dd", "ddd", "dddd"]

— कॉनर मैक्के

Answer 3

माणिक 1.9.3 में एक श्रृंखला योग्य विधि है, जिसे with_indexमानचित्र में जंजीर कहा जा सकता है।

उदाहरण के लिए:

array.map.with_index { |item, index| ... }

Answer 4

शीर्ष पर

arr = ('a'..'g').to_a
indexes = arr.each_index.map(&2.method(:+))
arr.zip(indexes)

Comments

एंड्रयू के पास बड़ी सुरक्षा होनी चाहिए! :)

— डेविड जे।

Answer 5

बिना एन्यूमरेटर का उपयोग किए बिना 1.8.6 (या 1.9) के लिए दो और विकल्प हैं:

# Fun with functional
arr = ('a'..'g').to_a
arr.zip( (2..(arr.length+2)).to_a )
#=> [["a", 2], ["b", 3], ["c", 4], ["d", 5], ["e", 6], ["f", 7], ["g", 8]]

# The simplest
n = 1
arr.map{ |c| [c, n+=1 ] }
#=> [["a", 2], ["b", 3], ["c", 4], ["d", 5], ["e", 6], ["f", 7], ["g", 8]]

Answer 6

मैंने हमेशा इस शैली के वाक्य रचना का आनंद लिया है:

a = [1, 2, 3, 4]
a.each_with_index.map { |el, index| el + index }
# => [1, 3, 5, 7]

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

Comments

लगभग 5 साल पहले दिए गए इस अलग रूप का उत्तर कैसा है ?

— एंड्री डाइनको

Answer 7

ऐसा करने का एक मजेदार, लेकिन बेकार तरीका:

az  = ('a'..'z').to_a
azz = az.map{|e| [e, az.index(e)+2]}

Comments

घृणा क्यों? यह ऐसा करने का एक कार्य तरीका है और मैं यह भी कहता हूं कि यह परिणाम प्राप्त करने का एक मूर्खतापूर्ण तरीका है।

— स्वचालित

#index पर कॉल करने का मतलब यह है कि अब O (N ^ 2) लूप भी +2 क्यों है? :)

— रोज़गारपैक

जैसा कि मैं लिखता हूं A fun, but useless way। +2उत्पादन ओ पी के लिए पूछता है बनाने के लिए है

— Automatico

Answer 8

a = [1, 2, 3]
p [a, (2...a.size+2).to_a].transpose

Answer 9

module Enumerable
  def map_with_index(&block)
    i = 0
    self.map { |val|
      val = block.call(val, i)
      i += 1
      val
    }
  end
end

["foo", "bar"].map_with_index {|item, index| [item, index] } => [["foo", 0], ["bar", 1]]

Comments

हे भगवान! क्या आपने अन्य उत्तर भी पढ़े? map.with_indexरूबी में पहले से मौजूद है। क्यों enumerable वर्ग को फिर से खोलने और पहले से मौजूद कुछ को जोड़ने का सुझाव दें?

— नाथनवदा

यह 1.8.6 और 1.8.7 के लिए जाने का एक आसान तरीका हो सकता है (हाँ, हम में से कुछ अभी भी इसका उपयोग करते हैं) जैसे कि weirder सामान का उपयोग करने के लिए each_with_index.mapआदि और यहां तक ​​कि नए संस्करणों पर हम में से कोई भी इसका उपयोग करने के लिए पसंद कर सकता है। map.with_index FWIW :)

— रोजरपैक

Answer 10

मैं अक्सर ऐसा करता हूं:

arr = ["a", "b", "c"]

(0...arr.length).map do |int|
  [arr[int], int + 2]
end

#=> [["a", 2], ["b", 3], ["c", 4]]

सरणी के तत्वों पर सीधे पुनरावृत्ति करने के बजाय, आप पूर्णांकों की एक श्रेणी पर पुनरावृत्ति कर रहे हैं और सरणी के तत्वों को पुनः प्राप्त करने के लिए सूचक के रूप में उनका उपयोग कर रहे हैं।

Comments

यदि आप अन्य उत्तरों को पढ़ते हैं, तो मुझे आशा है कि अब आपको पता चलेगा कि बेहतर दृष्टिकोण हैं। तो यह सुनिश्चित करने के लिए कि आपको इसे जोड़ने की आवश्यकता क्यों नहीं है।

— नथानवदा

यदि एंड्रयू ग्रिम का जवाब दस वोटों का हकदार है, तो यह कम से कम एक योग्य है!

— केमिली गौडेय्यून