Programación lógica con listas

Transcripción

1 Ingeniería Informática Ingeniería Técnica en Informática de Sistemas Departamento de Lenguajes y Ciencias de la Computación Universidad de Málaga

2 Contenido 1. Programación básica con listas 2. Generar/comprobar con listas 2

3 Programación básica con listas

4 Definición de listas Sea D un dominio o tipo base Definición: el conjunto de listas L de D se define inductivamente 1. nil L (lista vacía) [base] 2. si L L D D, entonces D :: L L [recursivo] :: es un constructor infijo: D L L primer argumento es la cabeza, el segundo la cola Ejemplo: a :: b :: c :: nil 1 :: 2 :: 3 :: 4 :: nil (a :: nil) :: (b :: c :: nil) :: nil 4

5 Representación Prolog de las listas Necesitamos términos recursivos para representar listas Seguimos la definición inductiva de L: 1. nil L (lista vacía) [base] 2. si L L D D, entonces D :: L L [recursivo] Caso base constante [] Caso recursivo estructura functor./2.(cabeza, Cola) Una lista bien formada es un término generado por la gramática: L ::= [].(T,L) donde T es un término Prolog 5

6 Prolog no tiene tipos Las listas así definidas tienen el término como tipo base:.(a,.(b,.(c, []))).(a,.(1,.(f(x,y), []))).(.(a,.(b, [])),.(t(u,c),[]) ) En general, los contenedores tendrán el término como tipo base Ventajas: Prolog es polimórfico Inconvenientes: Prolog es inseguro 6

7 Endulzando las listas Prolog añade azúcar sintáctico para mejorar la legibilidad: L ::= [] % vacía [T 1, T 2,, T n ] % n elementos [T 1, T 2,, T n L] % al menos n elementos Ejemplo: prefijo cola.(a,.(b,.(c,[]))) [a,b,c].(a,.(1,.(f(x,y), []))) [a,1,f(x,y)].(.(a,.(b,[])),.(t(u,c),[]) ) [[a,b],[t(u,c)]] 7

8 Azúcar según el gusto la lista.(a,.(b,.(c,[]))) puede representarse de varias formas equivalentes: [a,b,c] [a,b,c []] [a,b [c]] [a [b,c]] [a [b [c] ]] [a [b [c [] ]]] Cuidado: después del la tiene que haber una lista 8

9 Plantillas de listas (I) Qué representa cada una de estas listas? [X] [X,Y] [X,X] [X [Y]] [X Xs] [a As] [X,Y Zs] [Xs Xs] [Xs a] 9

10 Plantillas de listas (y II) Qué representa cada una de estas listas? [X] [X,Y] [X,X] [X [Y]] [X Xs] [a As] [X,Y Zs] [Xs Xs] [Xs a] listas de un elemento listas de dos elementos listas de dos elementos iguales listas de dos elementos (equivale a [X,Y]) listas de al menos un elemento listas que empiezan por a listas de al menos dos elementos listas cuyo primer elemento es una lista que coincide con la cola (ej. [[1,2,3], 1, 2, 3]) no es una lista, después de debe haber una lista 10

11 Unificación de listas las listas deben unificar elemento a elemento hay que rescribir las listas colocando la en la misma posición (el prefijo más corto) Ejemplo: [X Y] [X Y] [a,b,c] [a [b,c]] { X / a, Y / [b,c] } [X, Y Ys] [X [Y Ys]] [a Zs] [a Zs] { X / a, Zs / [Y Ys] } 11

12 Ejercicios Unificar los siguientes pares de listas: 1. [X Y] [a,b,c] 2. [a,[b,c]] [X Y] 3. [[a,b],c] [X Y] 4. [a X] [Y a] 5. [a X] [Y [c]] 6. [a X] [Y] 7. [a,b,x] [X T] 8. [a,b Y] [X,T] 9. [a,b [Y]] [a,b,c] 10. [a,b [Y]] [a,b,c,d] 12

13 Definición de dominio Seguimos la definición inductiva de L: nil L (lista vacía) [base] si L L D D, entonces D :: L L [recursivo] Utilizaremos la sintaxis simplificada: % es_lista(?xs) es_lista([]). es_lista([x Xs]) :- es_lista(xs). % base % recursivo Notación: variables acaban en s cuando deben ser listas; ej: Xs Ejercicio: Define es_lista_de_naturales/1 13

14 Comprobando y generando listas?- es_lista([a,2+3,t(x)]). % test Yes?- es_lista([a,x c]). % test No?- es_lista(xs). % generador no acotado Xs = [] ; Xs = [_G308] ; Xs = [_G308, _G311] ; Xs = [_G308, _G311, _G314] 14

15 El predicado longitud/1 (I) longitud(+xs,?n) la lista Xs tiene N elementos Ejemplo:?- longitud([a,b,c], 3). % test Yes?- longitud([a,b,c],n). % generador único N = 3 ; No 15

16 El predicado longitud/1 (II) longitud(+xs,?n) la lista Xs tiene N elementos Aplicamos recursión sobre la lista Xs: longitud([],?) :-... longitud([x Xs],? ) :

17 El predicado longitud/1 (III) longitud(+xs,?n) la lista Xs tiene N elementos El caso base es trivial: longitud([],0). longitud([x Xs],? ) :

18 El predicado longitud/1 (y IV) longitud(+xs,?n) la lista Xs tiene N elementos El caso recursivo es muy simple (patrón recursivo): longitud([],0). longitud([x Xs], N) :- longitud(xs,t), % reducir y resolver N is T+1. % componer Cómo sería recursivo de cola? 18

19 El predicado longitud/1 recursivo de cola longitud(+xs,?n) la lista Xs tiene N elementos Basta aplicar directamente el patrón: longitud(xs,n) :- long_cola(xs,0,n). long_cola([],n,n). long_cola([x Xs],Ac,N) :- Ac1 is Ac+1, long_cola(xs,ac1,n). Ejercicio: compara las tablas de comportamiento de las versiones recursiva y recursiva de cola 19

20 Ejercicios Define versiones recursivas y recursivas de cola de los siguientes predicados sobre listas de números: 1. suma(+xs,?n), N es la suma de los elementos de Xs 2. maximo(+asmbs,?m), M es el máximo de AsMsBs 3. minimo(+asmbs,?m), M es el mínimo de AsMsBs 4. cuantas(+x,+asxbs,?n), X aparece N veces en AsXBs 5. escalar(+xs,+ys,?p), P es el producto escalar de Xs y Ys 6. rango(+x,+y,?ls), Ls es la lista con los enteros entre X e Y 20

21 El predicado miembro/2 (I) miembro(?x,?xs) X pertenece a la lista Xs Cómo aplicamos recursión sobre la lista? miembro(x,?):-... miembro(x,?):-... % base % recursivo Cuál es el caso base? 21

22 El predicado miembro/2 (II) miembro(?x,?xs) X pertenece a la lista Xs Caso base: he encontrado el elemento miembro(x,[x Xs]). miembro(x,?):-... % base % recursivo sólo puedo inspeccionar la cabeza de la lista suponemos que Xs es una lista 22

23 El predicado miembro/2 (y III) miembro(?x,?xs) X pertenece a la lista Xs Caso recursivo: puede estar en el resto de la lista miembro(x,[x Xs]). % base miembro(x,[y Xs]):- miembro(x,xs). % recursivo Los casos base y recursivo no son excluyentes 23

24 Usos de miembro/2?- miembro(b,[a,b,c]). % test Yes?- miembro(x,[a,b,c]). % generador acotado X = a ; X = b ; X = c ; No?- miembro(a,xs). % generador no acotado Xs = [a _G323] ; Xs = [_G322, a _G326] ; Xs = [_G322, _G325, a _G329]... 24

25 Tabla de comportamiento de miembro/2 miembro(x,asxbs) Uso Comportamiento Significado (+,+) test X AsXBs (-,+) generador acotado {X X AsXBs} (+,-) generador no acotado AsXBs= [_,..., _, X _] (-,-) generador no acotado AsXBs= [_,..., _, X _] Notación: el nombre AsXBs refleja la estructura del término: una lista que contiene X Ejercicio: Construir la tabla utilizando como caso base miembro(x,[x Xs]) :- es_lista(xs). 25

26 El predicado prefijo/2 (I) prefijo(?xs,?xsys) Xs es prefijo de XsYs Se puede razonar: aplicando el patrón: reducir, resolver, componer (hacia atrás) operacionalmente, recorriendo Xs (hacia delante) Lo resolveremos de ambas formas 26

27 El predicado prefijo/2 (II) prefijo(?xs,?xsys) Xs es prefijo de XsYs Aplicamos recursión sobre el primer argumento: prefijo([],?) :-... prefijo([x Xs],?) :-... % base % recursivo Caso base: de qué listas es prefijo la lista vacía? 27

28 El predicado prefijo/2 (III) prefijo(?xs,?xsys) Xs es prefijo de XsYs Caso base: la lista vacía es prefijo de cualquier lista prefijo([],ys). prefijo([x Xs],?) :-... % base % recursivo Caso recursivo: reducir, resolver y componer 28

29 El predicado prefijo/2 (IV) prefijo(?xs,?xsys) Xs es prefijo de XsYs Caso recursivo: reducir y resolver son triviales prefijo([],ys). prefijo([x Xs],?) :- prefijo(xs,xsys). % base % recursivo Caso recursivo: componer supongamos que Xs es prefijo de XsYs de qué listas es prefijo [X Xs]? 29

30 El predicado prefijo/2 (V) prefijo(?xs,?xsys) Xs es prefijo de XsYs prefijo([],ys). prefijo([x Xs],[X XsYs]):- prefijo(xs,xsys). % base % recursivo También se puede razonar operacionalmente 30

31 El predicado prefijo/2 (VI) prefijo(?xs,?xsys) Xs es prefijo de XsYs Recorremos la primera lista de la cabeza a la cola: prefijo([x Xs],?) :-... Si la primera lista comienza con X, por qué debe empezar la segunda lista? 31

32 El predicado prefijo/2 (VII) prefijo(?xs,?xsys) Xs es prefijo de XsYs La segunda también debe comenzar por X: prefijo([x Xs],[X XsYs]) :-... Ya hemos comprobado que las cabezas coinciden: y los restos? 32

33 El predicado prefijo/2 (VIII) prefijo(?xs,?xsys) Xs es prefijo de XsYs Continuamos recorriendo la lista para comprobar el resto: prefijo([x Xs],[X XsYs]) :- prefijo(xs,xsys). Cuando acabamos? 33

34 El predicado prefijo/2 (IX) prefijo(?xs,?xsys) Xs es prefijo de XsYs Cuando hayamos recorrido completamente la primera lista: prefijo([],ys). prefijo([x Xs],[X XsYs]) :- prefijo(xs,xsys). 34

35 El predicado prefijo/2 (y XI) prefijo(?xs,?xsys) Xs es prefijo de XsYs Podemos representar gráficamente el razonamiento operacional: XsYs [X1 X1s] Ys [X1 X1s] Xs Idea: ir comparando ambas listas por la cabeza, hasta agotar Xs 35

36 Usos de prefijo/2?- prefijo([a,b,c],[a,b,c]). % test Yes?- prefijo(ps,[a,b,c]). % generador acotado Ps = [] ; Ps = [a] ; Ps = [a, b] ; Ps = [a, b, c] ; No 14?- prefijo([a,b],xs). % generador único Xs = [a, b _G362] ; No 36

37 Tabla de comportamiento de prefijo/2 prefijo(?xs,?xsys) Uso Comportamiento Significado (+,+) test comprueba Xs es prefijo de XsYs (-,+) generador acotado genera prefijos de XsYs (+,-) generador único dada Xs= [t 1,,t n ], genera XsYs= [t 1,, t n _] (-,-) generador no acotado genera Xs= [V 1,,V n ] XsYs= [V 1,,V n _] Ejercicio: construir la tabla de comportamiento que se obtiene al añadir la comprobación de dominio (es_lista/1) al caso base 37

38 El predicado sufijo/2 (I) sufijo(?xs,?ysxs) Xs es sufijo de YsXs Lo más fácil es razonar operacionalmente (hacia delante): Ys eliminar YsXs Xs Xs Idea: eliminar elementos de la cabeza de YsXs hasta obtener Xs 38

39 El predicado sufijo/2 (y II) sufijo(?xs,?ysxs) Xs es sufijo de YsXs sufijo(xs,xs). % son iguales sufijo(xs,[y YsXs]) :- sufijo(xs,ysxs). % eliminar cabeza 39

40 Usos de sufijo/2?- sufijo(ss,[a,b]). % generador acotado Ss = [a, b] ; Ss = [b] ; Ss = [] ; No?- sufijo([a,b],xs). % generador no acotado Xs = [a, b] ; Xs = [_G346, a, b] ;...?- sufijo(xs,ys). % generador no acotado Xs = _G266 Ys = _G266 ; Xs = _G266 Ys = [_G331 _G266] ;... 40

41 Tabla de comportamiento de sufijo/2 sufijo(?xs,?ysxs) Uso Comportamiento Significado (+,+) test comprueba si Xs es sufijo de YsXs (-,+) generador acotado genera en Xs sufijos de YsXs (+,-) generador no acotado YsXs = [V1,,Vi Xs] i= 0 (-,-) generador no acotado Xs = V, YsXs =[V1,,Vi V] i= 0 41

42 El predicado selecciona/3 (I) selecciona(?x,?asxbs,?asbs) AsBs es el resultado de eliminar X de AsXBs hay que localizar X en AsXBs (similar a miembro/2) y eliminarlo aplicamos recursión sobre la lista AsXBs : selecciona(x,[x Bs],?) :-... selecciona(x,[a AsXBs],?) :

43 El predicado selecciona/3 (II) selecciona(?x,?asxbs,?asbs) AsBs es el resultado de eliminar X de AsXBs Caso base: trivial selecciona(x,[x Bs],Bs). selecciona(x,[a AsXBs],?) :-... Caso recursivo: reducir, resolver, componer 43

44 El predicado selecciona/3 (III) selecciona(?x,?asxbs,?asbs) AsBs es el resultado de eliminar X de AsXBs Caso recursivo: reducir y resolver son directos selecciona(x,[x Bs],Bs). selecciona(x,[a AsXBs],?) :- selecciona(x,asxbs,asbs). en qué consiste componer? 44

45 El predicado selecciona/3 (y IV) selecciona(?x,?asxbs,?asbs) AsBs es el resultado de eliminar X de AsXBs selecciona(x,[x Bs],Bs). selecciona(x,[a AsXBs],[A AsBs]) :- selecciona(x,asxbs,asbs). Ejercicio: construye la tabla de comportamiento de selecciona/3 45

46 Usos de selecciona/3?- selecciona(a,[a,b,a,c],xs). % gen acotado Xs = [b, a, c] ; Xs = [a, b, c] ; No?- selecciona(a,xs,[b,c]). % gen acotado Xs = [a, b, c] ; Xs = [b, a, c] ; Xs = [b, c, a] ; No?- selecciona(x,[a,b,c,d],[a,c,d]). % gen único X = b ; No 46

47 Ejercicios Define los siguientes predicados sobre listas: 1. primero(?x,?xys), X es el primer elemento de XYs 2. ultimo(?x,?ysx), X es el último elemento de YsX 3. pri_y_ult(?x,?y,?xzsy), X e Y son primero y último de XZsY 4. adyacentes(?x,?y,?asxybs), A y B son adyacentes en AsXYBs 5. todos_iguales(?xs), Xs tiene todos los elementos iguales 6. iesimo(+i,?asxbs,?x), X es el I-ésimo elemento de AsXBs 7. sublista(?xs,?asxsbs), Xs es sublista de AsXsBs 47

48 El predicado concatena/3 (I) concatena(?xs,?ys,?xsys) XsYs es la concatenación de Xs e Ys Aplicamos recursión sobre el primer argumento: concatena([], Ys,?) :-... concatena([x Xs], Ys,?) :

49 El predicado concatena/3 (II) concatena(?xs,?ys,?xsys) XsYs es la concatenación de Xs e Ys Caso base: trivial concatena([], Ys, Ys). concatena([x Xs], Ys,?) :-... Caso recursivo: reducir, resolver y componer 49

50 El predicado concatena/3 (III) concatena(?xs,?ys,?xsys) XsYs es la concatenación de Xs e Ys Caso recursivo: reducir y resolver concatena([], Ys, Ys). concatena([x Xs], Ys,?) :- concatena(xs,ys,xsys). Si Xs concatenado con Ys es XsYs, Qué se obtiene al concatenar [X Xs] con Ys? 50

51 El predicado concatena/3 (y IV) concatena(?xs,?ys,?xsys) XsYs es la concatenación de Xs e Ys concatena([], Ys, Ys). concatena([x Xs], Ys, [X XsYs]) :- concatena(xs,ys,xsys). A qué predicado de la aritmética de Peano se parece? 51

52 Usos de concatena/3?- concatena([a,b],[c,d],xs). % gen único Xs = [a, b, c, d] ; No?- concatena(xs,[c,d],[a,b,c,d]). % gen único Xs = [a, b] ; No?- concatena(xs,ys,[a,b,c]). % gen acotado Xs = [] Ys = [a, b, c] ; Xs = [a] Ys = [b, c] ; Xs = [a, b] Ys = [c] ; Xs = [a, b, c] Ys = [] ; No 52

53 Tabla de comportamiento de concatena/3 concatena(?xs,?ys,?xsys) Uso Comportamiento Significado (+,+,+) test Xs concatenada con Ys es XsYs (+,+,-) generador único dadas Xs = [X1,,Xn], Ys = [Y1,,Ym] genera XsYs = [X1,,Xn,Y1,,Ym] (-,+,+) generador único dadas XsYs = [X1,,Xn,Y1,,Ym], Ys = [Y1,,Ym] genera Xs = [X1,,Xn] (+,-,+) generador único similar a (-,+,+) (-,-,+) generador acotado dada XsYs = [T1,,Tn], i=0..n genera Xs = [T 1,,T i ] Ys = [T i+1,,t n ] 53

54 Ejercicios Define los siguientes predicados empleando concatena/3: 1. primero(?x,?xys), X es el primer elemento de XYs 2. ultimo(?x,?ysx), X es el último elemento de YsX 3. pri_y_ult(?x,?y,?xzsy), X e Y son primero y último de XZsY 4. adyacentes(?x,?y,?asxybs), X e Y son adyacentes en AsXYBs 5. prefijo(?xs,?xsys), Xs es prefijo de XsYs 6. sufijo(?xs,?ysxs), Xs es sufijo de XsYs 7. sublista(?xs,?asxsbs), Xs es sublista de AsXsBs 8. miembro(?x,?asxbs), X pertenece a la lista AsXBs 9. selecciona(?x,?asxbs,?asbs), AsBs resulta de eliminar X de AsXBs 54

55 El predicado inversa/2 (I) inversa(+xs,?sx) Sx es la inversa de Xs Aplicamos recursión sobre el primer argumento: inversa([],[]). inversa([x Xs],?) :- inversa(xs,sx),?. Si la inversa de Xs es Sx, cuál es la inversa de [X Xs]? 55

56 El predicado inversa/2 (y II) inversa(+xs,?sx) Sx es la inversa de Xs Hay que poner X al final de Sx: inversa([],[]). inversa([x Xs],SxX) :- % O(n 2 ) inversa(xs,sx), concatena(sx,[x],sxx). % O(n) Tiempo: O(n 2 ) Cómo mejorar la eficiencia? aplicar recursión de cola 56

57 inversa/2 con recursión de cola (I) inversa(+xs,?sx) Sx es la inversa de Xs inversa(xs,sx) :- inversa_cola(xs,[],sx). inversa_cola([],sx,sx). inversa_cola([x Xs],Is,Sx) :- actualizar(x,is,xis), inversa_cola(xs,xis,sx). En qué consiste actualizar? 57

58 inversa/2 con recursión de cola (y II) inversa(?xs,?sx) Sx es la inversa de Xs inversa(xs,sx) :- inversa_cola(xs,[],sx). inversa_cola([],sx,sx). inversa_cola([x Xs],Is,Sx) :- inversa_cola(xs,[x Is],Sx). Tiempo: O(n) La recursión de cola reduce el consumo de memoria y tiempo 58

59 El predicado borrar/3 (I) borrar(+x,+as,?bs) borra todas las X de As, dando Bs Aplicamos recursión a As: borrar(x,[],[]). borrar(x,[a As],?) :-... % base % recursivo En el caso recursivo: no puedo emplear unificación (X y As están en modo +) lo que se haga depende de si X y A son el mismo término qué predicado de comparación debo utilizar? 59

60 El predicado borrar/3 (y II) borrar(+x,+as,?bs) borra todas las X de As, dando Bs El caso recursivo se divide en dos casos: borrar(x,[],[]). borrar(x,[a As],Bs) :- X == A, borrar(x,as,bs). borrar(x,[a As],[A Bs]) :- X \== A, borrar(x,as,bs). % base % borrar A % conservar A 60

61 Ejercicios Define los siguientes predicados (sin unificar en modo +): 1. esta(+x,+asxbs), X está en AsXBs 2. no_esta(+x,+asbs), X no está en AsBs 3. purga(+xxss,?xs), Xs resulta de eliminar elementos repetidos de XXss 4. borra_una(+x,+as,?bs), borra una X de As, dando Bs 5. borra_algunas(+x,+as,?bs), borra algunas X de As, dando Bs 6. borra_al_menos_una(+x,+as,?bs), borra al menos una X de As, dando Bs 7. borra_pri(+x,+as,?bs). borra la primera X de As, dando Bs 8. borra_ult(+x,+as,?bs), borra la última X de As, dando Bs 61

62 El predicado quicksort/2 quicksort(+as,?os) Os es As ordenada por quicksort Aplicamos recursión sobre As: quicksort([],[]). quicksort([a As], Os) :- partir(a,as,menorigs,mayores), quicksort(menorigs,omenorigs), quicksort(mayores,omayores), concatena(omenorigs,[a OMayores],Os). Cómputo = Deducción controlada Algoritmo 62

63 El predicado partir/3 partir(+pivote,+as,?menorigs,?mayores) parte As en MenorIgs y Mayores respecto a Pivote Aplicamos recursión sobre As: partir(pivote,[],[],[]). partir(pivote,[a As],[A MenorIgs],Mayores) :- Pivote, partir(pivote,as,menorigs,mayores). partir(pivote,[a As],MenorIgs,[A Mayores]) :- Pivote, partir(pivote,as,menorigs,mayores). 63

64 Ejercicios Define los siguientes predicados de ordenación: 1. burbuja(+as,?os) 2. insercion(+as,?os) 3. mezcla(+as,?os) 4. quicksort_azar(+as,?os) ordena por quicksort, seleccionando el pivote al azar (emplea la función random/1) 64

65 El predicado permutacion/2 (I) permutacion(+xs,?ys) Ys es una permutación de Xs Aplicamos recursión sobre Xs: permutacion([],[]). % base permutacion([x Xs],?) :- % recursivo permutacion(xs,ys), % reducir + resolver? % componer Componer: añadir X a Ys en qué posición? 65

66 El predicado permutacion/2 (y II) permutacion(+xs,?ys) Ys es una permutación de Xs Hay que añadir X a Ps en todas las posiciones posibles: permutacion([],[]). permutacion([x Xs],Ys) :- permutacion(xs,ps), selecciona(x,ys,ps). % base % recursivo % reducir + resolver % componer 66

67 El predicado combinacion/3 (I) combinacion(+xs,+n,?cs) Cs es una combinación de N elementos de Xs Aplicamos recursión sobre N: combinacion(xs,0,[]). combinacion([x Xs],N,?) :- N > 0, % base % recursivo Caso recursivo: hay que distinguir dos posibilidades, según X forme parte o no de la combinación Cs 67

68 El predicado combinacion/3 (y II) combinacion(+xs,+n,?cs) Cs es una combinación de N elementos de Xs combinacion(xs,0,[]). combinacion([x Xs],N,[X Cs]) :- N > 0, N1 is N-1, combinacion(xs,n1,cs). combinacion([x Xs],N,Cs) :- N > 0, combinacion(xs,n,cs). % base % X Cs % X Cs 68

69 Generar/comprobar con listas

70 El prefijo más largo que suma N (I) Problema: aplicando generar/comprobar, define un predicado premax(+psxs,+n,?ps) que se satisface cuando Ps es el prefijo no vacío más largo de PsXs tal que la suma de sus elementos no supera N Ejemplo:?- premax([1,2,3,4,5,6],12,ps). Ps = [1,2,3,4] ; No 70

71 El prefijo más largo que suma N (II) Necesitamos un generador de prefijos: premax(psxs,n,ps) :- prefijo(ps,psxs), % generar... % comprobar Qué condiciones debe verificar Ps? 1. no es vacío 2. la suma de sus elementos no supera N 3. es el más largo posible 71

72 El prefijo más largo que suma N (III) El prefijo no puede ser vacío: premax(psxs,n,[p Ps]) :- prefijo([p Ps],PsXs), % generar... % comprobar 72

73 El prefijo más largo que suma N (IV) La suma de los elementos de [P Ps] no puede superar N: premax(psxs,n,[p Ps]) :- prefijo([p Ps],PsXs), suma([p Ps],S), S =< N,... % generar % comprobar [P Ps] debe ser el prefijo más largo con estas condiciones 73

74 El prefijo más largo que suma N (y V) [P Ps] no puede crecer sin violar las condiciones: premax(psxs,n,[p Ps]) :- concatena([p Ps],Xs,PsXs), suma([p Ps],S), S =< N, no_crece(s,n,xs). % generar % comprobar no_crece(_,_,[]). no_crece(s,n,[x _]) :- S + X > N. 74

75 La secuencia mágica (I) Problema: definir un predicado secuencia(?xs) que genere todas las secuencias de dígitos entre 1 y 9 tales que: 1) todos los dígitos aparecen tres veces 2) las tres apariciones del dígito i están separadas entre sí por i dígitos Ejemplo: 1, 9, 1, 2, 1, 8, 2, 4, 6, 2, 7, 9, 4, 5, 8, 6, 3, 4, 7, 5, 3, 9, 6, 8, 3, 5, 7 Qué longitud tiene la lista Xs? Solución: aplicando generar/comprobar, construimos listas que satisfagan todas las condiciones 75

76 La secuencia mágica (y II) secuencia(xs) :- % Xs = lista de 27 variables libres Xs = [_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_], % restricciones sublista([1,_,1,_,1],xs), sublista([2,_,_,2,_,_,2],xs), sublista([3,_,_,_,3,_,_,_,3],xs), sublista([4,_,_,_,_,4,_,_,_,_,4],xs), sublista([5,_,_,_,_,_,5,_,_,_,_,_,5],xs), sublista([6,_,_,_,_,_,_,6,_,_,_,_,_,_,6],xs), sublista([7,_,_,_,_,_,_,_,7,_,_,_,_,_,_,_,7],xs), sublista([8,_,_,_,_,_,_,_,_,8,_,_,_,_,_,_,_,_,8],xs), sublista([9,_,_,_,_,_,_,_,_,_,9,_,_,_,_,_,_,_,_,_,9],xs). 76

77 El problema de las N reinas (I) Problema: colocar N reinas en un tablero de ajedrez de manera que las reinas no se ataquen unas a otras Ejemplo: para N = 8, dónde ponemos la siguiente reina? 77

78 El problema de las N reinas (II) Solución: no hay solución analítica (incluso Gauss fracasó!), sólo podemos aplicar un método de prueba y error Aplicando generar/comprobar, definiremos un predicado reinas(+n,?solucion) que genere en Solucion todas las soluciones posibles La solución debe mostrar el emplazamiento de las N reinas Cómo representamos la solución? 78

79 El problema de las N reinas (III) Primera posibilidad: como una lista de coordenadas (fila,columna) [(X1,Y1), (X2,Y2),, (XN,YN)] Inconveniente: el espacio de búsqueda es demasiado grande para N = 8, tenemos unos candidatos posibles comprobando 1 millón de candidatos por segundo, llevaría 135 años Cómo reducir el espacio de búsqueda? 79

80 El problema de las N reinas (IV) Segunda posibilidad: El elemento i-ésimo de la lista representa la fila ocupada por la reina situada en la columna i-ésima 1 2 N columna Yi [X1, X2,, XN] Xi {1..N}, sin repet. [X1, X2,, XN] es una permutación de la lista [1,2,3,,N] tal que las reinas no se atacan (N! candidatos, 8! = 40320) Por construcción: sólo puede haber una reina en cada fila sólo puede haber una reina en cada columna sólo hay que evitar ataques diagonales 80

81 El problema de las N reinas (V) reinas(n,solucion) :- rango(1,n,filas), permutacion(filas,solucion), no_se_atacan(solucion). % generar % comprobar Cómo mejorar esta solución? 81

82 El problema de las N reinas (VI) Entrelazar generación y comprobación: cada vez que se coloque una reina, comprobar que no ataca a las ya colocadas Esto exige llevar cuenta de las reinas colocadas reinas(n,solucion) :- rango(1,n,disponibles), reinas(disponibles,[],solucion). colocadas Vamos tomando filas Disponibles y las ponemos en Colocadas, comprobando que no ataca a las anteriores 82

83 El problema de las N reinas (VII) % reinas(disponibles,colocadas,solucion) reinas([],solucion,solucion). reinas(disponibles,colocadas,solucion) :- selecciona(fila,disponibles,disponibles_1), no_ataca(fila,colocadas), reinas(disponibles_1,[fila Colocadas],Solucion). El tablero se rellena por columnas, de derecha (N) a izquierda (1) 83

84 El problema de las N reinas (y VIII) no_ataca(fila,colocadas) comprueba que la reina recién colocada no está en la misma diagonal que las anteriores no_ataca(fila,colocadas) :- no_ataca(fila,1,colocadas). no_ataca(_,_,[]). no_ataca(fila,n,[f Colocadas]) :- % N dist horiz. N =\= abs(fila - F), % dist. vertical N1 is N+1, no_ataca(fila,n1,colocadas). 84