Question

数组由1，2和0组成。我试图确定数组中的最大重复次数及其起始索引。

示例：

2 2 1 0 2 2 2 0 1 1

该方法应接受整数争论，该争论可以是数字1或2

之一

如果我们在上面的数组上演示这些输入，输出将是：

find_duplicates(2)
=>    3,4

find_duplicates(1)
=>    2,8

其中第一个数字表示复制的大小，第二个数字表示复制的起始索引。

我尝试循环遍历数组并与arr[i+1]或arr[-1]进行比较，但这不是正确的方法。任何帮助将不胜感激。

修改在我提出这个问题的时候，我没有粘贴我曾经尝试过的东西，如果我能对自己所遵循的方式有所信心，那么我不会这样做：

def find_status(arr,participant)
    status = Array.new
#arr is a two dimensional array
for i in 0...arr.length do
    current_line=arr[i]
    cons=0
    for j in 0...current_line.length do
         #I worked on lots of if/else/case statements here, this is just one of them
        if current_line[j] == participant
            cons+=1   #count consecutive
            if current_line[j]!=participant
                cons=0
            end
        end
        status[i] = cons
    end
end
return status
end

Answer 1

tablebottomConstraint.constant =  keyboardEndFrame.size.height+self.messageView.frame.size.height

对于def max_run(arr, target) _,b = arr.each_with_index. chunk { |n,_| n==target }. select { |tf,_| tf==true }. max_by { |_,a| a.size } b ? [b.size, b.first.last] : nil end arr = [1,1,2,2,2,3,1,1,1,1,2,2,2,2,3,3] max_run(arr,1) #=> [4, 6] max_run(arr,2) #=> [4, 10] max_run(arr,3) #=> [2, 14] max_run(arr,4) #=> nil，步骤如下：

target = 2

我们可以看到这个枚举器通过将它转换为数组而生成的元素：

enum0 = arr.each_with_index
  #=> #<Enumerator: [1, 1, 2, 2, 2, 3, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3]
  #    :each_with_index>

继续，

enum0.to_a
  #=> [[1, 0], [1, 1], [2, 2], [2, 3], [2, 4], [3, 5], [1, 6], [1, 7], [1, 8],
  #     [1, 9], [2, 10], [2, 11], [2, 12], [2, 13], [3, 14], [3, 15]]

仔细检查这里的返回值。您可以将enum1 = enum0.chunk { |n,_| n==target } #=> #<Enumerator: #<Enumerator::Generator:0x007f9beb9b0850>:each>视为＆＃34;复合枚举器＆＃34;。它将生成以下值：

enum1

继续，

enum1.to_a
  #=> [[false, [[1, 0], [1, 1]]], [true, [[2, 2], [2, 3], [2, 4]]],
  #    [false, [[3, 5], [1, 6], [1, 7], [1, 8], [1, 9]]],
  #    [true, [[2, 10], [2, 11], [2, 12], [2, 13]]], [false, [[3, 14], [3, 15]]]]

Answer 2

a = [2, 2, 1, 0, 2, 2, 2, 0, 1, 1]

longest_sequence =
a.each_index.select{|i| a[i] == 2}.chunk_while{|i, j| i.next == j}.max_by(&:length)
# => [4, 5, 6]

[longest_sequence.length, longest_sequence.first] # => [3, 4]

Answer 3

以下解决方案可能最有效，因为它是O(N)。它遍历一个数组，收集块：

arr.each.with_index.reduce({idx:-1, i: -1, len: 0}) do |memo, (e, i)|
  memo[:i] = i if memo[:i] == -1 && e == 2        # at the beginning of chunk
  memo[:len], memo[:idx] = [i - memo[:i], memo[:i]] \
    if memo[:i] >= 0 && i - memo[:i] > memo[:len] # save values if needed
  memo[:i] = -1 unless e == 2                     # reset index counter
  memo
end.reject { |k, _| k == :i }                     # reject temporary index value

#⇒ {
#    :idx => 4,
#    :len => 3
#  }

将其用作方法，接受参数;只需使用def find_duplicates number包含上面的代码，并将2替换为上面代码中的数字。是的，它返回哈希而不是数组。

查找数组中连续重复元素的索引和大小

3 个答案: