Рубиновый индекс элементов массива

Question

Считайте, что у меня есть массив целочисленных элементов. В котором я пытаюсь найти индекс, где начинается длинная последовательность повторяющихся чисел.

my_array = [100, 101, 100, 102, 100, 100, 101, 100, 250, 251, 253, 260, 250, 200, 100, 100, 100, 100, 100, 100, 100, 100, 100, 120]

Ниже я пытаюсь найти указатель. Может кто-нибудь предложить мне более оптимизированный и правильный способ сделать это?

my_array.each with_index do |e, x|
  match = e.to_s * 5
  next_10 = my_array[x + 1, 5].join()

  if match == next_10
    puts "index #{x}"
    break
  end
end

#index 14

Answer 1

Я предполагаю, что цель состоит в том, чтобы найти индекс первого элемента самой длинной последовательности равных элементов в данном массиве.

my_array = [100, 101, 100, 102, 100, 100, 101, 100, 250, 251, 253, 260, 250, 200,
            100, 100, 100, 100, 100, 100, 100, 100, 100,
            120]

Здесь это будет 14, индекс 100, за которым следуют еще 8 100.

Мы можем сделать это следующим образом.

my_array.each_index.chunk { |i| my_array[i] }.
         max_by { |_,a| a.size }.
         last.
         first
           #=> 14

Шаги следующие.

enum0 = my_array.each_index
  #=> #<Enumerator: [100, 101, 100,..., 100, 120]:each_index> 

Мы можем увидеть элементы, которые будут сгенерированы этим перечислителем, преобразовав его в массив.

enum0.to_a
  #=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
  #    17, 18, 19, 20, 21, 22, 23]

Постоянно

enum1 = enum0.chunk { |i| my_array[i] }
  #=> #<Enumerator: #<Enumerator::Generator:0x000058d8d09ec8a0>:each> 

Ввиду возвращаемого значения вышеприведенного выражения, enum1 можно рассматривать как составной перечислитель , хотя Ruby не имеет такой концепции. Посмотрим, сгенерируют значения enum1.

enum1.to_a
  #=> [[100, [0]], [101, [1]], [100, [2]], [102, [3]], [100, [4, 5]],
  #    [101, [6]], [100, [7]], [250, [8]], [251, [9]], [253, [10]],
  #    [260, [11]], [250, [12]], [200, [13]],
  #    [100, [14, 15, 16, 17, 18, 19, 20, 21, 22]],
  #    [120, [23]]]

Постоянно

a = enum1.max_by { |v,a| a.size }
  #=> [100, [14, 15, 16, 17, 18, 19, 20, 21, 22]]

Поскольку v не используется в блоке, это выражение обычно пишется:

a = enum1.max_by { |_,a| a.size }

Наличие подчеркивания (допустимой локальной переменной) сигнализирует читателю, что эта переменная блока не используется в расчете блока. Последние два шага следующие.

b = a.last
  #=> [14, 15, 16, 17, 18, 19, 20, 21, 22] 
b.first
  #=> 14 

См. Enumerable # chunk и Enumerable # max_by .

Answer 2

В первой итерации я получаю массив последовательностей повторяющихся элементов, а затем продолжаю с логикой,

groups = my_array[1..-1].inject([[my_array[0]]]) { |m, n| m.last[0] == n ? m.last << n : m << [n]; m }
# => [[100], [101], [100], [102], [100, 100], [101], [100], [250], [251], [253], [260], [250], [200], [100, 100, 100, 100, 100, 100, 100, 100, 100], [120]]

groups[0,groups.index(groups.sort { |a,b| a.count <=> b.count }.last)].flatten.count
# => 14

Использование регулярных выражений может быть точным и простым.

Answer 3

my_array = [100, 101, 100, 102, 100, 100, 101, 100, 250, 251, 253, 260, 250, 200, 100, 100, 100, 100, 100, 100, 100, 100, 100, 120]


index_and_repetitions = lambda { |my_array|
  stk = {}
  previous = my_array[0]
  last_index = 0
  stk[last_index] = 1
  my_array.drop(0).each_with_index{|item, index|
    if item == previous
      stk[last_index] += 1
    else
      last_index = index
      stk[last_index] = 1
      previous = item
    end
  }
  stk
}

stk = index_and_repetitions.call(my_array)
puts stk.key(stk.values.max)

вы можете найти результаты тестов (по сравнению с другими ответами) отсюда.

Answer 4

my_array.index.with_index{|value,index| my_array[index,6].uniq.size==1}

Это своего рода подстройка, если вы имеете в виду «оптимизированный» именно так, как выглядит код. Если вы имеете в виду оптимизированную производительность. это не подходит.