¿cómo se puede recorrer varias matrices en paralelo?

Question

tengo 4 matrices.

["one", "two", "three"] 
["1", "2", "3" 
["un", "deux", "trois"] 
["ichi", "ni", "san"] 

¿es posible concatenar cada elemento en sus respectivas matrices?

así que terminan con las líneas individuales de cadena como como

"one, 1, un, ichi"\n 
"two,2, deux,ni"\n 

y así sucesivamente ...

es posible hacer esto en un bucle?

for i in (1..array1.count) 

puts array1[i] + ", " + array2[i] + ", " + array3[i] + ", " + array4[i] 

end 

¿Qué pasa cuando puede haber número impredecible de matrices & son cada tamaño desigual?

Answer 1

Bueno, si usted sabe que todos ellos eran de la misma longitud:

(0...array1.length).each{|i|puts array1[i] + ", " + array2[i] + ", " + array3[i] + ", " + array4[i]} 

Editar: El código siguiente funciona

array1 = ["one", "two", "three"] 
array2 = ["1", "2", "3"] 
array3 = ["un", "deux", "trois"] 
array4 = ["ichi", "ni", "san"] 

(0...array1.length).each{|i| puts array1[i] + ", " + array2[i] + ", " + array3[i] + ", " + array4[i]} 

Edit2: ¿Qué pasa si usted no sabe cómo muchas matrices ¿habrá?

Sugeriría hacer una matriz de matrices; una lista de matrices. Haga una matriz de matrices (esencialmente una matriz 2D pero no se puede indexar como una) y con ella imprima cada línea una por una para cada matriz en la lista de matrices.

Este código funciona:

array1 = ["one", "two", "three"] 
array2 = ["1", "2", "3"] 
array3 = ["un", "deux", "trois"] 
array4 = ["ichi", "ni", "san"] 

arrayList = [] 
arrayList.push(array1, array2, array3, array4) 

p arrayList 

(0...array1.length).each{|i| 
    (0...arrayList.length).each{|j| 
     print arrayList[j][i] + ", " 
    } 
    print "\n" 
} 

Answer 2

me gustaría utilizar Enumerable#zip para crear una matriz de matrices. Creará una matriz donde el primer elemento sea una matriz de los primeros elementos de todas las matrices que le pase, y así sucesivamente con la segunda, tercera, etc. Luego revise esta lista e imprima cada argumento usando Array#join. Algo así como:

a.zip(b, c, d).each do |l| 
    puts l.join(", ") 
end 

EDIT: No, zip no va a ser muy útil en lo que va añadiendo matrices. glenn's método es bueno para eso. Se puede añadir al final de una matriz zip ped, pero no es tan fácil:

e = a.zip(b, c) 
e.length.times { |i| e[i].push(d[i]) } 

Answer 3

Fácil:

a = [array1,array2,array3,array4] # or however many you have 

puts a.transpose.map {|x| x.join(", ")}.join("\n") 

Esto funciona con cualquier número de submatrices, siempre y cuando todos ellos son los mismos tamaño (independientemente de lo que ese tamaño es).

Si los subconjuntos son diferentes longitudes, pero es bien usar la longitud de la primera de ellas, se puede hacer esto:

a[0].zip(*a[1..-1]).map {|x| x.join(", ")}.join("\n") 

Answer 4

Si está utilizando rubí 1.9 tal vez usted puede tomar ventaja de los iteradores externos, esto le permitirá hacer frente a cualquier número de matrices:

array1 = ['one','two','three'] 
array2 = [1,2,3,4] 
array3 = ['un','deux','trois'] 
array4 = ['ichi','ni','san'] 

def bundle(*enumerables) 
    enumerators = enumerables.map{ |e| e.to_enum } 
    loop { puts enumerators.map { |e| e.next }.join(', ') } 
end 

bundle(array1,array2,array3,array4) 

produce:

one, 1, un, ichi 
two, 2, deux, ni 
three, 3, trois, san