ТЕМА: array tricks

[1, 2] + [3, 4] #=> [1, 2, 3, 4]

[3, 4, 5] - [4, 5] #=> [3] Удаляет из первого массива все элементы второго массива. (Не изменяет изначальный массив, возвращает копию)

[1, 2, 3] & [2, 3] # => [2, 3] Вернет новый массив с элементами которые встречаются в обоих массивах.

[1, 2, 3, 3] | [2, 4, 5] # => [1, 2, 3, 4, 5]

[ Object.new ] * 4 #Создаст массив с 4 ссылками на один объект
Array.new(4) { Object.new } # Чаще всего когда умножают массив - хотят именно такой результат.
                            # 4 раза выполни блок, результат сохрани в новый массив.

[1, 2, 3, 4, 5, 6][2 .. 4]  #=> [3, 4, 5] Две точки включают последний элемент
[1, 2, 3, 4, 5, 6][2 ... 3] #=> [3, 4] Три точки - не включают, кстати 2 .. 3 - это Range, а не магия :)
[1, 2, 3, 4, 5][3 .. 1] #А это не сработает, когда хотите перевернутую часть массива делайте так:
[1, 2, 3, 4, 5][1 .. 3].reverse

arr = [1, 2, 3, 4, 5]
arr[2 .. 3] = 'x' #Возьми элементы со второго по третий и замени их на x
arr  # => [1, 2, 'x', 5]
arr[0 .. 1] = ['y', 'y', 'y'] #Возьми элементы с первого по второй и замени их на новый массив ( при этом, как ни странно, новый массив не будет одним элементом, он вставится и развернется)
arr # => ['y', 'y', 'y', 'x', 5]
arr[1 ... 2] = ['z', 'z'] #Возьми элементы со второго по третий (не включая, т.е. только второй) И замени их на новый массив.
arr # => ['y', 'z', 'z', 'y', 'x', 5]
arr[0 .. 1] = [] #Удали элементы 0 и 1
arr # => ['z', 'y', 'x', 5]
arr[1 ... 1] = ['i', 'i'] #Вставь после первого элемента новый массив. 
arr # => ['z', 'i', 'i', 'y', 'x', 5]

numbers = [18, 13, 14, 15]
numbers.map { |i| "i + 3 = #{i + 3}" } #map выполняет блок для каждого элемента массива, результат становится элементом нового масива

[1, 2, 3, 4].select { |i| i > 2 } #=> [3, 4]
[1, 2, 3, 4].reject { |i| i > 2 } #=> [1, 2]

arr = [1, 2, 3, 4, 5, 6, 7]
#Метод принимает один аргумент, который будет начальным значением
arr.inject 0 do |sum, element|         #В блок передается результат по стеку и текущий элемент
  if element % 2 == 0
   sum + element                    #Вы можете не изменять значение sum, все равно в следующий блок
  else                              #передастся результат исполнения предыдущего 
   sum                              #(последнее выражение в предыдущем блоке)
  end
end                                 # => В итоге получим сумму всех четных элементов. 

  [1, nil, nil, 2, 3, nil].compact # => [1, 2, 3]
  # недавно игрался с мейкером - 
  $game_party.line_set.slots.map(&:buttler).compact # тут с map используется краткий синтаксис блоков, могу и про это рассказать как-нибудь.

[1, [2, [3]], 4].flatten #[1, 2, 3, 4]

[1, 2, 3, 4, 5, 6].any? { |i| i > 2 } #Такой синтаксис any? применяет к каждому элементу блок, 
                                      #пока блок не вернет истину (не nil или false).
                                      #Тогда и any? вернет true
                                      

[1, 2, 3, 4, 5, 6].find { |i| i > 3 } # => 4. До 5 и 6 он не доберется.

#Это можно использовать к примеру в параллельном переборе 
arr1 = [2, 3]
arr2 = [4, 5]
arr1.each.with_index do |element, index|
  puts element
  puts arr2[index]
end

arr = [1, 2, 3, 4, 5]
arr.sample # => 3
arr.sample(3) # => [1,3,4]

arr = [1, 2, 3]
"#{arr.join(' + ')} = #{arr.inject(0) { |s, i| s + i }}" #=> "1 + 2 + 3  = 6"

arr = [1, 2, 3, 4, 5, 6, 7, 8] # отсортируем его так - сначала четные, потом нечетные
arr.sort { left, right| left % 2 - right % 2 } #[8, 2, 6, 4, 5, 3, 7, 1]

arr = [['EUR', 100], ['USD', 50], ['EUR', 200], ['USD', 150]]

result = {}
arr.each do |sub_arr|
  currency, amount = sub_arr[0], sub_arr[1]
  result[currency] ||= 0 #мы проверяем есть ли в хэше значение с таким ключем, если нет - инициализируем этот ключ со нулевым значением
  result[currency] += amount
end
result #=> { 'EUR' => 300, 'USD' => 200 }

#result - результат выполнение предыдущего блока
#sub_arr - текущий элемент массива
#в метод inject аргументом передаем то значение, которые передасться как result для самого первого блока, ведь для него не было предыдущего. По умолчанию - nil, в нашем случае - {}
arr.inject({}) do |result, sub_arr|
  #в следующий блок в переменную result передасться последнее выражение в этом блоке
  currency, amount = sub_arr[0], sub_arr[1]
  result[currency] ||= 0 
  result[currency] += amount
  result
end

  [1, 2, 3, 4, 5].inject(0) { |result, element| result + element }