LISTAS

Las listas son uno de los aspectos más importantes de PROLOG, ya que de esta manera se trabaja con estructuras de datos organizadas y netamente recursivas. La recursividad (http://virtual.cuautitlan.unam.mx/intar/?page_id=185) es una de las grandes fortalezas de PROLOG, por lo que por medio de las listas se pueden explotar las características inherentes del lenguaje.

Una lista es una representación de un conjunto de elementos. Dentro de PROLOG se pueden generar listas de diferentes tipos tales como una lista de valores numéricos [1, 2, 3…], listas de valores alfabéticos [a, b, c,…], o listas de valores alfanuméricos [a, b, 1, 2, c, 3,…]. Como ya se ha observado una lista se representa como un conjunto de elementos encerrados entre corchetes:

Pero también tenemos la lista vacía  [ ]. Así como la generación de listas de listas

PROLOG, identifica de manera automática este tipo de elementos como predicados de 2 secciones, tal como se ve a continuación:

[Cabeza | Cola]

PROLOG separa las listas en Cabeza y en Cola, la cabeza representa el primer elemento de una lista, y la cola todos los elementos restantes de la misma.

Ejemplo 1. Identifica la cabeza y a cola de la siguiente lista [1, 2, 3, 4, 5, 6].

Como se mencionó, PROLOG separa por defecto en estos dos elementos, entre el primer componente de la lista y el resto de ellos, por lo tanto tenemos que:

Cabeza=1

Cola= [2, 3, 4, 5, 6]

Ejemplo 2. Realizar un programa recursivo que encuentre el máximo valor de una lista de valores.

Este ejercicio se puede resolver por medio del siguiente código

Donde se tiene que la función máximo_valor, se llama a si misma en una interacción recursiva. Tenemos que max(X,Y), es una función definida que devuelve el valor máximo entre dos valores.

Algunas funciones para trabajar con listas

append

Existen funciones definidas que ayudaran a trabajar con listas, por ejemplo append, la cual concatena dos listas y devuelve una tercer lista concatenada, por ejemplo:

X dará como resultado [1, 2, 3, a, b, c].

También se tiene el comando append([[…], […],…..,[…]], X), que realizara la concatenación de todas las listas que conforman una lista de listas.

member

member, por otro lado, nos dirá si un elemento es miembro o no de una lista. Por ejemplo, la siguiente función, dará como resultado False

Pero la siguiente función, dará como resultado True.

prefix

Este comando sirve para identifica si el primer argumento dentro de prefix es una sub cadena del segundo argumento, por ejemplo, si nosotros realizamos la siguiente consulta

La respuesta será true. Pero si realizamos la siguiente consulta,

La respuesta será false.

select

Tenemos la siguiente consulta select(Elimina, Lista1, Lista2). En este caso, este comando dará True si al quitar el elemento Elimina de la Lista1, da como resultado la Lista2, de otra forma, será false. Por ejemplo, la siguiente consulta dará como resultado true

Pero la siguiente consulta, da como resultado false.

reverse

Este comando da como resultado true, si la lista 2 es el inverso de la lista 1, dentro del siguiente esquema reverse(Lista1, Lista2). Por ejemplo, tenemos que si consultamos la siguiente línea, el resultado será true,

Pero si consultamos la siguiente línea, el resultado será false

permutation

Este comando nos devuelve un true si la lista 2 es una permutación de la lista 1, y un false si no lo es. Por ejemplo:

?- permutation([1,2,3,4], [2,3,1,4]).

true ;

?- permutation([1,2,3,4], [2,3,1,5]).

false.

Sin embargo, también nos pude devolver todas las listas que sean permutaciones de la lista 1, tal como se puede ver en el siguiente ejemplo.

?- permutation([1,2,3,4], A).

A = [1, 2, 3, 4] ;

A = [1, 2, 4, 3] ;

A = [1, 3, 2, 4] ;

A = [1, 3, 4, 2] ;

A = [1, 4, 2, 3] ;

A = [1, 4, 3, 2] ;

A = [2, 1, 3, 4] ;

A = [2, 1, 4, 3] ;

A = [2, 3, 1, 4] ;

A = [2, 3, 4, 1] ;

A = [2, 4, 1, 3] ;

A = [2, 4, 3, 1] ;

A = [3, 1, 2, 4] ;

A = [3, 1, 4, 2] ;

A = [3, 2, 1, 4] ;

A = [3, 2, 4, 1] ;

A = [3, 4, 1, 2] ;

A = [3, 4, 2, 1] ;

A = [4, 1, 2, 3] ;

A = [4, 1, 3, 2] ;

A = [4, 2, 1, 3] ;

A = [4, 2, 3, 1] ;

A = [4, 3, 1, 2] ;

A = [4, 3, 2, 1] ;

false.