Hoe in kaart brengen met index in Ruby?

Wat is de gemakkelijkste manier om

. te converteren

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

naar

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

Antwoord 1, autoriteit 100%

Als je ruby 1.8.7 of 1.9 gebruikt, kun je het feit gebruiken dat iteratormethoden zoals each_with_index, wanneer ze zonder blok worden aangeroepen, een Enumerator-object retourneren , waarmee u Enumerable-methoden zoals mapkunt aanroepen. U kunt dus het volgende doen:

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

In 1.8.6 kunt u het volgende doen:

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

Antwoord 2, autoriteit 32%

Ruby heeft Enumerator#with_index(offset = 0) , dus converteer eerst de array naar een enumerator met behulp van Object#to_enumof Array#map:

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

Antwoord 3, autoriteit 18%

In ruby 1.9.3 is er een ketenbare methode genaamd with_indexdie kan worden gekoppeld aan een map.

Bijvoorbeeld:

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

Antwoord 4, autoriteit 2%

Over de beste obfuscation:

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

5

Hier zijn nog twee opties voor 1.8.6 (of 1.9) zonder gebruik van de enumerator:

# 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]]

6

Een leuke, maar nutteloze manier om dit te doen:

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

7

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

8

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]]

9

Ik doe dit vaak:

arr = ["a", "b", "c"]
(0...arr.length).map do |int|
  [arr[int], int + 2]
end
#=> [["a", 2], ["b", 3], ["c", 4]]

In plaats van rechtstreeks te itereren over de elementen van de array, itereer je over een reeks gehele getallen en gebruik je deze als de indices om de elementen van de array op te halen.