Ruby 배열의 홀수 (또는 짝수) 항목

Ruby 배열의 홀수 (또는 짝수) 항목

---

Ruby에서 배열의 다른 모든 항목을 가져 오는 빠른 방법이 있습니까? 홀수에 0이 포함 된 홀수 또는 짝수 항목 값입니다. 다음과 같이 사용할 수 있기를 바랍니다.

array1 += array2.odd_values

또는

puts array2.odd_values.join("-")

예를 들면

최신 정보

이것은 내가 추구하는 것을 정확히 제공하지만 더 짧은 버전이 있다고 확신합니다.

array1.each_with_index do |item,index| 
  if (index %2 ==0) then 
    array2.push(item) 
  end
end

---

a = ('a'..'z').to_a

a.values_at(* a.each_index.select {|i| i.even?})
# => ["a", "c", "e", "g", "i", "k", "m", "o", "q", "s", "u", "w", "y"]

a.values_at(* a.each_index.select {|i| i.odd?})
# => ["b", "d", "f", "h", "j", "l", "n", "p", "r", "t", "v", "x", "z"]

그래서 요청대로

class Array
  def odd_values
    self.values_at(* self.each_index.select {|i| i.odd?})
  end
  def even_values
    self.values_at(* self.each_index.select {|i| i.even?})
  end
end

---

...

arr = ["0", "1", "2", "3"]
arr.select.each_with_index { |_, i| i.odd? }
arr.select.each_with_index { |_, i| i.even? }

으로 floum는 지적, 루비 2.2 당신은 간단하게 할 수 있습니다 :

arr.select.with_index { |_, i| i.odd? }

---

이것을 사용할 수 있습니다.

(1..6).partition { |v| v.even? }  #=> [[2, 4, 6], [1, 3, 5]]

Ruby 문서에서 : Ruby 문서 참조

---

left,right = a.partition.each_with_index{ |el, i| i.even? }

---

패싯을 사용하는 미친 방법 :

require 'facets'
array = [1,2,3,4,5]
odd = array.to_h.keys # 1,3,5
even = array.to_h.values.compact # 2,4

---

이건 절대 읽히지 않겠지 만 ...

간단하고 깔끔함 :

array2.map{ |n| n if n % 2 == 0 }.compact # evens

array2.map{ |n| n if n % 2 == 1 }.compact # odds

더 간결한 방법을 찾았습니다 (루비를 좋아해야합니다).

array2.find_all{ |n| n % 2 == 0 } # evens

array2.reject  { |n| n % 2 == 0 } # odds

---

dst = []
array.each_slice(2) { |x| dst.push(x[1]) }

이상한 인덱스의 배열을 제공해야합니다.

교체 x[1]와 x[0]짝수 항목에 대한.

---

odds = array.each_slice(2).map(&:first)
evens = array.each_slice(2).map(&:last)

---

기록을 위해 :

a = [1,2,3,4,5,6]
h = Hash[*a]
evens = h.keys
odds = h.values

Array의 'splat'연산자를 사용하여 쉼표로 구분 된 값을 가져 와서 인수를 대체 키 / 값으로 허용하는 Hash에 전달합니다.

---

그것에 대해 생각하는 또 다른 방법 (array2 짝수를 array1에 추가) :

array1 << array2.values_at(*Array.new(array2.size/2){|i| i*2})

---

이것은 JacobM과 glenn jackman의 접근 방식을 결합한 가장 Rubyish 솔루션처럼 보입니다.

module ::Enumerable
  def select_with_index
    index = -1
    select { |x| yield(x, (index += 1)) }
  end
  def odds
    select_with_index {|x,i| i.odd?}
  end
  def evens
    select_with_index {|x,i| i.even?}
  end
end

---

다음은 Enumerable에 select_with_index 메소드를 추가하기위한 코드 스 니펫 입니다.

array.select_with_index{|item, i| item if i % 2 == 0} 짝수

array.select_with_index{|item, i| item if i % 2 == 1} 확률을 위해

---

내 문제에 대한 간단한 배열 확장 정의 :

class Array
  def odd_values
    (0...length / 2).collect { |i| self[i*2 + 1] }
  end

  def even_values
    (0...(length + 1) / 2).collect { |i| self[i*2] }
  end
end

puts [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ].odd_values.inspect
# => [1, 3, 5, 7, 9]

puts [ 0, 1, 2, 3, 4, 5, 6, 7, 8 ].even_values.inspect
# => [0, 2, 4, 6, 8]

puts [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ].even_values.inspect
# => [0, 2, 4, 6, 8]

puts [ ].even_values.inspect
# => []

---

이것은 당신을 위해 작동하거나 다시 작동하지 않을 수 있습니다 :-)

irb(main):050:0> all = [1,2,3,4,5,6,7,8,9]
=> [1, 2, 3, 4, 5, 6, 7, 8, 9]
irb(main):051:0> evens = []
=> []
irb(main):052:0> all.each_index do |i| if (i.even?): evens.push(a[i]) end end
=> [1, 2, 3, 4, 5, 6, 7, 8, 9]
irb(main):053:0> evens
=> [1, 3, 5, 7, 9]

---

a = [0,1,2,3,4,5,6,7,8,9]

(1...a.size).step(2).collect { |i| a[i] }
=> [1, 3, 5, 7, 9]

(2...a.size).step(2).collect { |i| a[i] }
=> [2, 4, 6, 8]

물론 0을 고려할 때 이상한 인덱스는 약간의 해커 리를 만듭니다. 사실상 홀수 인덱스 인 인접 항목이 있기 때문입니다. 이를 보완하기 위해 첫 번째 수집 결과에 0 번째 항목을 추가 할 수 있습니다. 중히 여기다:

[a[0]] + (1...a.size).step(2).collect { |i| a[i] }
=> [0, 1, 3, 5, 7, 9]

You could always compact this further and do something like:

a.values_at(*(1...a.size).step(2))
=> [1, 3, 5, 7, 9]

a.values_at(*(2...a.size).step(2))
=> [2, 4, 6, 8]

The same hack is available to handle the zeroth entry.

---

evens = (1..10).each_with_object([]) {|i, a| a << i*2 }
#=> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

---

a = [1,2,3,4,5]
a.in_groups_of(2).map(&:first) => odds
a.in_groups_of(2).map(&:last) => evens

---

With a blank array A, and a full array H, something like this should work:

H.size.times do |i|
  if i % 2 == 1
    A[i/2] = H[i]
  end
end

---

module Enumerable
  def odd_values
    r = []
    self.each_index {|x| r << self[x] if x%2==0}
    r
  end
end

p ["a", "b" ,"c" ,"d" ,"e"].odd_values  #returns ["a","c","e"]
p ["a", "b" ,"c" ,"d" ,"e"].odd_values.join("-") #returns "a-c-e"

I just reused an approach i used for another question on arrays. :D

---

Don't forget good old friend Array.inject

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a.inject([]){|result, item| result << item if item %2 == 1; result}

Should give you odd items.

---

I suggest the use of Enumerable#Inject function

array = (1..30)    
array.inject({even: [], odd: []}){|memo, element| memo[element.even? ? :even : :odd] << element; memo}

ReferenceURL : https://stackoverflow.com/questions/1614147/odd-or-even-entries-in-a-ruby-array