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>