MANIPULACIÓN DE LISTAS

Repasamos en los siguientes ejercicios algunas de las reglas de manejo de listas.

- Construir una matriz NxM:  Matriz=Table[a(j,k),{j,1,N},{k,1,M}]

Matriz=Table[a[j,k],{j,1,5},{k,1,3}]

     {{a[1, 1], a[1, 2], a[1, 3]}, {a[2, 1], a[2, 2], a[2, 3]}, 
      
       {a[3, 1], a[3, 2], a[3, 3]}, {a[4, 1], a[4, 2], a[4, 3]}, 
      
       {a[5, 1], a[5, 2], a[5, 3]}}

En forma matricial:

MatrixForm[Matriz]

     a[1, 1]   a[1, 2]   a[1, 3]
     
     a[2, 1]   a[2, 2]   a[2, 3]
     
     a[3, 1]   a[3, 2]   a[3, 3]
     
     a[4, 1]   a[4, 2]   a[4, 3]
     
     a[5, 1]   a[5, 2]   a[5, 3]

- Aplicar una función f a cada elemento de una lista: Map[f,lista]. Por ejemplo, definamos puntos en el espacio, con las coordenadas de la matriz anterior:

MatrixForm[Map[Point,Matriz]]

     Point[{a[1, 1], a[1, 2], a[1, 3]}]
     
     Point[{a[2, 1], a[2, 2], a[2, 3]}]
     
     Point[{a[3, 1], a[3, 2], a[3, 3]}]
     
     Point[{a[4, 1], a[4, 2], a[4, 3]}]
     
     Point[{a[5, 1], a[5, 2], a[5, 3]}]

- Existen ocasiones en las que al aplicar Map, no nos interesa que aparezcan las llaves dentro de la variable de la función. Así, si en vez de aplicar Point a la matriz utilizamos RGBColor (que determina el color de un punto en el espacio), obtenemos:

MatrixForm[Map[RGBColor,Matriz]]

     RGBColor[{a[1, 1], a[1, 2], a[1, 3]}]
     
     RGBColor[{a[2, 1], a[2, 2], a[2, 3]}]
     
     RGBColor[{a[3, 1], a[3, 2], a[3, 3]}]
     
     RGBColor[{a[4, 1], a[4, 2], a[4, 3]}]
     
     RGBColor[{a[5, 1], a[5, 2], a[5, 3]}]

lo que no es correcto, ya que RGBColor necesita 3 variables y no una lista de 3 elementos.  Otro ejemplo vendría dado al considerar la función f[x,y,z]=x+y+z:

f[x_,y_,z_]:=x+y+z;
MatrixForm[Map[f,Matriz]]

     f[{a[1, 1], a[1, 2], a[1, 3]}]
     
     f[{a[2, 1], a[2, 2], a[2, 3]}]
     
     f[{a[3, 1], a[3, 2], a[3, 3]}]
     
     f[{a[4, 1], a[4, 2], a[4, 3]}]
     
     f[{a[5, 1], a[5, 2], a[5, 3]}]

y no obtenemos la suma de las componentes. La manera correcta es utilizar Apply a la matriz transpuesta:

MatrixForm[Apply[f,Transpose[Matriz]]]

     a[1, 1] + a[1, 2] + a[1, 3]
     
     a[2, 1] + a[2, 2] + a[2, 3]
     
     a[3, 1] + a[3, 2] + a[3, 3]
     
     a[4, 1] + a[4, 2] + a[4, 3]
     
     a[5, 1] + a[5, 2] + a[5, 3]

En el caso de RGBColor, como no es listable, tenemos que asignarle ese atributo:

SetAttributes[RGBColor,Listable];
Attributes[RGBColor]

     {Listable, Protected}

Ahora vemos que funciona correctamente:

MatrixForm[Apply[RGBColor,Transpose[Matriz]]]

     RGBColor[a[1, 1], a[1, 2], a[1, 3]]
     
     RGBColor[a[2, 1], a[2, 2], a[2, 3]]
     
     RGBColor[a[3, 1], a[3, 2], a[3, 3]]
     
     RGBColor[a[4, 1], a[4, 2], a[4, 3]]
     
     RGBColor[a[5, 1], a[5, 2], a[5, 3]]

Otra posibilidad es utilizar reglas de substitución:

MatrixForm[Map[RGBColor,Matriz]
    /.RGBColor[{x__}]->RGBColor[x]]

     RGBColor[a[1, 1], a[1, 2], a[1, 3]]
     
     RGBColor[a[2, 1], a[2, 2], a[2, 3]]
     
     RGBColor[a[3, 1], a[3, 2], a[3, 3]]
     
     RGBColor[a[4, 1], a[4, 2], a[4, 3]]
     
     RGBColor[a[5, 1], a[5, 2], a[5, 3]]

- Si queremos combinar los elementos de 2 listas, lista1 y lista2, de manera que los términos en la misma posición se agrupen en pares, una forma rápida de hacerlo es la siguiente:
Transpose[{lista1,lista2}]. Por ejemplo, asociar a cada vocal la posición que ocupa (del 1 al 5):

vocal={a,e,i,o,u};posicion={1,2,3,4,5};
Transpose[{vocal,posicion}]

     {{a, 1}, {e, 2}, {i, 3}, {o, 4}, {u, 5}}

Ejercicio 1: Generar una lista de N puntos aleatorios en el cubo unidad. Dibujarlos mediante Show y Graphics3D en color según su posición, de manera que los puntos que estén próximos tengan colores similares.

- El comando AppendTo[lista,x] añade el elemento x a lista.

lista={y};AppendTo[lista,x];lista

     {y, x}

- Flatten aplicado a una lista de listas, genera una única lista con todos los elementos.

Flatten[{{1,2,4},3,{5,6}}]

     {1, 2, 4, 3, 5, 6}

- Take[lista,n] selecciona los n primeros elementos de lista.

Take[{1,2,3,{4,5},6},4]

     {1, 2, 3, {4, 5}}

- Cases[lista,propiedad] genera una lista con todos los elementos de lista que satisfacen propiedad.

Cases[{1,2,3,4,4},4]

     {4, 4}

Ejercicio 2: Representar gráficamente el número de veces que se repiten las cifras del 0 al 9, en la expresión con N decimales del número π.

Solución al Ejercicio 1:

SetAttributes[RGBColor,Listable];
Nu=1000;
q=Table[Random[],{Nu},{3}];
qq=Map[Point,q];
rr=Apply[RGBColor,Transpose[q]];
pun=Transpose[{rr,qq}];
Show[Graphics3D[pun]]

Solución al Ejercicio 2:

Nu=5000;
decimales=Flatten[Take[RealDigits[N[Pi,Nu]],1]];

Contador={};
Do[AppendTo[Contador,{k,Length[Cases[decimales,k]]}],
    {k,0,9}];
ListPlot[Contador,PlotJoined->True]