acheter(pierre,voiture).
pere(pierre,paul).
pere(jean,pierre). %(pour "Jean est le père de Paul" )
pere(ali,jean).
pere(jacques,ali).
pere(roi,jacques).
pere(jacques,marie).
mere(marie,jude).
parent(X,Y):-pere#(X,Y).
parent(X,Y):-mere(X,Y).
grand_Pere(X,Y):-pere(X,Z),pere(Z,Y).
grand_Pere(X,Y):-pere(X,Z),mere(Z,Y).
arriere_grand_Pere(X,Y):-grand_Pere(X,Z),pere(Z,Y).
arriere_grand_Pere(X,Y):-pere(X,Z),grand_Pere(Z,Y).
arriere_grand_Pere(X,Y):-pere(X,Z),pere(Z,W),pere(W,Y).
ancetre(X,Y):-parent(X,Y). %("Condition initiale")
ancetre(X,Y):-parent(X,Z),ancetre(Z,Y).%("Condition de Recursivite")
/*tester avec :"appart(X,L)" sera évaluée "vraie" si l’élément X appartient à la
liste.
Elle sera définie de façon récursive :*/
appart(X,L) :-L=[X|_]. %("Condition initiale")
appart(X,L) :-L=[_|L1],appart(X,L1). %("Recursivite")
/*La clause "concat(L1,L2,L3) sera vraie si L3 est la concaténation de L1 et L2*/
/*concat([pierre,paul],[jacques,marie],[pierre,paul,jacques,marie]) est vraie.*/
concat([],L2,L3) :-L2=L3. %("condition initiale")
concat(L1,L2,L3) :-L1=[X|L4],concat(L4,L2,L5),L3=[X|L5]. %("récursion")
/*La clause "concat" sera modifiée en ajoutant une nouvelle condition :*/
reunion([],L2,L3) :-L2=L3. %("condition initiale")
reunion(L1,L2,L3) :-L1=[X|L4],appart(X,L2),reunion(L4,L2,L3). %(ignorer les
doublons,soit X la tête de L1,et X déjà dans L2 alors poursuivre en ignorant X)
reunion(L1,L2,L3) :-L1=[X|L4],not(appart(X,L2)),reunion(L4,L2,L5),L3=[X|L5]. %
(récursion)
/*La clause fera appel à "concat" (dans sa première version, sans élimination de
doublons)*/
renverser(L1,L2) :-L1=[],L2=[]. %("Condition Initiale")
renverser(L1,L2) :-L1=[X|L3],renverser(L3,L4),concat(L4,[X],L2). %("Recursion")m-
/* soit la relation inserer(X,Xs,Ys), où Xs est une
liste triée en ordre croissant d’entiers
et Ys est la liste obtenue à partir de Xs en insérant l’entier X.*/
inserer(X,[] ,[X]).
inserer(X,[Y|Ys],[Y|Zs]) :- X > Y, inserer(X,Ys,Zs).
inserer(X,[Y|Ys],[X,Y|Ys]):- X=<Y.
/*On peut "couper " ce processus, avec le
prédicat " ! ". Idem si la clause(2) est vérifiée, inutile
d’examiner la (3).
inserer(X,[],[X]) :- !.
inserer(X,[X|Ys],[Y|Zs]) :- X >Y,!, inserer(X,Ys,Zs).
inserer(X,[Y|Ys],[X,Y|Ys]) :- X=<Y.*/
/*Soit P une phrase (chaîne de caractères) décomposée mot à mot en une liste L.
La clause "Phrase(L)" permettra de vérifier si P est ou non une phase générée
par le système, aussi appelée "Expressions Bien Formées" ou EBF.*/
article(the).
nom(man).
nom(ball).
verbe(hit).
verbe(took).
gN(L1):-L1=[X1,X2],article(X1),nom(X2).
gV(L2):-L2=[X1|L3],verbe(X1),gN(L3).
phrase(L):-concat(L1,L2,L),gN(L1),gV(L2).
% Prédicat qui est vrai si X est un élément de la liste L
element(X, [X|_]). % X est l'élément tête de la liste
element(X, [_|Tail]) :- element(X, Tail). % X est dans la queue de la liste
% Cas de base : la longueur d'une liste vide est 0
longueur([], 0).
% Récursion : la longueur d'une liste est 1 + la longueur de la liste sans son
premier élément
longueur([_|Tail], N) :-
longueur(Tail, N1), % Appel récursif pour la queue de la liste
N is N1 + 1. % Incrémenter la longueur
% Prédicat principal pour retirer les trois derniers éléments
retirer3(L, []) :-longeur(L,N),N<3.
retirer3(L,Lmoins):-longueur(L,N1),N1>=3,concat([_,_,_],Lmoins,L).
% Prédicat principal pour retirer les trois derniers éléments
retirer3d(L, []) :-longeur(L,N),N<3.
retirer3d(L,Lmoins):-longueur(L,N1),N1>=3,concat(Lmoins,[_,_,_],L).
retirer33(L,[]):-longueur(L,N),N<6.
retirer33(L,Lmoins33):-
longueur(L,N1),N1>=6,concat([_,_,_],Lmoins,L),concat(Lmoins33,[_,_,_],Lmoins).
%("Trouve le maximum entre 3 nombres")
max3(X,Y,Z,M):- %(" trouve le maximum entre 3 nombres")
X>=Y,X>=Z -> M = X;
Y>=X,Y>=Z -> M = Y; M = Z.
%("trouver le maximum d'une liste de nombres")
max([L],L).
max([X,Y|L],M):-X>=Y,max([X|L],M).
max([X,Y|L],M):-X<Y,max([Y|L],M).
% ("Predicat prolog minmax qui,etant donne une liste de nombre, calcule
% le minimum des maxima")
minmax([L],M):-max(L,M).
minmax([L1,L2|L],M):-max(L1,M1),max(L2,M2),M1=<M2,minmax([L1|L],M).
minmax([L1,L2|L],M):-max(L1,M1),max(L2,M2),M1>M2,minmax([L2|L],M).
%("Predicat prolog qui trie une liste de liste")
tri([],[]).
tri(L,T):-L=[X|L1],tri(L1,T1),inserer(X,T1,T).
%("Exemple a faire")
%tri([5,1,2,6],T).
%("Ecrire un prdi at prolog qui melange et trie une liste")
melange_tr(L1,L2,L):-concat(L1,L2,L1L2),tri(L1L2,L).
/*("Ecrire un prédicat Prolog element(L,X,LX) qui est vrai si X est un élément de L
et LX
la liste
obtenue en retirant X de L. ")*/
element([],_,[]).
element([X|L],X,LX):-element(L,X,LX).
element([Y|L],X,[Y|LX]):- not(X=Y),element(L,X,LX).
/*Principe du Backtrack*/
appel(X1,X2,X3):- appart(X1,[1,2,3]),appart(X2,[1,2,3]),appart(X3,
[1,2,3]),X1<X2,X2=X3.
/*coloriage des cartes*/
adjacent(1,2).
adjacent(2,1).
adjacent(1,3).
adjacent(3,1).
adjacent(1,4).
adjacent(4,1).
adjacent(1,5).
adjacent(5,1).
adjacent(2,3).
adjacent(3,2).
adjacent(2,4).
adjacent(4,2).
adjacent(3,4).
adjacent(4,3).
adjacent(4,5).
adjacent(5,4).
/* coloriage 1 */
color(1,bleu,coloriage1).
color(2,rouge,coloriage1).
color(3,vert,coloriage1).
color(4,jaune,coloriage1).
color(5,rouge,coloriage1).
/* coloriage 2 */
color(1,vert,coloriage2).
color(2,rouge,coloriage2).
color(3,vert,coloriage2).
color(4,jaune,coloriage2).
color(5,vert,coloriage2).
/* coloriage 3 */
color(1,bleu,coloriage3).
color(2,bleu,coloriage3).
color(3,bleu,coloriage3).
color(4,bleu,coloriage3).
color(5,bleu,coloriage3).
conflit(Coloriage):- color(X,Couleur,Coloriage), color(Y,Couleur,Coloriage),
adjacent(X,Y).
/*TD3 EXO2 2024/2025*/
voisin(1,2).
voisin(2,1).
voisin(1,3).
voisin(3,1).
voisin(1,5).
voisin(5,1).
voisin(2,3).
voisin(2,4).
voisin(4,2).
voisin(3,4).
voisin(4,5).
voisin(5,4).
% voisin(1,4).
% voisin(4,1).
%("Predicat pays")
pays(L):- L=[1,2,3,4,5].
%("Predicat voisins")
voisins(P,Q):- voisin(P,Q);voisin(Q,P).
%("Predicat Couleur")
couleurs(L):- L=[bleu,rouge,vert,jaune].
/*Predicat verifiant que chaque pays possede un voisin et que tous les
pays notes comme ayant un moyeb sont dans la liste des pays
*/
verification:-
pays(L),not((appart(P,L),not(voisins(P,Q)))),not((voisins(P,Q),not(appart(P,L)))).
/* predicat coloriage
*/
permis(P,C,Ca):-not((voisins(P,Q),appart((Q,C),Ca))).
colorie([],_,[]).
colorie(L,Co,Ca):-L=[P|L1],appart(C,Co),Ca=[(P,C)|
Ca1],colorie(L1,Co,Ca1),permis(P,C,Ca).
coloriage(Ca):-pays(L),couleurs(Co),colorie(L,Co,Ca).
/* Coloriage avec le moins de couleur possible*/
coloriagemin(Ca):-pays(L),couleurs(Co),concat(_,Cm,Co),colorie(L,Cm,Ca).
