jak można przechodzić przez wiele tablic równolegle?

Question

Mam 4 tablice.

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

Czy możliwe jest łączenie każdego elementu w odpowiednich tablicach?

więc skończyć z pojedynczych linii sznurka jak jak

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

i tak dalej ...

to możliwe, aby to zrobić w jednej pętli?

for i in (1..array1.count) 

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

end 

Co się dzieje, gdy nie może być nieprzewidywalna liczba tablic & są każdy nierówna wielkość?

Answer 1

Dobrze, jeśli wiesz, że wszystkie były tej samej długości:

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

Edit: następujący kod działa

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: co się dzieje, jeśli nie wiem, jak wiele tablic tam będzie?

Proponuję utworzyć tablicę tablic; lista tablic. Stwórz tablicę tablic (zasadniczo tablicę 2D, ale nie można jej indeksować jak jedną), a wraz z nią drukuj każdą linię po kolei dla każdej tablicy w tablicyList.

Ten kod działa:

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

użyłbym Enumerable#zip stworzyć tablicę tablic. Tworzy tablicę, w której pierwszy element jest tablicą pierwszych elementów wszystkich tablic, które do niej przechodzisz, itd. Następnie przejrzyj tę listę i wydrukuj każdy argument za pomocą Array#join. Coś jak:

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

EDIT: Nie, zip nie będzie bardzo pomocne w miarę dołączania tablic idzie. glenn's metoda jest na to dobra. Możesz dołączyć do końca tablicy zip ped, ale to nie jest tak proste:

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

Answer 3

proste:

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

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

ta będzie współpracować z dowolną liczbą subarrays tak długo, jak są one wszystkie takie same rozmiar (niezależnie od tego, jaki jest rozmiar).

Jeśli subarrays mają różne długości, ale to jest OK, aby używać długość pierwszego, można to zrobić:

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

Answer 4

Jeśli używasz rubin 1.9 może można skorzystać z iteratorów zewnętrznych, to niech sobie z dowolnej liczby tablic:

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) 

produkuje:

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