Нечетный (или даже) записи в Массиве Ruby

Немного левая сторона поля, но мне недавно было нужно что-то, что я мог передать select как proc:

def alternator
  gen = [true,false].cycle
  proc { gen.next }
end

self.filter = alternator

# ... elsewhere/much later ...
input = 'a'..'z'
input.select(&filter)

Некоторые могут предположить, что это могло даже быть случаем для Enumerator.new или даже Волокно, которое оба технически будет более простыми конструкциями, но я думаю за счет ясности.

Не забывай, старый добрый друг Array.inject

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

Должен дать вам лишние предметы.

С пустым массивом A и полным array H , должно работать что-то вроде этого:

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

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 нечетный индекс создает небольшую хакерскую работу, верно? Поскольку у вас будут соседние записи, которые фактически являются нечетными знаками. Чтобы компенсировать это, вы можете просто добавить нулевую запись к результату первого сбора. Подумайте:

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

Вы всегда можете еще больше сжать это и сделать что-то вроде:

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]

Тот же метод доступен для обработки нулевой записи.

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"

Я только что повторно использовал подход, который использовал для другого вопроса о массивах. : D

Это может сработать для вас или, опять же, нет: -)

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]

Мой взгляд на проблему, определение простых расширений массива:

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

Вот фрагмент кода , предназначенный для добавления метода select_with_index в Enumerable, который позволит вам выполнять

array.select_with_index {| item, i | элемент, если i% 2 == 0} для эвенов

array.select_with_index {| item, i | элемент, если i% 2 == 1} для коэффициентов

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

должен дать вам массив нечетных индексов.

Замените x [1] на x [0] для четных записей.

Другой способ подумать об этом (добавляет элементы array2 к array1):

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