Anexando a las filas de una tabla

Question

Tengo una lista bidimensional y una lista unidimensional. Me gustaría insertar la lista 1D en la lista 2D como una columna adicional. Por ejemplo:

array = {{a,1,2},{b,2,3},{c,3,4}}; 
column = {x,y,z}; 

convierte

final = {{a,1,2,x},{b,2,3,y},{c,3,4,z}}; 

he hecho esto de manera poco elegante:

Table[Insert[array[[i]], column[[i]], 4], {i, Length[array]}]; 

Mi pregunta: ¿cuál es la forma correcta de hacer esto en Mathematica? No creo que necesite el bucle que estoy usando. Mi solución se siente fea

Answer 1

Por ejemplo:

Transpose@Append[Transpose@array, column] 

También se puede hacer es una función de este modo:

subListAppend = Transpose@Append[Transpose@#1, #2] &; 
subListAppend[array, column] 

que hace que sea más fácil si se tiene que utilizar con frecuencia. Y, por supuesto, si desea insertar en cualquier lugar que no sea el final, puede usar Insert[].

subListInsert = Transpose@Insert[Transpose@#1, #2, #3] &; 
subListInsert[array, column, 2] 
--> {{a, x, 1, 2}, {b, y, 2, 3}, {c, z, 3, 4}} 

EDIT: Ya ha comenzado la discusión obligatoria optimización de la velocidad, he aquí algunos resultados utilizando this y una matriz 10000x200:

ArrayFlatten@{{array, List /@ column}}:    0.020 s 
Transpose@Append[Transpose@array, column]:   0.067 s 
MapThread[Append, {array, column}]:     0.083 s 
MapThread[Insert[#1, #2, 4] &, {array, column}]: 0.095 s 
Map[Flatten, Flatten[{array, column}, {2}]]:  0.26 s 
ConstantArray based solution:      0.29 s 
Partition[Flatten@Transpose[{array, column}], 4]: 0.48 s 

Y el ganador es ArrayFlatten!

Answer 2

Otra posibilidad es

result = ConstantArray[0, Dimensions[array] + {0, 1}]; 
result[[All, 1 ;; Last[Dimensions[array]]]] = array; 
result[[All, -1]] = column; 

que parece ser más rápido en mi equipo para grandes matrices numéricas, aunque requiere una variable adicional. Si está tratando con entradas con valores reales, querrá usar

result = ConstantArray[0.0, Dimensions[array] + {0, 1}]; 

para mantener las ganancias de velocidad.

También hay

MapThread[Append, {array, column}] 

que también es rápido (y elegante OMI) sino que desempaquetar el resultado. (Pero si tiene entradas simbólicas como en el ejemplo, que no es una preocupación.)

Answer 3

Still:

k= Partition[Flatten@Transpose[{#, {x, y, z}}], 4]& 

k@ {{a, 1, 2}, {b, 2, 3}, {c, 3, 4}} 

(* 
-> {{a, 1, 2, x}, {b, 2, 3, y}, {c, 3, 4, z}} 
*) 

Answer 4

¿Qué tal esto?

pos = 4; 
MapThread[Insert[#1, #2, pos] &, {array, column}] 

Answer 5

I (a veces) para transponer gusta con Aplanar, ya que trabaja con una matriz 'desigual'.

Map[Flatten, Flatten[{array, column}, {2}]] 

dando

{{a, 1, 2, x}, {b, 2, 3, y}, {c, 3, 4, z}}

Pero si, por ejemplo, la columna tiene sólo 2 elementos

column2 = {x, y}; 
Map[Flatten, Flatten[{array, column2}, {2}]] 

dando

{{a, 1, 2, x}, {b, 2, 3, y}, {c, 3, 4}}

(Transposición no funcionará aquí)

Answer 6

Aquí está mi trate de usar Ingreso

In[11]:= Join[array,List/@column,2] 
Out[11]= {{a,1,2,x},{b,2,3,y},{c,3,4,z}} 

podría ser comparable a la más rápida entre los programas antes mencionados.

Answer 7

Aunque no es tan práctico o eficiente como algunos de los métodos existentes, aquí hay dos más que añadir a la lista:

ArrayPad[array, {0,{0,1}}, List /@ column] 

PadRight[array, Dimensions[array] + {0, 1}, List /@ column]