División de una matriz en partes iguales en ruby ​​

Question

Necesito una forma de dividir una matriz en una serie de matrices dentro de otra matriz de igual tamaño. Alguien tiene algún método para hacer esto?

Por ejemplo

a = [0, 1, 2, 3, 4, 5, 6, 7] 
a.method_i_need(3) 
a.inspect 
    => [[0,1,2], [3,4,5], [6,7]] 

Answer 1

estás buscando Enumerable#each_slice

a = [0, 1, 2, 3, 4, 5, 6, 7] 
a.each_slice(3) # => #<Enumerator: [0, 1, 2, 3, 4, 5, 6, 7]:each_slice(3)> 
a.each_slice(3).to_a # => [[0, 1, 2], [3, 4, 5], [6, 7]] 

Answer 2

Trate

a.in_groups_of(3,false) 

Lo hará su trabajo

Answer 3

Tal vez estoy leyendo mal la questi ya que la otra respuesta ya está aceptada, pero sonaba como si quisieras dividir la matriz en 3 grupos iguales, independientemente del tamaño de cada grupo, en lugar de dividirla en N grupos de 3 como lo hacen las respuestas anteriores. Si eso es lo que está buscando, rieles (ActiveSupport) también tiene un método llamado in_groups:

a = [0,1,2,3,4,5,6] 
a.in_groups(2) # => [[0,1,2,3],[4,5,6,nil]] 
a.in_groups(3, false) # => [[0,1,2],[3,4], [5,6]] 

No creo que hay un rubí equivalente, sin embargo, se puede obtener aproximadamente los mismos resultados mediante la adición de este método sencillo:

class Array; def in_groups(num_groups) 
    return [] if num_groups == 0 
    slice_size = (self.size/Float(num_groups)).ceil 
    groups = self.each_slice(slice_size).to_a 
end; end 

a.in_groups(3) # => [[0,1,2], [3,4,5], [6]] 

la única diferencia (como se puede ver) es que esto no va a difundir el "espacio vacío" en todos los grupos; cada grupo, pero el último es igual en tamaño, y el último grupo siempre contiene el resto más todo el "espacio vacío".

Actualización: Como @rimsky astutamente señaló, el método anterior no siempre resultan en el número correcto de los grupos (a veces se crearán varias "grupos vacías" al final, y dejarlos fuera). Aquí hay una versión actualizada, reducida desde ActiveSupport's definition que extiende los extras para completar el número solicitado de grupos.

def in_groups(number) 
    group_size = size/number 
    leftovers = size % number 

    groups = [] 
    start = 0 
    number.times do |index| 
    length = group_size + (leftovers > 0 && leftovers > index ? 1 : 0) 
    groups << slice(start, length) 
    start += length 
    end 

    groups 
end 

Answer 4

Como escribió mltsy, in_groups(n, false) debe hacer el trabajo.

Solo quería agregar un pequeño truco para obtener el equilibrio correcto my_array.in_group(my_array.size.quo(max_size).ceil, false).

Aquí se muestra un ejemplo para ilustrar ese truco:

a = (0..8).to_a 
a.in_groups(4, false) => [[0, 1, 2], [3, 4], [5, 6], [7, 8]] 
a.in_groups(a.size.quo(4).ceil, false) => [[0, 1, 2], [3, 4, 5], [6, 7, 8]] 

Answer 5

Esto necesita un poco mejor inteligencia para manchar las piezas adicionales, pero es un comienzo razonable.

def i_need(bits, r) 
    c = r.count 
    (1..bits - 1).map { |i| r.shift((c + i) * 1.0/bits) } + [r] 
end 

> i_need(2, [1, 3, 5, 7, 2, 4, 6, 8]) 
=> [[1, 3, 5, 7], [2, 4, 6, 8]] 
> i_need(3, [1, 3, 5, 7, 2, 4, 6, 8]) 
=> [[1, 3, 5], [7, 2, 4], [6, 8]] 
> i_need(5, [1, 3, 5, 7, 2, 4, 6, 8]) 
=> [[1, 3], [5, 7], [2, 4], [6], [8]]