Usando Mathematica Reunir/Recoger adecuadamente

Question

¿Cómo uso Mathematica de Gather/Recoger/transporte funciones para convertir:

{ { {1, foo1}, {2, foo2}, {3, foo3} }, { {1, bar1}, {2, bar2}, {3, bar3} } } 

a

{ {1, foo1, bar1}, {2, foo2, bar2}, {3, foo3, bar3} } 

EDIT: Gracias! Esperaba que hubiera una manera simple, ¡pero supongo que no!

Answer 1

Aquí está la lista:

tst = {{{1, foo1}, {2, foo2}, {3, foo3}}, {{1, bar1}, {2, bar2}, {3, bar3}}} 

Aquí es una manera:

In[84]:= 
Flatten/@Transpose[{#[[All,1,1]],#[[All,All,2]]}]&@ 
    GatherBy[Flatten[tst,1],First] 

Out[84]= {{1,foo1,bar1},{2,foo2,bar2},{3,foo3,bar3}} 

EDITAR

Aquí es una versión completamente diferente, sólo por diversión:

In[106]:= 
With[{flat = Flatten[tst,1]}, 
    With[{rules = Dispatch[Rule@@@flat]}, 
     Map[{#}~Join~ReplaceList[#,rules]&,DeleteDuplicates[flat[[All,1]]]]]] 

Out[106]= {{1,foo1,bar1},{2,foo2,bar2},{3,foo3,bar3}} 

EDIT 2

Y aquí es otra manera, utilizando listas enlazadas y función interna para acumular los resultados:

In[113]:= 
Module[{f},f[x_]:={x}; 
    Apply[(f[#1] = {f[#1],#2})&,tst,{2}]; 
    Flatten/@Most[DownValues[f]][[All,2]]] 

Out[113]= {{1,foo1,bar1},{2,foo2,bar2},{3,foo3,bar3}} 

EDITAR 3

bien, para aquellos que se consideran todos de los anteriores demasiado complicados, aquí hay una solución basada en reglas muy simple:

In[149]:= 
GatherBy[Flatten[tst, 1], First] /. els : {{n_, _} ..} :> {n}~Join~els[[All, 2]] 

Out[149]= {{1, foo1, bar1}, {2, foo2, bar2}, {3, foo3, bar3}} 

Answer 2

Tal vez un poco demasiado complicado, pero:

lst = {{{1, foo1}, {2, foo2}, {3, foo3}}, {{1, bar1}, {2, bar2}, {3, bar3}}} 

Map[ 
    Flatten, 
    {Scan[Sow[#[[1]]] &, 
       Flatten[lst, 1]] // Reap // Last // Last // DeleteDuplicates, 
    Scan[Sow[#[[2]], #[[1]]] &, 
      Flatten[lst, 1]] // Reap // Last} // Transpose 
] 
(* 
{{1, foo1, bar1}, {2, foo2, bar2}, {3, foo3, bar3}} 
*) 

Así es como funciona esto:

Scan[Sow[#[[1]]] &, 
    Flatten[lst, 1]] // Reap // Last // Last // DeleteDuplicates 

devuelve los primeros elementos únicos de cada uno de los elementos de la lista, en el orden en que fueron sembradas (ya DeleteDuplicates Nunca reordena los elementos). Entonces,

Scan[Sow[#[[2]], #[[1]]] &, 
     Flatten[lst, 1]] // Reap // Last 

explota el hecho de que Reap devuelve expresiones sembradas con etiquetas de diferencia en las diferentes listas. Entonces, júntelos y transpórtelos.

Esto tiene la desventaja de que escaneamos dos veces.

EDIT:

Este

Map[ 
    Flatten, 
    {DeleteDuplicates@#[[1]], 
      Rest[#]} &@Last@Reap[ 
       Scan[(Sow[#[[1]]]; Sow[#[[2]], #[[1]]];) &, 
        Flatten[lst, 1]]] // Transpose 
] 

es (muy) poco más rápido, pero es aún menos legible ...

Answer 3

Quizás más fácil:

tst = {{{1, foo1}, {2, foo2}, {3, foo3}}, {{1, bar1}, {2, bar2}, {3, bar3}}}; 

GatherBy[Flatten[tst, 1], First] /. {{k_, n_}, {k_, m_}} -> {k, n, m} 
(* 
-> {{1, foo1, bar1}, {2, foo2, bar2}, {3, foo3, bar3}} 
*) 

Answer 4

MapThread

Si el "nombre" y sublistas "bar" están garantizados para estar alineados entre sí (como en el ejemplo) y si se considere el uso de funciones distintas de Gather/Collect/Transpose, entonces será suficiente MapThread:

data={{{1,foo1},{2,foo2},{3,foo3}},{{1,bar1},{2,bar2},{3,bar3}}}; 

MapThread[{#1[[1]], #1[[2]], #2[[2]]}&, data] 

resultado:

{{1, foo1, bar1}, {2, foo2, bar2}, {3, foo3, bar3}} 

coincidencia de patrón

Si las listas son no alineados, también se puede utilizar la coincidencia de patrones recta y reemplazo (aunque yo no recomendaría este enfoque para grandes listas) :

data //. 
    {{h1___, {x_, foo__}, t1___}, {h2___, {x_, bar_}, t2___}} :> 
    {{h1, {x, foo, bar}, t1}, {h2, t2}} // First 

Sow/Reap

Un enfoque más eficiente para las listas no alineados utiliza Sow y Reap:

Reap[Cases[data, {x_, y_} :> Sow[y, x], {2}], _, Prepend[#2, #1] &][[2]] 

Answer 5

también sólo por diversión ...

DeleteDuplicates /@ Flatten /@ GatherBy[Flatten[list, 1], First] 

donde

list = {{{1, foo1}, {2, foo2}, {3, foo3}}, {{1, bar1}, {2, bar2}, {3, 
    bar3}}} 

Editar.

Algunos más divertido ...

Gather[#][[All, 1]] & /@ Flatten /@ GatherBy[#, First] & @ 
Flatten[list, 1] 

Answer 6

Aquí es cómo lo haría utilizando la versión de SelectEquivalents he publicado en What is in your Mathematica tool bag?

l = {{{1, foo1}, {2, foo2}, {3, foo3}}, {{1, bar1}, {2, bar2}, {3, bar3}}}; 

SelectEquivalents[ 
    l 
    , 
    MapLevel->2 
    , 
    TagElement->(#[[1]]&) 
    , 
    TransformElement->(#[[2]]&) 
    , 
    TransformResults->(Join[{#1},#2]&) 
] 

Este método es bastante genérico. Solía ​​usar funciones como GatherBy antes para tratar grandes listas que genero en las simulaciones de Monte-Carlo. Ahora con las implementaciones de SelectEquivalents para tales operaciones son mucho más intuitivas. Además, se basa en la combinación Reap and Sow, que es muy rápida en Mathematica.

Answer 7

hasta que la cuestión se actualiza para ser más claro y específico, asumiré lo que yo quiero, y sugerir esto:

UnsortedUnion @@@ #~Flatten~{2} & 

Ver: UnsortedUnion