Есть ли быстрый способ получить любую другую запись в массиве в Ruby? Либо нечетные, либо четные значения записей с 0, включенными в нечетные. Я бы хотел использовать его так:
array1 += array2.odd_values
или
puts array2.odd_values.join("-")
например
Update
Это дает то, что мне нужно, но я уверен, что есть более короткая версия.
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, в Ruby 2.2 вы можете просто:
arr.select.with_index { |_, i| i.odd? }
Вы можете просто использовать это:
(1..6).partition { |v| v.even? } #=> [[2, 4, 6], [1, 3, 5]]
От Ruby docs: Справка по Ruby Docs
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
Просто нашел еще более строгий способ (должен любить Ruby):
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
Я использую оператор "splat" массива для получения значений, разделенных запятыми, и передаю их в Hash, который принимает аргументы как переменные ключи/значения.
Еще один способ подумать (добавляет array2 evens в array1):
array1 << array2.values_at(*Array.new(array2.size/2){|i| i*2})
Это похоже на самое Rubyish решение, сочетающее в себе лучшее из JacobM и glenn jackman.
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
С пустым массивом A и полным массивом H должно работать следующее:
H.size.times do |i|
if i % 2 == 1
A[i/2] = H[i]
end
end
Это может сработать для вас, или, опять же, не: -)
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]
Здесь фрагмент кода, который предназначен для добавления метода select_with_index в Enumerable, что позволит вам делать
array.select_with_index{|item, i| item if i % 2 == 0} для evens
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
# => []
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]
Тот же самый хак доступен для обработки нулевой записи.
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
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
Не забывайте, старый добрый друг Array.inject
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a.inject([]){|result, item| result << item if item %2 == 1; result}
Должны предоставить вам нечетные элементы.
Я предлагаю использовать функцию Enumerable # Inject
array = (1..30)
array.inject({even: [], odd: []}){|memo, element| memo[element.even? ? :even : :odd] << element; memo}
Слегка покинул поле, но недавно мне нужно было кое-что, что я мог бы передать select как процесс:
def alternator
gen = [true,false].cycle
proc { gen.next }
end
self.filter = alternator
# ... elsewhere/much later ...
input = 'a'..'z'
input.select(&filter)
Некоторые могут предположить, что это может быть даже случай для Enumerator.new или даже для Волокна, которые технически будут более простыми конструкциями, но я думаю за счет ясности.