Una lista es una colección de elementos, no necesariamente homogéneos. En Prolog, las listas son estructuras de datos incorporadas. Las listas se pueden usar para representar conjuntos, pilas, colas, listas vinculadas y varias estructuras de datos complejas, como árboles, gráficos, etc.
Notación básica y propiedades de las listas:
- Una lista en Prolog es una colección ordenada de elementos indicados como [i1, i2, …, in].
- A diferencia de las arrays en otros lenguajes de programación donde podemos acceder directamente a cualquier elemento de la array, las listas de prólogo permiten el acceso directo solo al primer elemento, que se denota como Head. Por lo tanto, podemos escribir una lista de prólogos como: [Cabeza | Rest], donde Rest es el resto de la lista excluyendo el primer elemento Head.
- Las listas de prólogo permiten tipos de datos no homogéneos de elementos de lista.
- Las listas anidadas de profundidades arbitrarias también están permitidas en prolog.
Algunas listas de ejemplo se muestran a continuación:
[] % empty list [a] % singleton list [hello, world] % 2 element list [[1,2,3,4], p, this] % 3 element list [[[1, 2], [3, 4]], [[a, b], [x, y]]]. % nested list (3 level nesting)
Operador de tubería (|):
En prolog, las listas tienen un solo operador, llamado tubería, denotado por |. Este operador se utiliza para añadir un elemento al principio de una lista. La sintaxis del operador de tubería es la siguiente:
[a | L] Here L is a list and a is a single element.
Por ejemplo:
If, L = [b,c,d] Then, [a | L] will result in [a,b,c,d]
Operador de corte (!):
En Prolog, el operador Cortar, denotado por ! es un objetivo que siempre tiene éxito, pero no se puede dar marcha atrás. Por ejemplo, considere el siguiente programa para encontrar el elemento máximo entre 2 números:
max_element(X, Y, X) :- X > Y. % If X > Y, then X is the max element max_element(X, Y, Y) :- X =< Y. % If X <= Y, then Y is the max element
Aquí si proporcionamos el objetivo como:
?- max_element(5, 2, Ans).
Este objetivo coincide con la primera regla porque 5 > 2 y el programa devuelve Ans = 5. Pero el programa no se detiene ahí. Continúa comprobando la siguiente regla también. Pero como ambas reglas son complementarias entre sí, podemos modificar este programa usando cut de la siguiente manera:
% If X > Y, max element is X and do not check the next rule for the current goal max_element(X, Y, X) :- X > Y, !. % If the first rule fails, then Y will definitely be the max element. % Therefore, no need to put conditionals anymore max_element(X, Y, Y).
Operaciones en listas de prólogos:
1. Encuentra la longitud de una lista L
% length of empty list is 0 (base case)
list_length([], 0).
list_length([_ | L], N) :-
list_length(L, N1),
N is N1 + 1.
% If length of L is N1, then length of [_ | L] will be N1 + 1
Consulta:
?- list_length([a, b, c, d], N). N = 4.
2. Determinar si un elemento X pertenece a una lista L
is_member(X, [X | _]) :- !. % If the head of the list is X is_member(X, [_ | Rest]) :- % else recur for the rest of the list is_member(X, Rest).
Consulta:
?- is_member(c, [a, b, c, d]). true. ?- is_member(f, [a, b, c, d]). false.
3. Agregue una lista L2 al final de otra lista L1 y coloque la lista resultante en L3
% If L1 is empty, resultant list will be equal to L2 (base case)
append_list([], L2, L2).
append_list([X | L1], L2, [X | L3]) :-
append_list(L1, L2, L3).
Consulta:
?- append_list([a, b, c], [p, q], Ans). Ans = [a, b, c, p, q].
4. Insertar un elemento X al final de una lista L
insert_end(L, X, NewL) :- append_list(L, [X], NewL).
Consulta:
?- insert_end([1, 2, 3], 7, Ans). Ans = [1, 2, 3, 7].
5. Eliminar la primera aparición de un elemento X de una lista L
% Deletion of any element from empty list will produce empty list(base case)
delete_element(_, [], []).
delete_element(X, [X | L], L) :- !.
delete_element(X, [Y | L], [Y | L1]) :-
delete_element(X, L, L1).
Consulta:
?- delete_element(b, [a, b, c, b, d], Ans). Ans = [a, c, b, d].