Ministerul Educațieţiei al Republicii Moldova

Universitatea de Stat din Moldova

Facultatea de Matematică și Informatică

Lucrari de laborator nr.2-11

La disciplina Inteligență artificială

Efectuat de studentul
grupei I1801: V. Madan

Verificat de:
M. Cristei

Chişinău, 2020
 Condițiile laboratorului nr 2 V11:
Să se definească în limbajul Prolog funcţia Ackermann:
ackermann(0,M,X) :- X is M+1.
ackermann(N,0,X) :- N>0,N1 is N-1, ackermann(N1,1,X).
ackermann(N,M,X):- N>0, M>0, N1 is N-1, M1 is M-1,
ackermann(N,M1,X1),ackermann(N1,X1,X).
Condițiile laboratorului nr 3 V1:
Să se definească în Prolog următoarele predicate:
a) predicatul care verifică dacă un element se conţine într-o listă (aparţine).
b) predicatul care găseşte al n-lea element dintr-o listă.
c) predicatul care dublează toate elementele unei liste.

a) apartine(X, [X | _]).
apartine(X, [Y | Rest]) :- X \=Y, apartine(X, Rest).
Ex: apartine(1,[1,2,3,4,5,6,7])
b) element_at(X,[X|_],1).
element_at(X,[_|L],K) :- K > 1, K1 is K - 1, element_at(X,L,K1).
Ex: element_at(X,[a,b,c,d],4)
c) dupli([],[]).
dupli([X|Xs],[X,X|Ys]) :- dupli(Xs,Ys).
Ex: dupli([1,1,2,3,4],X)
Condițiile laboratorului nr 4 V11:
Să se scrie predicatul care elimină toate apariţiile unui element dat de pe poziţiile impare dintr-o
listă.
Se consideră că poziţia primului element al listei este 1

sterg1([Z],Z,[]).
sterg1([Z],Y,[Z]):-Z\=Y.
sterg1([], _, []).
sterg1([N,X|Rest], N, [X|Rez]) :- sterg1(Rest, N, Rez).
sterg1([M,X|Rest], N, [M,X|Rez]) :- M\=N,sterg1(Rest, N, Rez).
Ex: sterg1([1,2,3,4,5],3,X)
 Condițiile laboratorului nr 5 V1:
Să se scrie programul pentru sortarea unei liste numerice în ordine crescătoare, prin metoda „naivă”:
se
generează permutări ale listei până când se obţine o permutare sortată.

srt(X,Y) :- perm(X,Y), isSrt(Y).

isSrt([]).
isSrt([_]).
isSrt([H,I|J]) :- H=<I, isSrt([I|J]).
scoaterea(X,[X|R],R).
scoaterea(X,[F |R],[F|S]) :- scoaterea(X,R,S).
perm([X|Y],Z) :- perm(Y,W), scoaterea(X,Z,W).
perm([],[]).
Ex: srt([1,3,5,4,6],X)
Condițiile laboratorului nr 6 V11:
Să se scrie un program Prolog care realizează automatul finit ce recunoaşte
cuvintele de forma:
abn cd m , n≥2, m≥1, n – par, m – impar
trecere(q0,a,q1).
trecere(q1,b,q2).
trecere(q2,a,q3).
trecere(q3,b,q4).
trecere(q4,a,q5).
trecere(q5,b,q2).
trecere(q4,c,q6).
trecere(q6,d,q7).
trecere(q7,c,q8).
trecere(q8,d,q9).
trecere(q9,c,q6).
initial(q0).
final(q7).
verifica(L):-initial(S),automat(S,L).
automat(S,[]):-final(S).
automat(S,[A|L]):-trecere(S,A,S_New),automat(S_New,L).
Ex: verifica([a,b,a,b,c,d])
Condițiile laboratorului nr 7 V1:
Să se distribuie numerele de la 1 la n în trei cutii A, B, C, astfel ca să se
satisfacă următoarele condiţii:

distr(0,[],[],[]).
distr(N,[N|A],B,C):-N>0,N1 is N-1,distr(N1,A,B,C),not(conditie(N,A)).
distr(N,A,[N|B],C):-N>0,N1 is N-1,distr(N1,A,B,C),not(conditie(N,B)).
distr(N,A,B,[N|C]):-N>0,N1 is N-1,distr(N1,A,B,C),not(conditie(N,C)).
conditie(K,L):-member(I,L),K is 2*I,K @=< L.
conditie(K,L):-member(I,L),member(J,L),not(I=J),K is I+J, K @=< L.
Ex: distr(5,A,B,C)
Condițiile laboratorului nr 8 V11:

Lab8. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
start :-
writeln("\nRegulile Jocului ' Chibriturile ' :"),
writeln("\tPe masa sunt asezate 23 chibrituri"),
writeln("\tFiecare jucator ridica de la 1 -> 3 chibrituri"),
writeln("\tJucatorul care ridica ultimele chibrituri castiga\n"),
pas(23,1).
raspunde(Total,X) :-
Y is mod(Total,4),
caz(Y,X).
caz(0,X) :-
random_between(1,3,X).
caz(X,X).
verifica(X,Y):-
( Y > 51; Y < 49 ),
 citeste(X).
verifica(X,X).
citeste(X) :-
write("\nExtrageti valoare:\t"),
get(Y),
verifica(X,Y).
extrage(X) :-
citeste(Y),
X is Y - 48.
pas(0,1):-
writeln("\n\t!\tCalculatorul a invins\t!"),nl.
pas(0,2):-
writeln("\n\t!\tPlayer-ul a invins\t!"),nl.
pas(Total,1) :-
format("Suma de chibrituri curenta: ~d",[Total]),
nl ,
extrage(X),
Curent is Total - X,
pas(Curent,2).
pas(Total,2) :-
format("Suma de chibrituri curenta: ~d",[Total]),
nl ,
raspunde(Total,X), nl ,
format("Calculatorul a extras ~d",[X]), nl ,
Curent is Total - X,
pas(Curent,1).
Condițiile laboratorului nr 9 V1:
Pe o tablă orizontală cu 7 pătrate iniţial sunt aliniaţi trei pioni albi şi trei pioni negri cu un
pătrat liber între ei:
 A A A N N N

Să se găsească consecutivitatea de transformări a configuraţiei iniţiale pentru a ajunge la

configuraţia finală în care pionii albi sunt în dreapta, iar cei negri – în stânga despărţiţi de un pătrat
liber:

N N N A A A

utilizând următoarele patru reguli:

- un pion negru poate fi deplasat cu un pătrat spre stânga, dacă pătratul e liber, de exemplu
A N A N N A → A N A N N A

- un pion negru poate sări peste un pion adiacent alb spre stânga, dacă pătratul e liber, de
exemplu
A N A N N A → A N N A N A

- un pion alb poate fi deplasat cu un pătrat spre dreapta, dacă pătratul e liber, de exemplu
A N A N N A → A N A N N A

- un pion alb poate sări peste un pion adiacent negru spre dreapta, dacă pătratul e liber, de
exemplu
A A N N N A → A N A N N A

% Regulile jocului
swap([a,[],N],X) :-
X = [[],a,N].
swap([A,[],n],X) :-
X = [A,n,[]].
swap([a,n,[]],X) :-
X = [[],n,a].
swap([[],a,n],X) :-
 X = [n,a,[]].
swap([n,a,[]],X) :-
X = [n,[],a].
swap([[],n,a],X) :-
X = [n,[],a].

%Pionii

pionii :-
pionii([a,a,a,[],n,n,n]),
writeln([a,a,a,[],n,n,n]).

pionii(List) :-
divid(List,Shmak1,Shmak2,Shmak3),
swap(Shmak2,NewShmak2),
uneste(Shmak1,NewShmak2,Shmak3,NewList),
result(NewList).

result([n,n,n,[],a,a,a]) :-
writeln([n,n,n,[],a,a,a]).
result(NewList) :-
pionii(NewList),
writeln(NewList).

% Predicate Ajutatoare

% Divide lista in trei subliste,

% A Doua sublista contine celula goala.
divid([[],B,C|Tail],[],[[],B,C],Tail).
divid([A,[],C|Tail],[],[A,[],C],Tail).
divid([A,B,[]|Tail],[],[A,B,[]],Tail).
divid([A,B,C|Tail],[A|List1],List2,List3) :-
divid([B,C|Tail],List1,List2,List3).

% Uneste 3 liste
uneste([],[],List3,List3).
uneste([],[Head|List2],List3,[Head|ListR]) :-
uneste([],List2,List3,ListR).
uneste([Head|List1],List2,List3,[Head|ListR]) :-
uneste(List1,List2,List3,ListR).

% Model de joc

%1 |AAA NNN|
%2 |AA ANNN|
%3 |AANA NN|
%4 |AANAN N|
%5 |AAN NAN|
%6 |A NANAN|
%7 | ANANAN|
%8 |NA ANAN|
%9 |NANA AN|
%10 |NANANA |
%11 |NANAN A|
%12 |NAN NAA|
%13 |N NANAA|
%14 |NN ANAA|
%15 |NNNA AA|
%16 |NNN AAA|
Ex: pionii
 Condițiile laboratorului nr 10 V2:
Fie date trei bidoane – unul de 8 litri, unul de 5 litri şi unul de 3 litri. Iniţial cel de 8 litri este plin, iar
celelalte (de 5 litri şi de 3 litri) sunt deşarte. Să se găsească o secvenţă de acţiuni care lasă câte 4 litri
de apă în bidonul de 8 litri şi în bidonul de 5 litri. Acţiunile posibile care pot modifica starea
bidoanelor sunt: apa poate fi turnată dintr-un bidon în altul, până când primul se goleşte sau al doilea
se umple.
:- dynamic arhiva/3.

torn(Bidon1,Bidon2,Size,NewBid1,Size) :-
Ramas is Size - Bidon2,
Bidon1 > Ramas,
NewBid1 is Bidon1 - Ramas , !.
torn(Bidon1,Bidon2,Size,NewBid1,NewBid2) :-
Ramas is Size - Bidon2,
Bidon1 < Ramas,
NewBid1 is 0,
NewBid2 is Bidon1 + Bidon2.
bidoane(X,Y,Z):-
bidoane(X,X,0,Y,0,Z).
bidoane(4,_,4,_,0,_) :-
!, retractall(arhiva(_,_,_)).
bidoane(Bidon1,Size1,Bidon2,Size2,Bidon3,Size3) :-
torn(Bidon1,Bidon2,Size2,New1,New2), % Bidon1 -> New1 , Bidon2 -> New2
not(arhiva(New1,New2,Bidon3)),
assert(arhiva(New1,New2,Bidon3)),
format('~n[~d][~d][~d]',[New1,New2,Bidon3]),
bidoane(New1,Size1,New2,Size2,Bidon3,Size3), !.
bidoane(Bidon1,Size1,Bidon2,Size2,Bidon3,Size3) :-
torn(Bidon1,Bidon3,Size3,New1,New2), % Bidon1 -> New1 , Bidon3 -> New2
not(arhiva(New1,Bidon2,New2)),
assert(arhiva(New1,Bidon2,New2)),
 format('~n[~d][~d][~d]',[New1,Bidon2,New2]),
bidoane(New1,Size1,Bidon2,Size2,New2,Size3).
bidoane(Bidon1,Size1,Bidon2,Size2,Bidon3,Size3) :-
torn(Bidon2,Bidon3,Size3,New1,New2), % Bidon2 -> New1 , Bidon3 -> New2
not(arhiva(Bidon1,New1,New2)),
assert(arhiva(Bidon1,New1,New2)),
format('~n[~d][~d][~d]',[Bidon1,New1,New2]),
bidoane(Bidon1,Size1,New1,Size2,New2,Size3).
bidoane(Bidon1,Size1,Bidon2,Size2,Bidon3,Size3) :-
torn(Bidon2,Bidon1,Size1,New1,New2), % Bidon1 -> New2 , Bidon2 -> New1
not(arhiva(New2,New1,Bidon3)),
assert(arhiva(New2,New1,Bidon3)),
format('~n[~d][~d][~d]',[New2,New1,Bidon3]),
bidoane(New2,Size1,New1,Size2,Bidon3,Size3).
bidoane(Bidon1,Size1,Bidon2,Size2,Bidon3,Size3) :-
torn(Bidon3,Bidon1,Size1,New1,New2), % Bidon1 -> New2 , Bidon3 -> New1
not(arhiva(New2,Bidon2,New1)),
assert(arhiva(New2,Bidon2,New1)),
format('~n[~d][~d][~d]',[New2,Bidon2,New1]),
bidoane(New2,Size1,Bidon2,Size2,New1,Size3).
bidoane(Bidon1,Size1,Bidon2,Size2,Bidon3,Size3) :-
torn(Bidon3,Bidon2,Size2,New1,New2), % Bidon2 -> New2 , Bidon3 -> New1
not(arhiva(Bidon1,New2,New1)),
assert(arhiva(Bidon1,New2,New1)),
format('~n[~d][~d][~d]',[Bidon1,New2,New1]),
bidoane(Bidon1,Size1,New2,Size2,New1,Size3).

%853
%^^^
%800
 %503
%530
%233
%251
%701
%710
%413
%440
Ex: bidoane(8,5,3)
Condițiile laboratorului nr 11 V12:

% Gramatica
gramatX(s,[a,p]).
gramatX(p,[b,p]).
gramatX(p,[c,q]).
gramatX(q,[d,q]).
gramatX(q,[e,[]]).

transform([],[]).
transform([El|List1],List2) :-
transform(List1,PrevList),
gramatX(List2,[El,PrevList]).

gramatica(List) :-
transform(List,s).
Ex: gramatica([a,b,c,d,e])