5.6. Operaciones sobre listas

5.6.1. Creando listas

Podemos crear listas de varias formas:

1. Declarandolas directamente:

   In> NuevaLista:={2,5,6};
   Out> {2,5,6};
   In>
   	    

2. Utilizando la funci�n List:

   Ejemplo 5-24. Uso de List

   In> NuevaLista:=List(2,5,6);
   Out> {2,5,6};
   In> OtraLista:=List(NuevaLista,a,b,c);
   Out> {{2,5,6},a,b,c};
   In>	      
   	      

   Una lista puede ser un elemento de otra lista.

3. Podemos crear una lista concatenando varias con Concat:

   Ejemplo 5-25. Uso de Concat

   In> PrimeraLista:={a,b,c,d};
   Out> {a,b,c,d};
   In> SegundaLista:={1,3,5,7,11};
   Out> {1,3,5,7,11};
   In> ListaFinal:=Concat(PrimeraLista,SegundaLista)
   Out> {a,b,c,d,1,3,5,7,11};
   In>
   	      

   Hay que tener en cuenta que de esta forma pueden aparecer elementos duplicados:

   In> PrimeraLista:={a,b,c,d};
   Out> {a,b,c,d};
   In> SegundaLista:={d,1,f,a};
   Out> {d,1,f,a};
   In> Concat(PrimeraLista, SegundaLista);
   Out> {a,b,c,d,d,1,f,a};
   In>
   	    

4. Podemos crear una lista como la uni�n de otras dos con Union:

   Ejemplo 5-26. Uso de Union

   In> PrimeraLista:={a,b,c,d};
   Out> {a,b,c,d};
   In> SegundaLista:={d,1,f,a};
   Out> {d,1,f,a};
   In> Union(PrimeraLista,SegundaLista);
   Out> {a,b,c,d,1,f};
   In>
   	      

   Observar que en este caso se eliminan los elementos repetidos, no como con Concat.

5. Podemos crear una lista como la intersecci�n de otras dos con Intersection:

   Ejemplo 5-27. Uso de Intersection

   In> PrimeraLista:={a,b,c,d};
   Out> {a,b,c,d};
   In> SegundaLista:={d,1,f,a};
   Out> {d,1,f,a};
   In> Intersection(PrimeraLista, SegundaLista);
   Out> {a,d};
   In>
   	      

6. Podemos crear una lista que sea la diferencia de dos listas con Difference:

   Ejemplo 5-28. Uso de Difference

   In> PrimeraLista:={a,b,c,d};
   Out> {a,b,c,d};
   In> SegundaLista:={d,1,f,a};
   Out> {d,1,f,a};
   In> Difference(PrimeraLista, SegundaLista);
   Out> {b,c};
   In>
   	      

   Se mostrar�n los elementos que est�n en PrimeraLista y que no est�n en SegundaLista, preservando el orden.

   Tenemos que destacar que si hay un cierto elemento que parece n veces en la primera lista y m veces en la segunda entonces aparecer� n-m veces en la diferencia.

7. Podemos crear una lista con todos sus componentes iguales utilizando FillList:

   Ejemplo 5-29. Uso de FillList

   In> FillList(Pi,5);
   Out> {Pi,Pi,Pi,Pi,Pi};
   In>
   	      

8. Podemos crear listas eliminando elementos de una lista ya creada con Drop:

   Ejemplo 5-30. Uso de Drop

   In> Lista:={a,b,c,d,e,f,g,h,i,j,k};
   Out> {a,b,c,d,e,f,g,h,i,j,k};
   In> Drop(Lista,3);
   Out> {d,e,f,g,h,i,j,k}
   In> Drop(Lista,-3);
   Out> {a,b,c,d,e,f,g,h}
   In> Drop(Lista,{4,8});
   Out> {a,b,c,i,j,k};
   In> Lista;
   Out> {a,b,c,d,e,f,g,h,i,j,k};
   In>
   	      

   Drop elimina los elementos indicados.

9. Podemos crear listas cogiendo elementos de una lista ya creada con Take:

   Ejemplo 5-31. Uso de Take

   In> Lista:={a,b,c,d,e,f,g,h,i,j,k};
   Out> {a,b,c,d,e,f,g,h,i,j,k};
   In> Take(Lista,3);
   Out> {a,b,c}
   In> Take(Lista,-3);
   Out> {i,j,k}
   In> Take(Lista,{4,8});
   Out> {d,e,f,g,h};
   In> Lista;
   Out> {a,b,c,d,e,f,g,h,i,j,k};
   In>
   	      

   Take coge los elementos indicados.

10. Podemos crear listas evaluando una cierta expresi�n desde un punto hasta otro e indicando el paso:

    Ejemplo 5-32. Uso de Table

    In> Table(i,i,1.,2,.1);
    Out> {1,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2};
    In> Table(n!,n,2,5,1);
    Out> {2,6,24,120};
    In>
    	      

11. Podemos crear listas cuyos elementos sean n�meros consecutivos con el operador ..:

    Ejemplo 5-33. Uso del operador ..

    In> a:=1 .. 8;
    Out> {1,2,3,4,5,6,7,8};
    In>
    	      

5.6.2. Evaluaci�n de funciones sobre listas

Existen funciones que permiten su evaluaci�n sobre todos los elementos de una lista.

Este tipo de funciones son normalmente funciones num�ricas:

In> Valores:={Pi,3*Pi/2,0,2*Pi};
Out> {Pi,3*Pi/2,0,2*Pi};
In> Res:=Sin(Valores);
Out> {0,Sin((3*Pi)/2),0,Sin(2*Pi)};
In> N(Res);
Out> {0,-1.000000,0,0.000000};
In>
	

5.6.3. Operaciones aritm�ticas sobre listas

Podemos realizar operaciones aritm�ticas sobre listas:

• Con el operador +/- podemos sumar/restar listas:

  In> {1,2,3}+{3,2,1};
  Out> {4,4,4};
  In> 
  	    

  Las sumas/restas se har�n miembro a miembro.

• Con el operador * podemos multiplicar listas miembro a miembro:

  In> {1,2,3}*{4,5,6};
  Out> {4,10,18};
  In>
  	    

  Con este operador tambi�n podemos multiplicar todos los elementos de una lista por un escalar:

  In> a*{3,6,7};
  Out> {3*a,6*a,7*a};
  In>
  	    

• Con el operador / podemos dividir listas miembro a miembro:

  In> {2,3,4}/{5,6,7};
  Out> {2/5,1/2,4/7};
  In>
  	    

  Con este operador tambi�n podemos dividir todos los elementos de una lista por un escalar:

  In> {2,3,4}/4;
  Out> {1/2,3/4,1};
  In>
  	    

• Con el operador ^ podemos elevar los elementos de la primera lista a los de la segunda componente a componente:

  In> {2,3,5}^{0,2,-2};
  Out> {1,9,1/25};
  In>
  	    

  Con este operador tambi�n podemos elevar todos los elementos de una lista a un escalar:

  In> {2,3,5}^2;
  Out> {4,9,25};
  In>
  	    

5.6.4. Calculando la longitud de una lista

Para calcular la longitud de una lista podemos utilizar la funci�n Length:

In >a:={a,b,3,5,Sin(x)};
Out> {a,b,3,5,Sin(x)};
In> Length(a);
Out> 5;
In>
	  

5.6.5. Recuperando elementos de una lista

Tenemos varias funciones para recuperar elementos de una lista:

• Pare recuperar el primer elemento podemos utilizar Head:

  Ejemplo 5-35. Uso de Head

  In> MiLista:={a,b,c,d};
  Out> {a,b,c,d};
  In> Primer:=Head(MiLista);
  Out> a;
  In> MiLista;
  Out> {a,b,c,d};
  In>
  	      

  Head no elimina el primer elemento de la lista.

  Si Head es utilizado sobre una expresi�n devuelve el primer operando:

  In> Head(a*b);
  Out> a;
  In> Head(Hold((2*3)+(4^5)));
  Out> 2*3;	    
  In> Head(func(z,y,z));
  Out> a;
  In>
  	    

  Pero si Head es utilizado sobre un �tomo devolver� un error:

  In> Head((2*3)+(4^5));
  In function "Head" :
  bad argument number 1 (counting from 1)
  The offending argument 2*3+4^5 evaluated to 1030
  CommandLine(1) : Argument is not a list
   
  In>
  	    

• Podemos recuperar todos los elementos salvo el primero con Tail:

  Ejemplo 5-36. Uso de Tail

  In> Lista:={2,4,6,8};
  Out> {2,4,6,8};
  In> Tail(Lista);
  Out> {4,6,8};
  In>
  	      

• Para recuperar cualquier otro elemento o grupo de elementos de la lista podemos utilizar Nth:

  Ejemplo 5-37. Uso de Nth

  In> MiLista:={a,b,c,d,e,f};
  Out> {a,b,c,d,e,f};
  In> Nth(MiLista,5);
  Out> e;
  In> SubLista:=Nth(MiLista,{2,4,6});
  Out> {b,d,f};	      
  In> SubLista;
  Out> {b,d,f};	      
  In>
  	      

• Tambi�n podemos recuperar elementos de una lista utilizando []:

  In> MiLista:={a,b,c,d,e,f};
  Out> {a,b,c,d,e,f};
  In> MiLista[5];
  Out> e;
  In> SubLista:=MiLista[{2,4,6}];
  Out> {b,d,f};	      
  In> SubLista;
  Out> {b,d,f};	      
  In>
  	      

• Podemos seleccionar dentro de una lista aquellos elementos que cumplan una determinada condici�n utilizando Select:

  Ejemplo 5-38. Uso de Select

  In> MiLista:={2/3,a,4,{a,6,y},2*3,Hold(a+b=c),{{1,0},{0,1}},Sin(z),"Hola",2.5,2+4*I,Pi,{2,3,5}};
  Out> {2/3,a,4,{a,6,y},6,a+b=c,{{1,0},{0,1}},Sin(z),"Hola",2.5,Complex(2,4),Pi,{2,3,5}};
  In> Enteros:=Select("IsInteger",MiLista);
  Out> {4,6};
  In> Complejos:=Select("IsComplex",MiLista);
  Out> {4,6,2.5,Complex(2,4)};
  In> Matrices:=Select("IsMatrix",MiLista);
  Out> {{{1,0},{0,1}}};
  In> Racionales:=Select("IsRational",MiLista);
  Out> {2/3};
  In>
  	      

  La funci�n Select evalua el primer argumento sobre la lista y devuelve aquellos elementos de la lista que finalizaron con True.

5.6.6. Alterando una lista

Podemos eliminar elementos de una lista:

• Utilizando Delete se devuelve una lista nueva sin el elemento seleccionado:

  Ejemplo 5-39. Uso de Delete

  In> Lista:={2,b,4,d};
  Out> {2,b,4,d};
  In> Delete(Lista,3);
  Out> {2,b,d};
  In>
  	      

• Utilizando DestructiveDelete eliminamos un elemento de la lista indicada:

  Ejemplo 5-40. Uso de DestructiveDelete

  In> Lista:={2,b,4,d};
  Out> {2,b,4,d};
  In> DestrutiveDelete(Lista,3);
  Out> {2,b,d};
  In> Lista;
  Out> {2,b,d};
  In>
  	      

Podemos reemplazar elementos en una lista utilizando Replace y DestructiveReplace. Su funcionamiento es similar a Delete y DestructiveDelete, pero reemplazando elementos en lugar de eliminarlos. Estas funciones tienen un tercer elemento que ser� el elemento que sustituir� al elemento indicado por el segundo argumento en la lista indicada por el primer argumento.

In> MiLista:={a,b,c,d,e};
Out> {a,b,c,d,e};
In> Replace(MiLista,3,C);
Out> {a,b,C,d,e};
In> MiLista;
Out> {a,b,c,d,e};
In> DestructiveReplace(MiLista,3,C);
Out> {a,b,C,d,e};
In> MiLista;
Out> {a,b,C,d,e};
In>
	  

Tambi�n podemos insertar elementos en una lista utilizando Insert y DestructiveInsert. Su funcionamiento es similar a Replace y DestructiveReplace, pero insertando el tercer argumento que se le pasa en la posici�n indicada por el segundo argumento en la lista indicada por el primer argumento.

In> MiLista:={a,b,d,e};
Out> {a,b,d,e};
In> Insert(MiLista,3,C);
Out> {a,b,C,d,e};
In> MiLista;
Out> {a,b,d,e};
In> DestructiveInsert(MiLista,3,C);
Out> {a,b,C,d,e};
In> MiLista;
Out> {a,b,C,d,e};
In>
	  

Podemos a�adir elementos a una lista con Append y DestructiveAppend. Su funcionamiento es similar a los anteriores y tiene dos argumentos, el primero es la lista a la que se le a�adir� el elemento que se especifica como segundo argumento. El elemento se a�adir� al final de la lista.

In> MiLista:={a,b,c,d,e};
Out> {a,b,c,d,e};
In> Append(MiLista,Infinity);
Out> {a,b,c,d,e,Infinity};
In> MiLista;
Out> {a,b,c,d,e};
In> DestructiveAppend(MiLista,Undefined);
Out> {a,b,c,d,e,Undefined};
In> MiLista;
Out> {a,b,c,d,e,Undefined};
In>
	  

Podemos eliminar elementos duplicados en una lista utilizando RemoveDuplicates:

In> MiLista:={a,b,c,a,d,b,c,e};
Out> {a,b,c,a,d,b,c,e};
In> RemoveDuplicates(MiLista);
Out> {a,b,c};
In> MiLista;
Out> {a,b,c,a,d,b,c,e};
In>
	  

Tambi�n es posible intercambiar dos elementos con la funci�n Swap:

In> Lista:={a,b,c,d,e,f};
Out> {a,b,c,d,e,f};
In> Swap(Lista,1,2);
Out> True;
In> Lista;
Out> {b,a,c,d,e,f};
In>
	  

5.6.7. Contando ocurrencias

Podemos contar el n�mero de ocurrencias de un elemento en una lista con Count:

In> Lista:={a,b,a,c,e,a,g,a};
Out> {a,b,a,c,e,a,g,a};
In> Count(Lista,a);
Out> 4;
In>
	  

5.6.8. Encontrando un elemento en una lista

Podemos encontrar la posici�n que ocupa un determinado elemento en una lista con Find:

In> Lista:={a,b,c,b,e,d};
Out> {a,b,c,b,e,d};
In> Find(Lista,b);
Out> 2;
In> Find(Lista,Pi);
Out> -1;
In>
	  

Si el elemento aparece m�s de una vez devuelve la posici�n de la primera ocurrencia. En caso de no aparecer en la lista devolver� un -1.

5.6.9. Ordenando listas

Podemos ordenar listas de la siguiente manera:

1. Con la funci�n BubbleSort. De esta forma se utiliza el algoritmo de la burbuja:

   Ejemplo 5-48. Uso de BubbleSort

   In> Lista:={2,6,7,84,5,2,8,-4};
   Out> {2,6,7,84,5,2,8,-4};
   In> BubbleSort(Lista,>);
   Out> {84,8,7,6,5,2,2,-4};
   In> BubbleSort(Lista,<);
   Out> {-4,2,2,5,6,7,8,84};
   In> Lista;
   Out> {2,6,7,84,5,2,8,-4};
   In>
   	      

   El tercer argumento es la funci�n de ordenamiento, para valores num�ricos podemos utilizar > y < como funciones de ordenamiento.

   En el caso de querer ordenar una lista con valores no num�ricos deberemos construir una funci�n de ordenamiento que tendr� que verificar:

   • Ser� una funci�n que requiera dos argumentos.

   • Unicamente devolver� los valores True y False.

   • Devolver� el valor True si el segundo argumento tiene que ir despu�s del primero en la lista ordenada.

   • Devolver� el valor False en el resto de casos.

   El algoritmo de la burbuja es ineficiente para listas grandes. En el caso de tener que reordenar listas grandes se deber�a utilizar la funci�n del siguiente punto.

2. Con la funci�n HeapSort:

   Ejemplo 5-49. Uso de HeapSort

   In> Lista:={2,6,7,84,5,2,8,-4};
   Out> {2,6,7,84,5,2,8,-4};
   In> HeapSort(Lista,>);
   Out> {84,8,7,6,5,2,2,-4};
   In> HeapSort(Lista,<);
   Out> {-4,2,2,5,6,7,8,84};
   In> Lista;
   Out> {2,6,7,84,5,2,8,-4};
   In>
   	      

   El tercer argumento es la funci�n de ordenamiento, para valores num�ricos podemos utilizar > y < como funciones de ordenamiento.

   En el caso de querer ordenar una lista con valores no num�ricos deberemos construir una funci�n de ordenamiento que tendr� que verificar:

   • Ser� una funci�n que requiera dos argumentos.

   • Unicamente devolver� los valores True y False.

   • Devolver� el valor True si el segundo argumento tiene que ir despu�s del primero en la lista ordenada.

   • Devolver� el valor False en el resto de casos.

   Este argumento es mucho m�s eficiente que el de la burbuja para listas grandes.

5.6.10. Particionando una lista

Podemos partir una lista en trozos de igual longitud con Partition:

In> Lista:={a,b,c,d,e,f,g};
Out> {a,b,c,d,e,f,g};
In> Partition(Lista,2);
Out> {{a,b},{c,d},{e,f}};
In>
	  

Todos los miembros de la nueva lista tendr�n la longitud especificada, y los que sobren no se incluir�n.

5.6.11. Permutaciones de una lista

Podemos calcular las permutaciones de un conjunto de n elementos con Permutations:

In> Permutations({a1,a2,a3});
Out> {{a1,a2,a3},{a1,a3,a2},{a3,a1,a2},{a2,a1,a3},{a2,a3,a1},{a3,a2,a1}};
In>