Napisz w Prologu klauzule, obliczajaca pole kwadratu
pole_kw(A) :- write('Pole = '),X is A*A,write(X).
Napisz w Prologu klauzule, obliczajaca pole koła
okrag(R) :- write('Pole='),P is 3.14*R*R,write(P).
Napisz w Prologu klauzule, obliczajaca srednia arytmetyczna dwoch liczb
srednia(X,Y) :- Z is (X+Y)/2, write(Z).
Dla nastepujacych faktow:
figura(kwadrat,4).
figura(trojkat,3).
figura(trapez,4).
figura(pieciokat_foremny,5).
figura(szczesciokat_foremny,6).
figura(osmiokat_foremny,8).
figura(dziesieciokat_foremny,10).
napisz klauzule, ktora wypisze tylko nazwy figur, ktore maja nie wiecej niz piec scian.
mn5(X) :- figura(X,Y),Y=<5.
Załóżmy, że zapisano w formie klauzul Prologu następujące relacje:
ojciec(X,Y) /* X jest ojcem Y */
matka(X,Y) /* X jest matka Y */
mezczyzna(X) /* X jest mezczyzna */
kobieta(X) /* X jest kobieta */
rodzic(X,Y) /* X jest rodzicem Y */
diff(X,Y) /* X i Y sa rozne */
nalezy zapisac klauzule definiujace relacje:
jest_matka(X) /* X jest matka */
jest_ojcem(X) /* X jest ojcem */
jest_synem(X) /* X jest synem */
siostra(X,Y) /* X jest siostra Y */
dziadek(X,Y) /* X jest dziadkiem */
rodzenstwo(X,Y) /* X i Y sa rodzenstwem */
kobieta(anna).
kobieta(jola).
kobieta(maria).
kobieta(martyna).
mezczyzna(tomasz).
mezczyzna(jurek).
mezczyzna(jan).
mezczyzna(bartek).
mezczyzna(olaf).
rodzic(tomasz,maria).
rodzic(anna,jola).
rodzic(maria,jurek).
rodzic(maria,martyna).
rodzic(jan,jurek).
rodzic(jan,martyna).
rodzic(bartek,olaf).
ojciec(X,Y):- rodzic(X,Y),mezczyzna(X).
matka(X,Y):- rodzic(X,Y),kobieta(X).
diff(X,Y):- rodzic(X)\=rodzic(Y).
jest_matka(anna).
jest_matka(maria).
jest_ojcem(jan).
jest_ojcem(bartek).
jest_synem(jurek).
jest_synem(olaf).
siostra(X,Y):- kobieta(X),rodzic(Z,X),rodzic(Z,Y),X\=Y.
dziadek(X, Y):- mezczyzna(X),rodzic(X, Z),rodzic(Z, Y).
rodzenstwo(X,Y):-rodzic(Z,X),rodzic(Z,Y),X\=Y.
% Znajdź ostatni element listy:
% ?- my_last(X,[a,b,c,d]).
% X = d
% last(?Elem, ?Lista) jest predefiniowane
my_last(X,[X]).
my_last(X,[_|L]) :- my_last(X,L).
% Znajdź n-ty element listy:
% ?- element_at(X,[a,b,c,d,e],3).
% X = c
% nth1(?Index, ?List, ?Elem) jest predefiniowane
element_at(X,[X|_],1). % z listy X znajduje element pierwszy czyli glowe bo podana jest 1
element_at(X,[_|T],Y) :- Y > 1, Y1 is Y - 1, element_at(X,T,Y1).
% Napisz klauzulę odwracającą list
% reverse(+List1, -List2) jest predefiniowane
% Odwrócić kolejność elementów w Lista1 i ujednolicić wynik elementów z List2.
reverse([],[]).
reverse([X|L],R):-
reverse(L,RL),
append(RL,[X],R).
Napisz klauzulę stwierdzającą, czy elementy listy tworzą palindrom
palindrome(L):- reverse(L,L).
my_reverse([],[]).
my_reverse([H|T],R):- my_reverse(T,T1),append(T1,[H],R).
% Największy wspólny dzielnik 2 liczb
% nwd(X,Y,N) :- X,Y to liczby N to NWD
nwd(X,0,X) :- X > 0.
nwd(X,Y,N) :- Y > 0, Z is X mod Y, gcd(Y,Z,N).
Napisz predykat liczący silnię danej liczby
silnia(0,1):-!.
silnia(1,1):-!.
silnia(N,X):- M is N-1, silnia(M,Y), X is Y*N.
Napisz predykat znajdujący maksymalna (minimalną) wartość w liście.
maximum([G],G).
maximum([G|O],Max):-maximum(O,Max1),
(G>=Max1, Max=G; G<Max1, Max=Max1). minimum([G],G).
minimum([G|O],Min):- minimum(O, Min1),
(G=<Min1, Min=G; G>Min1, Min=Min1).
Zdefiniuj predykat liczący sumę wszystkich elementów listy
suma(L,Suma).
suma([G], G):-!.
suma([G|O], Suma):- suma(O,Y), Suma is Y+G.
Jak wypisać jednym poleceniem wszystkie permutacje liczb 1-5 ? Użyj predykatu wbudowanego permutation.
Permutation([1,2,3,4,5], X).
System dwójkowy:
cyfra(0).
cyfra(1).
liczba(X):-
cyfra(S),
cyfra(D),
cyfra(J),
X is 4*S+2*D+J,write(S),write(D),write(J).
Wypisanie listy:
p([1,2,3]).
wypisz_liste([]).
wypisz_liste(Lista) :- Lista = [Glowa|Ogon], write(Glowa), nl, wypisz_liste(Ogon).
%%% Prosty program ilustruj±cy ideę generacji/wyszukiwania rozwiazań w Prologu
% Fakty: definicja dostepnych cyfr.
cyfra(0).
cyfra(1).
cyfra(2).
cyfra(3).
cyfra(4).
cyfra(5).
cyfra(6).
cyfra(7).
cyfra(8).
cyfra(9).
% Przykładowa definicja liczby trzycyfrowej
liczba(X):-
cyfra(S),
cyfra(D),
cyfra(J),
X is 100*S+10*D+J.
% Przykład wypisywania liczb od 0 do 999.
write999 :-
liczba(X),
write(X),nl,
fail.
write999 :-
write('=====').
% Przykład wypisywania liczb z zadanego zakresu od A do Z
% Uwaga: przykład ma charakter logiczny; uzyta metoda nie jest efektywna
writeAZ(A,Z) :-
liczba(X),
X >= A,
X =< Z,
write(X), nl,
fail.
writeAZ(_,_) :-
write('=====').
% Modyfikacje:
% 1. Zmiana zakresu.
% 2. Zmiana kolejności.
% 3. Zmiana sposobu wypisywania.
% eof
Zadanie logiczne:
% Fakty: definicja dostępnych cyfr.
cyfra(0).
cyfra(1).
cyfra(2).
cyfra(3).
cyfra(4).
cyfra(5).
cyfra(6).
cyfra(7).
cyfra(8).
cyfra(9).
% Skrót nazwy predykatu cyfra/1.
c(X) :- cyfra(X).
% Rozwiązanie dla problemu SEND + MORE = MONEY
solve :-
c(S),c(E), c(N), c(D), c(M), c(O), c(R), c(Y), M > 0,
S \= E, S \= N, S \= D, S \= M, S \= O, S \= R, S \= Y,
E \= N, E \= D, E \= M, E \= O, E \= R, E \= Y,
N \= D, N \= M, N \= O, N \= R, N \= Y,
D \= M, D \= O, D \= R, D \= Y,
M \= O, M \= R, M \= Y,
O \= R, O \= Y,
R \= Y,
L1 is S*1000 + E*100 + N*10 + D,
L2 is M*1000 + O*100 + R*10 + E,
L3 is M*10000 + O*1000 + N*100 + E*10 + Y,
Q is (L1 + L2) - L3, % write(Q),nl,
Q = 0,
write(' '),write(S),write(E),write(N),write(D),nl,
write('+'),write(M),write(O),write(R),write(E),nl,
write(M),write(O),write(N),write(E),write(Y).
Napisz program w języki Prolog rozwiązujący następujący kryptogram:
$$\frac{\begin{matrix}
\mathbf{\text{\ \ \ \ \ \ \ \ \ \ \ \ G\ \ R\ \ A\ \ D}} \\
\mathbf{+ D\ \ E\ \ S\ \ Z\ \ C\ \ Z} \\
\end{matrix}}{\mathbf{\text{\ \ \ \ S\ \ T\ \ R\ \ A\ \ T\ \ A}}}$$
Rozwiązanie:
$$\frac{\begin{matrix}
\mathbf{\ \ \ \ \ \ \ \ 8475} \\
\mathbf{+ 596232} \\
\end{matrix}}{\mathbf{\ \ \ \ 604707}}$$
cyfra(0).
cyfra(1).
cyfra(2).
cyfra(3).
cyfra(4).
cyfra(5).
cyfra(6).
cyfra(7).
cyfra(8).
cyfra(9).
c(X) :- cyfra(X).
solve :-
c(G),c(R), c(A), c(D), c(E), c(S), c(Z), c(C), c(T), E > 0,
G \= R, G \= A, G \= D, G \= E, G \= S, G \= Z, G \= C, G \= T,
R \= A, R \= D, R \= E, R \= S, R \= Z, R \= C, R \= T,
A \= D, A \= E, A \= S, A \= Z, A \= C, A \= T,
D \= E, D \= S, D \= Z, D \= C, D \= T,
E \= S, E \= Z, E \= C, E \= T,
S \= Z, S \= C, S \= T,
Z \= C, Z \= T,
C \= T,
L1 is G*1000 + R*100 + A*10 + D,
L2 is D*100000 + E*10000 + S*1000 + Z*100 + C*10 + Z,
L3 is S*100000 + T*10000 + R*1000 + A*100 + T*10 + A,
Q is (L1 + L2) - L3, % write(Q),nl,
Q = 0,
write(' '),write(G),write(R),write(A),write(D),nl,
write('+'),write(D),write(E),write(S),write(Z),write(C),write(Z),nl,
write(S),write(T),write(R),write(A),write(T),write(A).
W pewnym lesie mieszka lew i nosorożec, Lew kłamie w poniedziałki, wtorki, środy,
w pozostałe dni mówi prawdę, nosorożec kłamie w czwartki, piątki i soboty w pozostałe dni mówi prawdę.
Na pytanie jaki był wczoraj dzień odpowiedzieli:
Lew: wczoraj był jeden z dni w które kłamię,
Nosorożec: wczoraj był jeden z dni w których ja również kłamię.
Jaki to był dzień ?
Odp: Czwartek
http://www.im.pwr.wroc.pl/~przemko/prolog/blog-3/files/e515007a77e7462376fe0c3622917e9f-1.html
klamie(lew,pon).
klamie(lew,wtorek).
klamie(lew,sroda).
klamie(nosorozec,czwartek).
klamie(nosorozec,piatek).
klamie(nosorozec,sobota).
wczoraj(niedziela,sobota).
wczoraj(pon,niedziela).
wczoraj(wtorek,pon).
wczoraj(sroda,wtorek).
wczoraj(czwartek,sroda).
wczoraj(piatek,czwartek).
wczoraj(sobota,piatek).
wczoraj_klamie(Kto,Wczoraj):-
klamie(Kto,Wczoraj),
wczoraj(Dzis,Wczoraj),
not(klamie(Kto,Dzis)).
wczoraj_klamie(Kto,Wczoraj):-
klamie(Kto,Dzis),
wczoraj(Dzis,Wczoraj),
not(klamie(Kto,Wczoraj)).
jaki_dzien(Wczoraj):-
wczoraj_klamie(lew,Wczoraj),
wczoraj_klamie(nosorozec,Wczoraj).
Napisz program w prologu, który rozwiązuje układ równań:
http://www-users.mat.umk.pl/~fly/materialy/pl/referaty/CLP_rosi.pdf
y = 2x2 − 5x − 9
y = −x2 + 8x + 2
Jako dziedzinę wartości argumentów przyjmij przedział z zakresu (-1000,1000)
Napisz program w prologu, który generuje listę n-elementową wartości będących liczbami pierwszymi,
for(I, Start, Finish):-
Start > Finish, !, fail;
I is Start;
for(I, Start + 1, Finish).
isPrime(N):-
for(I, 2, N - 1),
0 is N mod I, !, fail;
!.
allPrimes(Start, Finish):-
for(I, Start, Finish),
isPrime(I), write(I), write(' '), fail.
Napisz program w prologu, który oblicza sumę iloczynów wartości całkowitych umieszczonych na dwóch listach,
il1([],1) :- !.
il1([H|T],W1) :- il1(T,WX), W1 is WX*H.
il1([],0).
il2([],1) :- !.
il2([H2|T2],W2):- il2(T2,WY),W2 is WY*H2 .
il2([],0).
zad([],[],0).
zad([G1|O1],[G2|O2],S) :- il1([G1|O1],X1), il2([G2|O2],X2), S is X1+X2.
Napisz program w prologu, który symuluje zachowanie półsumatora jednobitowego,
and(0,0,0).
and(0,1,0).
and(1,0,0).
and(1,1,1).
xor(0,0,0).
xor(0,1,1).
xor(1,0,1).
xor(1,1,0).
zad(A,B,P,S) :- and(A,B,P), xor(A,B,S).
Napisz program w prologu, który symuluje działanie multipleksera o dwóch wejściach adresowych,
not(1,0).
not(0,1).
and(1,1,1).
and(1,0,0).
and(0,1,0).
and(0,0,0).
or(1,1,1).
or(1,0,1).
or(0,1,1).
or(0,0,0).
zad(A,B,Y) :-not(A,NA), not(B,NB), and(A,B,W1), and(A,NB,W2), and(NA,B,W3), and(NA,NB,W4), or(W1,W2,WO1), or(WO1,W3,WO2), or(WO2,W4,Y).
Napisz program w prologu, który symuluje działanie demultipleksera o dwóch wejściach adresowych,
Za pomocą język prolog, zweryfikuj czy funkcja logiczna:
A + !B*C !C+B*A
jest tautologią,
not(1,0).
not(0,1).
and(0,0,0).
and(0,1,0).
and(1,0,0).
and(1,1,1).
or(0,0,0).
or(0,1,1).
or(1,0,1).
or(1,1,1).
eq(1,0,0).
eq(0,1,0).
eq(1,1,1).
eq(0,0,1).
zad(A,B,C,Y):- not(B,NB), not(C,NC), and(A,NB,W1), or(W1,C,W3), and(NC,B,W2),or(W2,A,W4), eq(W3,W4,Y).
Zweryfikuj czy prawo pochłaniania jest tautologią.
and(0,0,0).
and(0,1,0).
and(1,0,0).
and(1,1,1).
or(0,0,0).
or(0,1,1).
or(1,0,1).
or(1,1,1).
st(1,0,0).
st(1,1,1).
st(0,1,1).
st(0,0,1).
pr1(P,Q,Y) :- or(P,Q,W1), st(P,W1,Y).
pr2(P,Q,Y) :- and(P,Q,W1), st(W1,P,Y).
W pewnym lesie mieszka lew i nosorożec, lew kłamie we wtorek, środę i czwartek
w pozostałe dni mówi prawdę, nosorożec kłamie w piątek, sobotę i niedzielę w pozostałe dni
mówi prawdę. Na pytanie jaki był wczoraj dzień tygodnia odpowiedzieli:
Lew: wczoraj był jeden z dni w które kłamię,
Nosorożec: wczoraj był jeden z dni w których ja również kłamię.
Jaki był wczoraj dzień ?
Napisz predykat, który rozwiązuje podane zadania, wypisując odpowiedni dzień tygodnia.
Napisz regułę symulującą działania multipleksera o czterech wejściach binarnych i jednym
wyjściu. W wyniku działania reguły, na wyjścia powinna zostać zwrócona wartość
odpowiedniego wejścia wynikająca z ustawionych bitów adresu.
not(1,0).
not(0,1).
nand(1,0,1).
nand(0,1,1).
nand(1,1,0).
nand(0,0,1).
multipleks(A,B,D0,D1,D2,D3,X):- not(A,G),
not(B,H),
not(H,I),
not(G,J),
nand(D0,H,C),
nand(D1,H,D),
nand(D2,I,E),
nand(D3,I,F),
nand(C,E,K),
nand(D,F,L),
nand(K,G,M),
nand(L,J,N),
nand(M,N,X).
qqq:- A is 0; A is 1, B is 0; B is 1, D0 is 0; D0 is 1, D1 is 0; D1 is 1, D2 is 0; D2 is 1, D3 is 0; D3 is 1.
Wyszukiwarka