Exemplu - Facultatea de Electrotehnică şi Electroenergetică

Universitatea “Politehnica” din Timişoara
Facultatea de Electrotehnică şi Electroenergtică
Departamentul de Electroenergetică
PROLOG
și
Elemente lemente de inteligenţă artificială
Curs 5
• OPERATII DE CITIRE / SCRIERE (I/O)
• OPERAŢII Ţ CU ŞIRURI Ş DE CARACTERE
Curs Anul 3 Electroenergetică
Titular disciplină: Ş.l.dr.ing. Ioan BORLEA

Cap. Cap Cap. 7 OPERATII DE DE CITIRE CITIRE / / SCRIERE SCRIERE (I/O)
(I/O)
Scrierea
Predicatul de scriere prezintă sintaxa:
write(arg1, it ( 1 ... ,argn) )
în care argumentele pot fi constante sau variabile legate ce aparţin unor
domenii standard sau definite de programator.
În interiorul şirului de caractere care pot fi afisate pe ecran,
sunt acceptate
următoarele u ătoaeecaacteedeco caractere de control: to
\n n – scrie pe linie nouă, \t t – tabulator,
\r r – enter, \nnn nnn – scrie caracterul cu codul ASCI nnn nnn.
Exemplu Exemplu: : goal write (" ("\t t Lista1 = ", L1, " "\ n\ t Lista2 = ", L2).
rezultă Lista1 = [ [] ]
Lista2 = [1, 22]

Scrierea cu format:
writef(formatstring, argument)
în care formatstring poate conține codurile:
Cod semnificatie

Citirea
Citirea este realizată de următoarele predicate p ppredefinite:
readint(X) - citirea variabilelor de tip întreg;
readreal(X) - citirea variabilelor din domeniul real.
readln(X) - citirea variabilelor din domeniul symbol sau string;
readchar(X) - citirea caracterelor
caracterelor.
readterm(domain, X) – citirea variabilelor cu domeniul precizat
readint, readreal, readln și readterm- operaţia de citire se termină în
momentul apăsării tastei enter după introducerea numărului dorit;
tastarea enter fără vreun carater numeric conduce la eșec (fail). (fail)
redachar - este întotdeauna un succes (citește doar un caracter);

Exemple
1. Construți o procedură care să citească de la tastaură numere întregi și
să construiască o listă cu acestea.
domains
lista=integer g *
predicates
citeste(lista)
domains
lista=integer g *
predicates
citeste(lista, lista)
clauses
clauses
citeste([ E | Rest]) if
citeste(L1, L2) if
write("Element="),
write("Element="),
it ("El t ")
readint(E),
readint(E), E0,
citeste(Rest).
L1nou=[ E| L1],
citeste( it t ( [ ] ) ). {% {%citirea iti se ttermină i ă
citeste(L1nou, it t (L1 L2) L2).
cu elementul vid}
goal
citeste(L, L). {%citirea se termină cu 0}
citeste(L) citeste(L), write(L). write(L)
goal
citeste( [ ] , L), write(L).

22. Construiţi o procedură care să asigure scrierea unei liste cu elemente
numere întregi pe rânduri succesive, fiecare rând având 3 elemente.
domains
lista = integer*
predicates
scrie(lista)
scrie_rind(lista, i i d(li t iinteger) t )
clauses
scrie (L) if
write(„ \ n ”),
scrie_rind(L, 0).
scrie_rind ( [ ], _ ). % oprirea procesului
recursiv
scrie_rind (L, 3) if
write(„\n”),
scrie scrie_rind(L, rind(L 0) 0).
scrie_rind ([E|Rest], N) if
write(" write( "E) ,E),
N1=N+1,
scrie_rind(Rest, N1).

3. Specificaţi setul de clauze care să asigure citirea unei liste a căror
elemente sunt obiecte compuse de forma:
persoana = p(nume, prenume, vârstă)
domains
nume, prenume = symbol
persoana = p( nume, prenume, integer)
lista = persoana *
predicates
citesc(lista)
citeste(persoana)
clauses
citeste( p( N, P, V)) if
nl,
write("Nume="), ( ) readln( ( N ), )
write("Prenume="), readln( P ),
write("Virsta="), readint( V ),
nl.
citesc( [ E | R ] ) if
citeste( E ),
citesc( R ).
citesc( [ ] ).

Cap. 8 OPERAŢII CU ŞIRURI DE CARACTERE
Operatii de divizare / compunere a unui şir
A. La nivelul unui caracter:
frontchar(Sir, Elem, Rest_sir)
Exemplu: p
frontchar( "Radu Dan Ion", E, R) % varianta (i,o,o):
E='R', R = "adu Dan Ion"
1 solution
Varianta (o,i,i) recompune şirul, alte moduri de lucru: (i,o,i), (i,i,o), (i,i,i).
B. La nivelul unui element al şirului:
fronttoken(Sir, Elem, Rest_sir)
EExemplu: l
fronttoken( "12 Dan Ion", E, R) % varianta (i,o,o)
E="12", R = "Dan Ion"
1 solution l ti
Prezintă aceleaşi moduri de lucru ca si frontchar.

Exemplu: Construiţi o procedură care să desfacă un şir în elemente
componente: t
a) la nivel de caracter si
b) la nivel de element de şir.
% descompunerea la nivel de caracter % descompunerea la nivel de șir
domains
lista= char*
predicates
desfac(string, lista)
clauses
desfac("" desfac( , [ ]) ]).
desfac(S, [C| Lista]) if
frontchar(S, C, Rest_s),
desfac(Rest_s, Lista), !.
domains
elem= string
lista= elem*
predicates
desfac(string, lista)
clauses
desfac( S, [E| Lista]) if
fronttoken( SS, EE, Rest) Rest),
desfac( Rest, Lista), !.
desfac( _, [ ]).

Comenzi şi operaţii de determinare a tipului de domeniu
char char_int(char, int(char integer) - con converteşte erteşte un n caracter în valoarea aloarea ASCII (i (i,o) o)
sau invers (o, i), sau verifica egalitatea dintre
codul caracterului si întreg (i, i)
str_char(string, char) - converteşte un caracter într-un şir (o, i), sau un
şir cu un singur caracter într-un caracter (i, o)
str_int(string, integer) - converteşte un şir numeric într-un întreg (i, o)
sau invers (o, i) sau verifică corespondenta
dintre cele două
str str_real(string, real(string real) - similar cu str str_int, int pentru numere reale
isname(string) - verifică dacă variabila este un nume (începe
cu o litera şi continua cu cifre sau litere)

Operatii auxiliare cu șiruri de caractere
str_len(string, integer)
- determină lungimea şirului (i, o) sau o verifică (i, i)
frontstr(integer, string, string, string)
concat(string, string, string)
- îîmparte t primul i l şir i îîn două, d ă primul i l având â d llungimea i
dată de întreg;
poate p fi folosit numai ca (i, (, i, , o, , o). )
- concatenează primele două şiruri în al treilea;
numai (i, i, o).

Exemplu: Construiţi o procedură care să determine tipurile de elemente din
care este alcătuit un şir. şir De exemplu:
alcătuit("12 a beta", R) va rezulta R=[nr(12), car('a'), nume("beta")].
domains
element = nr(integer); car(char); nume(string)
lista = element*
predicates
alcatuit(string, lista) % desface sirul in elementele componente
este(string, element) % determinarea tipului
clauses
este(E, nr(N)) if str_int(E,N).
este(E, car(C)) if str_char(E,C).
este(E, ( , nume(E)) ( )) if isname(E). ( )
alcatuit(Sir, [Tip | L ]) if
fronttoken(Sir, E, Restsir),
este(E, Tip), alcatuit(Restsir, L), !.
alcatuit(_,[]).

EExemplu: l CConstruiţi t iţi o procedura d care să ă permită ită o analiză li ă gramaticală ti lă simplă i lă
pentru propoziţii simple de forma: "Tom is a cat".
Pentru a detecta şi stabili predicatele, se porneşte de la analiza gramaticală a
propoziţiilor de forma:
analizeaza ( "Tom is a cat", R )
R = structura(substantiv("Tom"), expe_verb("is", expr_substantivala("a", "cat")))
analizeaza (“ is a cat”), R )
R = structura(predicat("is"), expr_substantivala("a", "cat"))
analizeaza ( "a cat", R)
R = structura(articol("a"), substantiv("cat"))

domains
subst, pred, art = string
e_subst = s(subst); e_subst (art, subst)
e_verb b = p(pred); ( d) e_verb b ( (pred, d e_subst) b t)
propozitie = structura (e_subst, e_verb)
predicates
analizeaza(string, propozitie)
este_e_subst(string, string, e_subst)
este_e_verb(string, e_verb)
a(art) ( t)
s(subst)
p(pred)
clauses
analizeaza(Sir, structura(S_exp, V_exp)) :este_e_subst(Sir,
Rest, S_exp),
este_e_verb(Rest, t b(R t V_exp). V )
a("the"). a("a").
s("Tom"). ( ) s("Bill"). ( ) s("dog"). ( g ) s("cat"). ( )
p("is"). p("has").
Analizor gramatical
este_e_subst(Sir, Rest, e_subst(Art, Subst)):fronttoken(Sir
fronttoken(Sir, Art,Rest1), Art Rest1)
a(Art),
fronttoken(Rest1, Subst, Rest),
s(Subst).
este_e_subst(Str, Rest, s(Subst)):fronttoken(Str,
Subst, Rest),
s(Subst).
este_e_verb(Str, e_verb(Pred, S_exp)):fronttoken(Str,
Pred, Rest1),
p(Pred),
este_e_subst(Rest1,"",S_exp).
este_e_verb(Str, p(Pred)):fronttoken(Str,
Pred, ""),
p(Pred) p(Pred).

Exemplu: Construiţi o procedură care asigure împărţirea în silabe a unui cuvânt.
Reguli de despartire:
a) )l la o secvenţă ţă de d ti tipul l vocală lă-consoană ă -vocală, lă îîmpărţirea ă ţi se fface ddupă ă
prima vocală: (prolog-> pro-log),
(regula-> re-gu-la);
b) la o secvenţă de tipul vocală - consoană - consoană - vocală vocală, împărţirea se
face între cele două consoane (turbo -> tur-bo);
c) excepţiile se exclud.
domains /* structura de tip sir de caractere a unui cuvânt */
litera = char
cuvant = litera* litera % sirul de caractere este despărtit în literele componente
predicates
repeta /* asigură repetarea */
vocala(litera) /* distingerea între vocală-consoană */
consoana(litera)
sir_cuvant(string, cuvant) /* transformarea unui şir în lista de caractere şi invers */
divide(cuvant divide(cuvant, cuvant cuvant, cuvant cuvant, cuvant) /* / impartirea în silabe */ /
/* divide(caractere prelucrate, rest de prelucrat, silaba 1, silaba 2)*/
clauses
vocala('a'). vocala('e'). vocala('i').
vocala('o'). vocala('u'). vocala('y').
consoana(C) if not(vocala(C)), C>= 'a', C

clauses % continuare
sir_cuvant("", [ ] ).
sir_ cuvant(S, ( , [C| [ | Lista]):- ])
frontchar(S, C, Rest_sir),
sir_cuvant(Rest_sir, Lista).
divide(Inceput divide(Inceput, [L1 [L1, L2 L2, L3| Rest] Rest], Silaba1 Silaba1, [ L2 L2, L3| Rest]) :vocala(L1),
consoana(L2), vocala(L3),
conc(Inceput, [L1], Silaba1).
divide(Inceput, ( p [ [L1, L2, L3, L4| | Rest], ] Silaba1, [L3,L4| [ | Rest]) ]) if
vocala(L1), consoana(L2), consoana(L3), vocala(L4),
conc(Inceput, [L1, L2], Silaba1).
divide(Inceput, [Litera| Rest], Sil1, Sil2) if
conc(Inceput conc(Inceput, [Litera] [Litera], Prelucrat) Prelucrat),
divide(Prelucrat, Rest, Sil1, Sil2), !.
divide( _, [ ], [ ], [ ]).
repeta.
repeta:- repeta.
goal /* citeşte cuvinte şi le desparte în silabe */
goal / citeşte cuvinte şi le desparte în silabe /
repeta, write("cuvant = "), readln(C),
sir_cuvant(C, Lista_car),
divide( [ ] , Lista_car, S1, S2),
sir_cuvant(Sil1, S1), sir_cuvant(Sil2, S2),
write(Sil1, "-", Sil2), nl, fail.

Cursul Cursul viitor viitor urmează:
urmează:
TEHNICI DE CONSTRUIRE A INTERFEŢELOR GRAFICE
UTILIZATOR
OPERAȚII CU FIŞIERE