Ruby数组迭代和变异

Question

我有一个类似的对象数组，其属性值为a，其值可以是b或c。该数组可以视为行的集合，其中数组中的每对项表示一行。我刚刚上市的属性a的数值为简单起见， 例子：

array = [c, b, b, c, c, c, b] 
# array[0], array[1] is one row (c, b) 
# array[2], array[3] is another (b, c) 
# ... 

不能有任何的只是(b, b)行，如果是这样的话，则b值中的一个必须被交换为数组中最接近的c值。如果没有更多c值，则只要b值保留在数组末尾，数组就会有效。

该最后阵列的行可以只包含一个值，即（b，）。

例子：

array = [b, c, b, b, c, b, b, b, c, b, b, c, c] 
# becomes 
array = [b, c, b, c, b, b, b, b, c, b, b, c, c] 
array = [b, c, b, c, b, c, b, b, b, b, b, c, c] 
array = [b, c, b, c, b, c, b, c, b, b, b, b, c] 
array = [b, c, b, c, b, c, b, c, b, c, b, b, b] 
# rows: (b, c), (b, c), (b, c), (b, c), (b, c), (b, b,), (b,)  

这是我想到了，我真的不喜欢（因为它是非常必要和详细）解决方案

while true do 
    cand = nil 
    array.each_slice(2) do |item, nxt| 
    return if nxt.nil? 
    # pseudo-code: assume b? returns true for a == b   
    next unless item.b? && nxt.b? 
    cand = nxt 
    break 
    end 
    swap_cand = array.slice(array.index(cand), array.length).reject{ |item| item.popular? }.first 
    return if swap_cand.nil? 
    old_index, new_index = array.index(cand), array.index(swap_cand) 
    array[old_index], array[new_index] = array[new_index], array[old_index] 
end 

我一直运行到的一个问题在迭代时我无法改变数组，因此需要两个循环。

编辑根据@ 7stud的建议清理了一些break语句。

Answer 1

可枚举的＃chunk非常适合这个问题。

代码

def valid?(arr, b) 
    arr.chunk { |e| e } 
    .map(&:last)[0..-2] 
    .select { |e| e.first == b } 
    .max_by(&:size) 
    .size <= 2 
end 

例

b = 0 
c = 1 
valid?([c, b, b, c, b, b, b], b) #=> true 
valid?([c, b, b, b, c, c, b], b) #=> false 

说明

b = 0 
c = 1 
arr = [c, b, b, c, b, b, b] 
    #=> [1, 0, 0, 1, 0, 0, 0] 
enum = arr.chunk { |e| e } 
    #=> #<Enumerator: #<Enumerator::Generator:0x0000010205aa70>:each> 
enum.to_a # Let's examine the elements of `enum` 
    #=> [[1, [1]], [0, [0, 0]], [1, [1]], [0, [0, 0, 0]]] 
a = enum.map(&:last) 
    #=> [[1], [0, 0], [1], [0, 0, 0]] 
d = a[0..-2] # disregard last value, which may or may not be an array of `b`'s 
    #=> [[1], [0, 0], [1]] 
e = d.select { |e| e.first == b } 
    #=> [[0, 0]] 
f = e.max_by(&:size) 
    #=> [0, 0] 
g = f.size 
    #=> 2 
g <= 2 
    #=> true