¿Cómo agrega una matriz a otra matriz en Ruby y no termina con un resultado multidimensional?

somearray = ["some", "thing"]

anotherarray = ["another", "thing"]

somearray.push(anotherarray.flatten!)

Esperaba

["some","thing","another","thing"]

Tienes una idea viable, pero #flatten!está en el lugar equivocado: aplana su receptor, por lo que puedes usarlo para convertirlo [1, 2, ['foo', 'bar']]en[1,2,'foo','bar'] .

Sin duda, estoy olvidando algunos enfoques, pero puedes concatenar :

a1.concat a2
a1 + a2              # creates a new array, as does a1 += a2

o anteponer / agregar :

a1.push(*a2)         # note the asterisk
a2.unshift(*a1)      # note the asterisk, and that a2 is the receiver

o empalme :

a1[a1.length, 0] = a2
a1[a1.length..0] = a2
a1.insert(a1.length, *a2)

o anexar y aplanar :

(a1 << a2).flatten!  # a call to #flatten instead would return a new array

¡Solo puedes usar el +operador!

irb(main):001:0> a = [1,2]
=> [1, 2]
irb(main):002:0> b = [3,4]
=> [3, 4]
irb(main):003:0> a + b
=> [1, 2, 3, 4]

Puede leer todo sobre la clase de matriz aquí: http://ruby-doc.org/core/classes/Array.html

El enfoque más limpio es utilizar el método Array # concat ; no creará una nueva matriz (a diferencia de Array # + que hará lo mismo pero creará una nueva matriz).

Directamente de los documentos ( http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-concat ):

concat (otro_ary)

Agrega los elementos de other_ary a self.

Entonces

[1,2].concat([3,4])  #=> [1,2,3,4]  

La matriz # concat no aplanará una matriz multidimensional si se pasa como argumento. Tendrá que manejar eso por separado:

arr= [3,[4,5]]
arr= arr.flatten   #=> [3,4,5]
[1,2].concat(arr)  #=> [1,2,3,4,5]

Por último, puede usar nuestra gema corelib ( https://github.com/corlewsolutions/corelib ) que agrega ayudantes útiles a las clases principales de Ruby. En particular, tenemos un método Array # add_all que aplanará automáticamente las matrices multidimensionales antes de ejecutar el concat.

Método fácil que funciona con la versión Ruby> = 2.0 pero no con versiones anteriores:

irb(main):001:0> a=[1,2]
=> [1, 2]
irb(main):003:0> b=[3,4]
=> [3, 4]
irb(main):002:0> c=[5,6]
=> [5, 6]
irb(main):004:0> [*a,*b,*c]
=> [1, 2, 3, 4, 5, 6]

Prueba esto, combinará tus matrices eliminando duplicados

array1 = ["foo", "bar"]
array2 = ["foo1", "bar1"]

array3 = array1|array2

http://www.ruby-doc.org/core/classes/Array.html

Más documentación mira en "Set Union"

Aquí hay dos formas, observe en este caso que la primera forma asigna una nueva matriz (se traduce en somearray = somearray + anotherarray)

somearray = ["some", "thing"]

anotherarray = ["another", "thing"]

somearray += anotherarray # => ["some", "thing", "another", "thing"]

somearray = ["some", "thing"]
somearray.concat anotherarray # => ["some", "thing", "another", "thing"]

a = ["some", "thing"]
b = ["another", "thing"]

Para añadir ba ay almacenar el resultado en a:

a.push(*b)

o

a += b

En cualquier caso, se aconvierte en:

["some", "thing", "another", "thing"]

pero en el primer caso, los elementos de bse añaden a la amatriz existente , y en el último caso las dos matrices se concatenan juntas y el resultado se almacena en a.

(array1 + array2).uniq

De esta manera obtienes primero los elementos array1. No obtendrás duplicados.

Al elaborar la respuesta de @ Pilcrow, la única respuesta adecuada para grandes matrices es concat(+ ) ya que es rápida y no asigna un nuevo objeto para ser recolectado como basura cuando se opera dentro de un bucle.

Aquí está el punto de referencia:

require 'benchmark'

huge_ary_1 = Array.new(1_000_000) { rand(5_000_000..30_000_00) }

huge_ary_2 = Array.new(1_000_000) { rand(35_000_000..55_000_00) }

Benchmark.bm do |bm|
  p '-------------------CONCAT ----------------'
  bm.report { huge_ary_1.concat(huge_ary_2) }

  p '------------------- PUSH ----------------'
  bm.report { huge_ary_1.push(*huge_ary_2)  }
end

Resultados:

       user     system      total        real
"-------------------CONCAT ----------------"
  0.000000   0.000000   0.000000 (  0.009388)
"------------------- PUSH ----------------"
  example/array_concat_vs_push.rb:13:in `block (2 levels) in <main>': stack level too deep (SystemStackError)

Como puede ver, el uso pusharroja un ERROR : stack level too deep (SystemStackError)cuando las matrices son lo suficientemente grandes.

La pregunta, esencialmente, es "cómo concatenar matrices en Ruby". Naturalmente, la respuesta es usar concato+ como se menciona en casi todas las respuestas.

Una extensión natural de la pregunta sería "cómo realizar una concatenación de filas 2D de matrices 2D en Ruby". Cuando busqué en Google "matrices de concatenación de rubíes", esta pregunta SO fue el resultado principal, así que pensé en dejar mi respuesta a esa pregunta (no formulada pero relacionada) aquí para la posteridad.

En algunas aplicaciones, es posible que desee "concatenar" dos matrices 2D en fila. Algo como,

[[a, b], | [[x],    [[a, b, x],
 [c, d]] |  [y]] =>  [c, d, y]]

Esto es algo así como "aumentar" una matriz. Por ejemplo, utilicé esta técnica para crear una matriz de adyacencia única para representar un gráfico de un conjunto de matrices más pequeñas. Sin esta técnica, habría tenido que iterar sobre los componentes de una manera que podría haber sido propensa a errores o frustrante. Podría haber tenido que hacer un each_with_index, por ejemplo. En cambio, combiné zip y flatten de la siguiente manera,

# given two multi-dimensional arrays that you want to concatenate row-wise
m1 = [[:a, :b], [:c, :d]]
m2 = [[:x], [:y]]

m1m2 = m1.zip(m2).map(&:flatten)
# => [[:a, :b, :x], [:c, :d, :y]]

Solo otra forma de hacerlo.

[somearray, anotherarray].flatten
=> ["some", "thing", "another", "thing"]

["some", "thing"] + ["another" + "thing"]

Si los nuevos datos pueden ser una matriz o un escalar, y desea evitar que los nuevos datos se aniden si se tratara de una matriz, ¡el operador splat es increíble! Devuelve un escalar para un escalar y una lista desempaquetada de argumentos para una matriz.

1.9.3-p551 :020 > a = [1, 2]
 => [1, 2] 
1.9.3-p551 :021 > b = [3, 4]
 => [3, 4] 
1.9.3-p551 :022 > c = 5
 => 5 
1.9.3-p551 :023 > a.object_id
 => 6617020 
1.9.3-p551 :024 > a.push *b
 => [1, 2, 3, 4] 
1.9.3-p551 :025 > a.object_id
 => 6617020 
1.9.3-p551 :026 > a.push *c
 => [1, 2, 3, 4, 5] 
1.9.3-p551 :027 > a.object_id
 => 6617020 

Me sorprende que nadie haya mencionado reduce, lo que funciona bien cuando tienes una variedad de matrices:

lists = [["a", "b"], ["c", "d"]]
flatlist = lists.reduce(:+)  # ["a", "b", "c", "d"]

a = ['a', 'b']
b = ['c', 'd']
arr = [a, b].flatten

Esto no eliminará dups, pero

a|b

elimina dups.

Me resulta más fácil empujar o agregar matrices y luego aplanarlas en su lugar, así:

somearray = ["some", "thing"]
anotherarray = ["another", "thing"]
somearray.push anotherarray # => ["some", "thing", ["another", "thing"]]
#or
somearray << anotherarray # => ["some", "thing", ["another", "thing"]]
somearray.flatten!  # => ["some", "thing", "another", "thing"]
somearray # => ["some", "thing", "another", "thing"]

somearray = ["some", "thing"]

anotherarray = ["otro", "cosa"]

somearray + anotherarray