Как вы получили предыдущие 2 и следующие 2 элемента из текущего индекса любого данного массива?

Question

Учитывая массив

arr = ["a", "b", "c", "d"]

Мне нужен метод, который принимает index и массив

def previous_and_next_elems(idx, arr)
  ...
end

Скажите, что idx = 1

$> previous_and_next_elems(1, arr)
$> [['a'], ['c', 'd']]

Обратите внимание, что, поскольку до idx=1 присутствовал только один элемент, следовательно, присутствовал только элемент a. Если бы не было ни одного, возвращался бы пустой массив.

Answer 1

arr = ["a", "b", "c", "d", "e"]

def for_and_aft(arr, idx)
  index_range = 0..arr.size-1
  [arr.values_at(*[idx-2, idx-1].grep(index_range)),
   arr.values_at(*[idx+1].grep(index_range))]
end

for_and_aft(arr,0)
  #=> [[], ["b"]] 
for_and_aft(arr,1)
  #=> [["a"], ["c"]] 
for_and_aft(arr,2)
  #=> [["a", "b"], ["d"]] 
for_and_aft(arr,3)
  #=> [["b", "c"], ["e"]] 
for_and_aft(arr,4)
  #=> [["c", "d"], []] 

См. Массив # values_at и Enumerable # grep .

Рассмотрим idx = 1. Выполняются следующие расчеты.

index_range = 0..arr.size-1
  #=> 0..4

a = [idx-2, idx-1]
  #=> [-1, 0] 
b = a.grep(index_range)
  #=> [0] 
c = arr.values_at(*b)
  #=> ["a"]

d = [idx+1]
  #=> [2] 
e = d.grep(index_range)
  #=> [2] 
f = arr.values_at(*e)
  #=> ["c"] 

[c,f]
  #=> [["a"], ["c"]]

В вычислениях b, grep использует Range # === для оценки

(0..4) === -1
  #=> false 
(0..4) ===  0
  #=> true

и, следовательно, возвращает [0].

Answer 2

Только что нашел решение. Парень просто помог мне расслабиться.

def previous_and_next_two_from(element = 3, arr = [1, 2, 3, 4, 5])
  i = arr.index(element)
  next_two = i ? arr[(i + 1)..(i + 2)] : []
  i = arr.reverse.index(element)
  previous_two = i ? arr.reverse[(i + 1)..(i + 2)].reverse : []
  {
    previous_two: previous_two,
    next_two: next_two
  }
end

$> previous_and_next_two_from(0) => {:previous_two=>[],     :next_two=>[]     }
$> previous_and_next_two_from(1) => {:previous_two=>[],     :next_two=>[2, 3] }
$> previous_and_next_two_from(2) => {:previous_two=>[1],    :next_two=>[3, 4] }
$> previous_and_next_two_from(3) => {:previous_two=>[1, 2], :next_two=>[4, 5] }
$> previous_and_next_two_from(4) => {:previous_two=>[2, 3], :next_two=>[5]    }
$> previous_and_next_two_from(5) => {:previous_two=>[3, 4], :next_two=>[]     }
$> previous_and_next_two_from(6) => {:previous_two=>[],     :next_two=>[]     }
$> previous_and_next_two_from(7) => {:previous_two=>[],     :next_two=>[]     }

Именно то, что мне нужно. Ура! * * 1004