Prolog aprendiendo Estructura de una lista Una lista

Prolog aprendiendo…

Estructura de una lista • Una lista en Prolog (como en casi cualquier lenguaje que use listas) se divide en dos partes: – Cabeza. Es el primer elemento de la lista. Puede ser un ´atomo o una lista, pero a fin de cuentas es el primer elemento de la lista original. – Cola. Es el resto de los elementos de una lista, es de nuevo una lista.

• Ejemplos: – L=[perro, gato, raton, queso] • (a) cabeza= perro • (b) cola=[gato, raton, queso] • L=[[perro, gato], [raton, queso]] – (a) cabeza=[perro, gato] – (b) cola=[[raton, queso]] • L=[perro] – (a) cabeza=perro – (b) cola=[] la lista vac´ıa • (L=[] – (a) cabeza= NO – (b) cola=[] la lista vacia

Manejo del contenido de las listas En primer lugar, la existencia de un elemento en la lista se puede verificarse con una regla como: pertenece(E, L): L=[E| ]. Que dice que el elemento E pertenece a la lista L si L se puede hacer teniendo una lista cuya cabeza sea E y cualquier cola, incluso la lista vacıa. Pero esto solamente nos asegura la pertenencia de la cabeza de la lista, no si un elemento esta dentro de ella. Para esto se necesita una segunda clausula recursiva: pertenece(E, [ |T]): pertenece(E, T). Es decir “un elemento E pertenece a una lista compuesta de cualquier cabeza y una cola T, si ese mismo elemento E es la cabeza del resto de la lista T”. Ası se tiene el siguiente programa en Prolog que verifica la pertenencia de un elemento en una lista: pertenece(E, L): L=[E|_]. pertenece(E, [_|T]): pertenece(E, T). : pertenece(E, [a, b, c, d, e]. )

pertenece(E, L): L=[E|_]. pertenece(E, [_|T]): pertenece(E, T). Pregunta: pertenece(E, [a, b, c, d, e]).

CABEZA Y COLA DE LISTAS • Si se tiene la lista [a, b, c, d], la a es la cabeza y la cola es la lista [b, c, d] • Una lista cuya cabeza es A y cola es B se anota como [A | B] • El predicado primer_elemento(X, [X|_]). tiene éxito si X es el primer elemento de la lista.

LISTAS

Operadores especiales

imprimir( [A | B] ): write(A), imprimir(B). Pregunta: imprimir([1, 2, 6, 5, 7, 8, 3, 6, 4]).

Comparación de términos en PROLOG. X<Y /*X es menor que Y*/ X>Y /*X es mayor que Y*/ X=<Y /*X es menor o igual que Y*/ X>=Y /*X es mayor o igual que Y*/ X=Y /*X es igual que Y*/ X=Y /X es distinto que Y*/

Comparación de expresiones en PROLOG. X==Y /*la expresión X es igual que la expresión Y*/ X==Y /*la expresión X es distinta que la expresión Y*/ X@<Y /*la expresión X es menor que la expresión Y*/ X@>Y /*la expresión X es mayor que la expresión Y*/ X@=<Y /*la expresión X es menor o igual que la expresión Y*/ X@>=Y /*la expresión X es mayor o igual que la expresión Y*/

suma(X, Y, Z) : Z is X+Y. Preguntas: suma(2, 3, Z).

Construcción de expresiones aritméticas en PROLOG X+Y /*suma*/ X Y /*resta*/ X*Y /*multiplicación*/ X/Y ó X div Y /*división real y entera*/ X mod Y /*resto de la división de X entre Y*/ X^Y /*X elevado a Y*/ X /*negación*/ abs(X) /*valor absoluto de X*/ acos(X) /*arco coseno de X*/ asen(X) /*arco seno de X*/ atan(X) /*arco tangente de X*/ cos(X) /*coseno de X*/ exp(X) /*exponencial de X; [e. X ]*/ ln(X) /*logaritmo neperiano de X*/ log(X) /*logaritmo en base 2 de X*/ sin(X) /*seno de X*/ sqrt(X) /*raíz cuadrada de X*/ tan(X) /*tangente de X*/ round(X, N) /*redondeo del real X con N decimales*/

arcotan(X, Z) : Z is atan(X). Pregunta: arcotan(10, Z).

X is 3*5+3/2. /*PROLOG contestaría X=9*/ Pregunta: X is 3*5+3/2.

Determinar si lo que se recibe es una lista([]): !. lista([_X|Y]): lista(Y). Pregunta: ? lista([1, 2]).

Devuelve la longitud de la lista que se le pasa por argumento. long([], 0): !. long([_X|Y], S): long(Y, T), S is T+1. Pregunta: ? long([1, 3, 7, 4], X).

Maximo elemento de una lista maximo([X], X). maximo([X|Xs], X): maximo(Xs, Y), X >=Y. maximo([X|Xs], N): maximo(Xs, N), N > X. Pregunta: ? maximo([1, 5, 3, 2], X).

Mínimo elemento de una lista minimo([X], X). minimo([X|Xs], X): minimo(Xs, Y), X =< Y. minimo([X|Xs], N): minimo(Xs, N), N < X. Preguntas: minimo([1, 5, 3, 2], X).

Determina si una lista es estrictamente creciente crece([_X]). crece([X, Y|Z]): X<Y, crece([Y|Z]). Preguntas: crece([1, 2, 3]). crece([2, 2, 3]).

Determina si una lista es estrictamente decreciente decrece([_X]). decrece([X, Y|Z]): X>Y, decrece([Y|Z]). Preguntas: decrece([3, 2, 1]). decrece([3, 2, 2]).

Determina si dos listas son iguales en todos los niveles lista([]): !. lista([_X|Y]): lista(Y). lista. Igual([], []): !. lista. Igual([X|M], [X|R]): lista. Igual(M, R). lista. Igual([X|M], [T|R]): lista(X), lista(T), lista. Igual(X, T), lista. Igual(M, R). Preguntas: lista. Igual([1, 2, [5, 2], 3], [[1, 2, [5, 2], 3], 9]). lista. Igual([1, 2, [5, 2], 3], [1, 2, [5, 2], 3]).

concatenar dos listas concatenar([], L, L): !. concatenar([X|M], L, [X|Y]): concatenar(M, L, Y). Preguntas: concatenar([1, 2], [3, 4], X).

Invierte la lista en el primer nivel concatenar([], L, L): !. concatenar([X|M], L, [X|Y]): concatenar(M, L, Y). invertir([], []): !. invertir([X], [X]): !. invertir([X|M], L): invertir(M, S), concatenar(S, [X], L). Preguntas: invertir([3, 2, [1, 6], 7, 4], X).

capicua • se refiere a cualquier número simétrico que, por ello, se lee igual de izquierda a derecha que de derecha a izquierda. – Ejemplos: 716. 617, 96. 700. 769.

Determina si una lista es capicua concatenar([], L, L): !. concatenar([X|M], L, [X|Y]): concatenar(M, L, Y). invertir([], []): !. invertir([X], [X]): !. invertir([X|M], L): invertir(M, S), concatenar(S, [X], L). lista([]): !. lista([_X|Y]): lista(Y). lista. Igual([], []): !. lista. Igual([X|M], [X|R]): lista. Igual(M, R). lista. Igual([X|M], [T|R]): lista(X), lista(T), lista. Igual(X, T), lista. Igual(M, R). capicua([]): !. capicua(L): invertir(L, R), lista. Igual(L, R). Preguntas: capicua([n, e, u, q, u, e, n]). capicua([n, e, u, q, [u, e], n]). capicua([n, e, [u, q, u], e, n]).

Prefijo y sufijo • El prefijo es la letra o letras que se antepone a una palabra, para formar otra, compuesta. • Se denomina sufijo añadirle a este una imfomarción suplemetaria.

Determina si la primer lista es prefijo de la segunda prefijo([], _M): !. prefijo([_X], [_X|_M]): !. prefijo([_X|L], [_X|M]): prefijo(L, M). Preguntas prefijo([1, 2, 3], [1, 2, 3, 4, 5]). prefijo([1, 5, 3], [1, 2, 3, 4, 5]).

Determina si la primer lista es posfijo de la segunda. concatenar([], L, L): !. concatenar([X|M], L, [X|Y]): concatenar(M, L, Y). invertir([], []): !. invertir([X], [X]): !. invertir([X|M], L): invertir(M, S), concatenar(S, [X], L). prefijo([], _M): !. prefijo([_X], [_X|_M]): !. prefijo([_X|L], [_X|M]): prefijo(L, M). posfijo(L, L 1): invertir(L, X), invertir(L 1, Y), prefijo(X, Y). Preguntas: posfijo([3, 5, 4], [1, 2, 6, 5, 7, 8, 3, 5, 4]). posfijo([3, 5, 4], [1, 2, 6, 5, 7, 8, 3, 6, 4]).

Determina si la primer lista es sublista de la segunda lista([]): !. lista([_X|Y]): lista(Y). prefijo([], _M): !. prefijo([_X], [_X|_M]): !. prefijo([_X|L], [_X|M]): prefijo(L, M). sub. Lista([], _L): !. sub. Lista(L, [X|M]): prefijo(L, [X|M]). sub. Lista(L, [X|_M]): lista(X), sub. Lista(L, X). sub. Lista(L, [_X|M]): sub. Lista(L, M). Preguntas: sub. Lista([3, 2], [1, 6, 2, 3]). sub. Lista([3, 2], [1, 6, 3, 2]).

Determina si dos elementos son consecutivos consecutivo([_X, _Y|_Xs], _X, _Y). consecutivo([_X|Xs], N, Z): consecutivo(Xs, N, Z). Preguntas: consecutivo([1, 3, 4, 6, 5, 7, 1, 2], 6, 5). consecutivo([1, 3, 4, 6, 5, 7, 1, 2], 5, 6).

BUSQUEDA DE ELEMENTOS

Obtener el primer elemento de la lista primer. Elem([_X|_Y], _X). Pregunta: primer. Elem([3, 2, 4], X).

Obtener el ultimo elemento de la lista concatenar([], L, L): !. concatenar([X|M], L, [X|Y]): concatenar(M, L, Y). invertir([], []): !. invertir([X], [X]): !. invertir([X|M], L): invertir(M, S), concatenar(S, [X], L). primer. Elem([_X|_Y], _X). ultimo. Elem(L, S): invertir(L, T), primer. Elem(T, S). Pregunta: ultimo. Elem([3, 2, 4], X).

Devuelve el enesimo elemento enesimo. Elem([], _N, []): !. enesimo. Elem([_X|_Y], 1, _X): !. enesimo. Elem([_X|Y], N, E): N 1 is N 1, enesimo. Elem(Y, N 1, E). Pregunta: enesimo. Elem([1, 4, 3, 2, 5], 2, X).

Devuelve una lista con el elemento que se encuentra en la enesima posicion n. Posicion([], _N, []): !. n. Posicion([_X|_N], 1, [_X]): !. n. Posicion([_X|R], N, S): M is N 1, n. Posicion(R, M, S). Preguntas: n. Posicion([1, 4, 2, 3], 2, X). n. Posicion([1, 4, 2, 3], 8, X).

Devuelve el numero de posicion de la primera ocurrencia de X pertenece(_X, [_X|_Y]). pertenece(X, [_C|Y]): pertenece(X, Y). x. Posicion(X, L, S): pertenece(X, L), !, x. Busca(X, L, S). x. Posicion(X, L, S): not(pertenece(X, L)), S is 0. x. Busca(_X, [], 0): !. x. Busca(_X, [_X|_M], 1): !. x. Busca(X, [_Y|M], S): x. Busca(X, M, T), S is T +1. Preguntas: x. Posicion(4, [7, 2, 1, 8, 3, 6], X).

pertenece(_X, [_X|_Y]). Pertenece(X, [_C|Y]): pertenece(X, Y). Pregunta: pertenece(1, [3, 4, 6, 1, 3]).

Determina si un elemento X pertenece a la lista L (multinivel) pertenece(_X, [_X|_Y]). pertenece(X, [_C|Y]): pertenece(X, Y). pertenece. M(N, L): lista. Atomos(L, La), pertenece(N, La). Pregunta: pertenece. M(1, [3, [4, 6, 1], 3]).

Elimina los N primeros elementos de una lista y devuelve el resto saca. Npri([], _N, []): !. saca. Npri([_X|_M], 1, _M): !. saca. Npri([_X|M], N, S): N 1 is N 1, saca. Npri(M, N 1, S). Pregunta: saca. Npri([1, 3, 5, 1, 2], 2, L).

Elimina los N ultimos elementos de una lista y devuelve el resto. concatenar([], L, L): !. concatenar([X|M], L, [X|Y]): concatenar(M, L, Y). invertir([], []): !. invertir([X], [X]): !. invertir([X|M], L): invertir(M, S), concatenar(S, [X], L). saca. Npri([], _N, []): !. saca. Npri([_X|_M], 1, _M): !. saca. Npri([_X|M], N, S): N 1 is N 1, saca. Npri(M, N 1, S). saca. Nult(L, N, R): invertir(L, L 1), saca. Npri(L 1, N, R 1), invertir(R 1, R). Pregunta: saca. Nult([1, 2, 3, 4, 5], 2, L).

Elimina el elemento X de la lista en el 1º nivel elimina. X([], _X, []): !. elimina. X([X|M], X, Z): elimina. X(M, X, Z), !. elimina. X([R|M], X, [R|Z]): elimina. X(M, X, Z), !. Pregunta: elimina. X([1, 2, 3, 4, 5], 3, L). elimina. X([1, 2, [3, 4], 5, 3], 3, L).

Elimina el elemento X de la lista en todos los niveles