1.Sa se defineasca si sa se aplica o functie care insumeaza nr mai mici sau egale cu n. Se va semnala eroare daca n<0.

ML: exception Error; fun sum n : int = if n < 0 then raise Error else if n = 0 then 0 else if n mod 2 = 0 then n + sum(n-1) else sum(n-1); RUFL: dec suma::Int ->Int def suma n = if n<0 then error "Numar negativ" else if n==0 then 0 else if n `mod` 2 ==0 then n+suma (n-1) else suma (n-1) 2. Sa se defineasca si sa se aplice functiile: - permutari care calculeaza numarul permutarilor de n obiecte; permutari(n) = n! - aranjamente care calculeaza numarul aranjamentelor de n obiecte luate cate k; aranjamente(n,k) = n! / (n-k)! = n*(n-1)*...*(n-k+1) - combinari care calculeaza numarul combinarilor de n obiecte luate cate k; combinari(n,k) = n! / (k! * (n-k)!) Functiile vor semnala erori daca parametrii n sau k sunt negativi sau daca k>n sau k = 0 in cazul functiei aranjamente. ML: exception Error; fun permutari n : int = if n < 0 then raise Error else if n = 1 then 1 else n * permutari(n-1); fun aranj (n:int,k:int)= if k<1 orelse n<k then raise Error else let val aux1 = permutari(n); val aux2 = permutari(n-k); in aux1 div aux2 end; fun combinari (n:int,k:int)= if k<1 orelse n<k then raise Error else let val aux1 = permutari(n); val aux2 = permutari(n-k); val aux3 = permutari(k); in aux1 div (aux2 * aux3) end; RUFL: dec permutari:: Int-> Int

def permutari n = if n < 0 then error "Eroare permutari" else if n == 1 then 1 else n * permutari(n-1) dec aranj:: (Int, Int)-> Int def aranj (n, k)= if k<1 || n<k then error "Eroare aranjamente" else let aux1 = permutari(n) aux2 = permutari(n-k) in aux1 `div` aux2 dec combinari:: (Int, Int)-> Int def combinari (n,k)= if k<1 || n<k then error "Eroare combinari" else let aux1 = permutari(n) aux2 = permutari(n-k) aux3 = permutari(k) in aux1 `div` (aux2 * aux3) 3. Sa se defineasca si sa se aplice functiile: - bisect care stabileste daca un an calendaristic este sau nu bisect. Amintim ca un an este bisect daca este divizibil cu 4 si daca este anterior lui 1582 (Calendarul Iulian). Daca este ulterior lui 1582, atunci un an este bisect daca este divizibil cu 4 si nu este divizibil cu 100 sau daca este divizibil cu 400; - nzl care determina numarul de zile dintr-o luna calendaristica; Functia bisect semnaleaza eroare daca se aplica la un an calendaristic ce nu apartine intervalului [0,4900]. Functia nzl semnaleaza eroare daca se aplica la o luna calendaristica ce nu apartine intervalului [1, 12] sau la un an calendaristic ce nu apartine intervalului [0,4900]; ML: exception anGresit fun bisect x = if (x<0 orelse x>4900) then raise anGresit else if x<1582 andalso x mod 4 = 0 then true else if ((x mod 4 = 0) andalso (x mod 100 <> 0 )) orelse (x mod 400 = 0) then true else false; exception lunaGresita; fun nzl (n, an) = case n of 1 => "31" |2 => if(bisect(an) = true) then "29" else "28" |3 => "31" |4 => "30" |5 => "31" |6 => "30"

|7 => "31" |8 => "31" |9 => "30" |10 => "31" |11 => "30" |12 => "31" |k=>raise lunaGresita; RUFL: dec bisect:: Int-> Bool def bisect x = if (x<0 || x>4900) then error "an gresit" else if x<1582 && x `mod` 4 == 0 then True else if ((x `mod` 4 == 0) && (x `mod` 100 != 0 )) || (x `mod` 400 == 0) then True else False dec nzl:: (Int, Int)-> String def nzl (n, an) = case n of 1 -> "31" 2 -> if(bisect(an) == True) then "29" else "28" 3 -> "31" 4 -> "30" 5 -> "31" 6 -> "30" 7 -> "31" 8 -> "31" 9 -> "30" 10 -> "31" 11 -> "30" 12 -> "31" k-> error "luna gresita"; 4. Sa se defineasca operatori pentru tupluri binare care definesc numere complexe ale caror parti reale si imaginare sunt numere de tip real. Se vor defini urmatorii operatori infix: +++ pentru adunarea nr complexe ### pentru scaderea nr complexe *** pentru inmultirea nr complexe === pt testul de egalitate a doua nr Sa se defineaca functia f care are ca parametru pe z de tip complex, iar ca valoare, valoarea expresiei z3 + z2 z. Apoi se va aplica functia pt argumentul (1, 2). Sa se indice rezultatul aplicatiei respective stiind ca (1,2)3 + (1,2)2 (1,2) are val (-15,0). ML: infix +++ ; fun (a1, b1) +++ (a2, b2) = (a1+a2, b1+b2);

infix ### ; fun (a1, b1) ### (a2, b2) = (a1-a2, b1-b2); infix *** ; fun (a1, b1) *** (a2, b2) = (a1*a2 b1*b2, b1*a2 + a1*b2); infix === ; fun (a1, b1) === (a2, b2) = if a1 = a2 andalso b1 = b2 then true else false; fun f(a,b) = (a,b)***(a,b)***(a,b) +++ ((a,b)***(a,b)) ### (a,b); >f(1,2); Val it = (~15,0) : int * int RUFL: infix +++ (a1, b1) +++ (a2, b2) = (a1+a2, b1+b2) infix ### (a1, b1) ### (a2, b2) = (a1-a2, b1-b2) infix *** (a1, b1) *** (a2, b2) = (a1*a2-b1*b2, b1*a2+a1*b2) infix === (a1, b1) === (a2, b2) = if a1 == a2 && b1 == b2 then True else False dec f:: (Int, Int) -> (Int, Int) def f(a,b) = ((((a,b)***(a,b))***(a,b)) +++ (((a,b)***(a,b)))) ### (a,b) 5. Sa se defineasca si sa se aplice functia intlist care are ca argument un intreg, iar ca rezultat lista ce contine cifrele intregului respectiv; Sa se defineasca si sa se aplice in LPF functia listint care este inversa functiei intlist, adica are ca argument o lista de cifre si are ca rezultat intrebul format din cifrele respective. Functia listint va semnala o eroare daca se aplica la o lista vida. intlist 7425; val it = [7, 4, 2, 5] : int list listint [7, 4, 2, 5]; val int 7425:int ML: fun intlist(n) = if n = 0 then [] else intlist(n div 10) @ [n mod 10]; fun invers [] = [] | invers(x::xs) = invers(xs) @ [x]; fun listint0 [] = 0 | listint0(n::ns) = n + 10 * listint0(ns); fun listint(l) = let val aux = invers(l); in listint0(aux) end; RUFL:

dec invers::[alpha]->[alpha] def invers([])=[] invers(x:xs)=invers(xs) ++ [x] dec listint0::[alpha]->Int def listint0([]) = 0 listint0(x:xs)=x+10*listint0(xs) dec listint::[alpha]->Int def listint(l) = let aux=invers(l) in listint0(aux) 6. Sa se defineasca o functie care insumeaza cifrele intregului pentru care este aplicata. sumcif 123; val it = 6 : int; ML: fun sumcif(n) = if n = 0 then 0 else (n mod 10) + sumcif(n div 10); RUFL: dec sumcif::Int->Int def sumcif(n) = if n == 0 then 0 else (n `mod` 10) + sumcif(n `div` 10) 7. Sa se defineasca o functie care are ca argument un intreg, iar ca valoare reprezentarea intregului respectiv sub forma unui sir de caractere. De ex, daca functia este aplicata cu intregul 123, at ea returneaza sirul 123, daca se aplica cu intregul -123, atunci ea returneaza sirul -123. ML: fun intchar0(n) = if n<0 then - ^ intchar0(~n) else if n = 0 then else intchar0(n div 10) ^ Int.toString(n mod 10) ; fun intchar(n) = if n=0 then 0 else intchar0(n); RUFL: dec toString:: Int->String def toString(n) = case n of 0 -> "0" 1 -> "1" 2 -> "2"

3 -> "3" 4 -> "4" 5 -> "5" 6 -> "6" 7 -> "7" 8 -> "8" 9 -> "9" dec intchar::Int->String def intchar0(n) = if n<0 then "-"++intchar0(-n) else if n==0 then "" else intchar0(n `div` 10)++toString(n `mod` 10) dec intchar::Int->String def intchar(n) = if n==0 then 0 else intchar0(n); 8. Sa se defineasca o functie care rezolva problema turnurilor din Hanoi ML: exception NumberIncorrect; fun hanoi(n,t1,t2,t3) = if n<=0 then raise NumberIncorrect else if n=1 then [t1^" to "^t2] else hanoi(n-1,t1,t3,t2)@[t1^" to "^t2]@hanoi(n-1,t3,t2,t1); fun turnuri_hanoi(n) = hanoi(n,"rod1","rod2","rod3") ; >> turnuri_hanoi(3); RUFL: dec hanoi :: (Int,String,String,String) ->[String] def hanoi(n,t1,t2,t3) = if n<=0 then error "Incorrect number" else if n==1 then [t1++" to "++t2] else hanoi(n-1,t1,t3,t2)++[t1++" to "++t2]++hanoi(n-1,t3,t2,t1) dec turnuri_hanoi :: (Int) -> [String] def turnuri_hanoi(n) = hanoi(n,"rod1","rod2","rod3") >>turnuri_hanoi(3) 9. Sa se defineasca si sa se aplice in ML si RUFL o functie care insumeaza numerele pare mai mici sau egale cu n. Functia semnaleaza eroare daca n<0 ML: exception WrongNumber fun sumaparnr(n,s)=if n<=0 then s else sumaparnr(n-2,s+n);

fun sumapar(n)=if n<0 then raise WrongNumber else if n mod 2 = 0 then sumaparnr(n,0) else sumaparnr(n-1,0); RUFL: dec sumaparnr::(Int,Int)->Int def sumaparnr(n,s)=if n<=0 then s else sumaparnr(n-2,s+n); dec sumapar::Int->Int def sumapar(n)=if n<0 error "raise WrongNumber" else if n `mod` 2 == 0 then sumaparnr(n,0) else sumaparnr(n-1,0); 10. Sa se defineasca o functie in ML si RUFL care insumeaza primele n numere ale lui fibonacci. Functiile semnaleaza erori daca n este negativ. ML: exception WrongNumber fun fibs(a,b,n,s)=if n=2 then s else fibs(b,a+b,n-1,s+a+b); fun sumfib(n)=if n<=0 then raise WrongNumber else if n=1 then 0 else if n=2 then 1 else fibs(0,1,n,1); RUFL: dec fibs::(Int,Int,Int,Int)->Int def fibs(a,b,n,s)=if n=2 then s else fibs(b,a+b,n-1,s+a+b); dec sumfib::Int->Int def sumfib(n)=if n<=0 then error "WrongNumber" else if n=1 then 0 else if n=2 then 1 else fibs(0,1,n,1);

11. Sa se defineasca o functie in ML si RUFL care are ca parametri doi intregi ce reprezinta numaratorul si numitorul unei fractii. Functia returneaza tuplul care contine numaratorul si numitorul fractiei de la intrare dupa ce astia au fost impartiti cu cel mai mare divizor comun al acestora, adica functia are valoare fractia de la intrarea simplificata ML: fun cmmdc(m,n) = if m=0 then n else cmmdc ( n mod m,m); fun simplifica (a,b)=let val comun = cmmdc(a,b) in ( a div comun,b div comun) end; RUFL: dec cmmdc::(Int,Int)->Int def cmmdc(m,n) = if m==0 then n else cmmdc ( n `mod` m,m) dec simplifica::(Int,Int)->(Int,Int) def simplifica (a,b)=let val comun = cmmdc(a,b) in ( a `div` comun,b `div` comun) 12. Sa se defineasca in limbajele ML si RUFL o functie de intregul n care afiseaza divizorii lui n. Functia afiseaza un mesaj de eroare daca n<1. ML: exception NrGresit fun divizori n= if n<1 then raise NrGresit else let fun dif n 1=[]| dif n k=if n mod k=0 then k::dif n (k-1) else dif n (k-1) in dif n n end; RUFL: dec divizori:: Int -> [Int] def divizori n=if n<1 then error "Incorrect number" else let divizor a b= if b==1 then [1]

else if a `mod` b==0 then (b: (divizor a (b-1))) else divizor a (b-1) in divizor n n 13. Sa se defineasca functii in ML si RUFL care determina solutia unui sistem liniar de doua ecuatii cu doua necunoscute. Se va semnala eroare daca determinantul sistemului este nul. Amintim ca sistemul: ax+by=c dx+ey=f Are solutia x=d1/d, y=d2/d ML: exception DetNegativ; fun determ a b d e = a*e-b*d; fun ecuatie a b c d e f = if determ a b d e =0 then raise DetNegativ else let val det = determ a b d e val det1 = determ c b f e val det2 = determ a c d f in (det1 div det, det2 div det) end; >> ecuatie 1 1 3 2 1 5; RUFL: dec determ:: Int Int Int Int -> Int def determ a b d e = a*e-b*d dec ecuatie:: Int Int Int Int Int Int -> (Int,Int) def ecuatie a b c d e f = if determ a b d e ==0 then error "determinant nul" else let det = determ a b d e det1= determ c b f e det2= determ a c d f in (det1`div` det,det2 `div` det) >> ecuatie 1 1 3 2 1 5

14. Folosind expresia conditionala sa se defineasca in ML si RUFL functia ziDinSaptamana care are ca argument o cifra din intervalul [1;7] si returneaza denumirea zilei din saptamana corespunzatoare cifrei respective. Astfel pentru argumentul 1 returneaza sirul de caractere "Luni" pentru argumentul 2 returneaza sirul de caractere "Marti" etc. Pentru un intreg mai mic decat 1 sau mai mare decat 7 functia returneaza un mesaj de eroare. Folosind expresia analiza de caz se va defini la fel in ML si RUFL functia ziDinSaptamana Expresie analiza de caz ML: exception NumarGresit fun zisapt(i)= case i of 1=>"Luni" |2=>"Marti" |3=>"Miercuri" |4=>"Joi" |5=>"Vineri" |6=>"Sambata" |7=>"Duminca"; |n=> raise NumarGresit; RUFL: dec zisapt::Int->String def zisapt(i)= case i of 1->"Luni" 2->"Marti" 3->"Miercuri" 4->"Joi" 5->"Vineri" 6->"Sambata" 7->"Duminca" n->error "Numarul nu e in interval" Expresie conditionala ML: exception NumarGresit

fun zisapt(i)= if i=1 then "Luni" else if i=2 then "Marti" else if i=3 then "Miercuri" else if i=4 then "Joi" else if i=5 then "Vineri" else if i=6 then "Sambata" else if i=7 then "Duminca"; else raise NumarGresit; RUFL: dec zisapt::Int->String def zisapt(i)= if i==1 then "Luni" else if i==2 then "Marti" else if i==3 then "Miercuri" else if i==4 then "Joi" else if i==5 then "Vineri" else if i==6 then "Sambata" else if i==7 then "Duminca"; else error "Numarul nu e in interval" 15. Sa se defineasca in ML si RUFL functia prim care are ca argument un numar natural si stabileste daca argumentul pentru care a fost apelata este sau nu numar prim ML: exception WrongNumber fun divizor(n,i)=if i>n div 2 then true else if n mod i = 0 then false else divizor(n,i+1); fun prim n=if n <= 0 then raise WrongNumber else divizor(n,2); RUFL: dec divizor::(Int,Int)->Bool def divizor(n,i)=if i>n `div` 2 then True else if n `mod` i == 0 then False else divizor(n,i+1);

dec prim::Int->Bool def prim(n) = if n>0 then divizor(n,2) else error "WrongNumber" 16. Sa se defineasca in limbajele ML si Rufl operatorul infix de ridicare la o putere intreaga a unui numar real. ML ---aici ar trebui cumva ca x sa fie real,dar nustiu ce sai fac. Functioneaza doar cu x intreg rezolvarea asta la ML infixr 9 rid; fun x rid y =if y<0 then 0 else if y=0 then 1 else x*x rid (y-1); RUFL: infixr 9 @@ dec(@@)::Real->Int->Int def x @@ y = if y<0 then 0 else if y==0 then 1 else x*x @@ (y-1) 17. Sa se defineasca in limbajele ML si RUFL functia assoc care gaseste intr.o lista de asociatii valoarea corespunzatoare unei chei. Sa se aplice functia assoc la lista de mai jos pentru a traduce un pronume din engleza in romana ML: fun assoc (x, [])= [] | assoc(x, (y,z)::lp)= f x=y then z else assoc(x, lp); RUFL: dec assoc:: (alpha, [(alpha,[ beta])])-> [beta] dec assoc(x,[])=[] assoc (x,(y,z):lp)= if x==p then z else assoc(x,lp)

18. Sa se defineasca in ML si RUFL functia cmmmc pentru calcului celui mai mic multiplu comun a doi intregi ne nuli. Se utilizeaza relatia: cmmmc(m,n)=m * n / cmmdc(m,n) unde prin cmmdc s-a notat functia de calcul a celui mai mare divizor comun a doi intregi Functiile definite semnaleaza eror in cazul in care unul din parametri sau ambii sunt nuli sau negativi . Inainte de a defini functia cmmmc se va defini functia cmmdc ML: exception WrongNumber fun cmmdc(m,n)=if m=0 then n else cmmdc(n mod m ,m); fun cmmmc (a,b)=if a<=0 then raise WrongNumber else if b<=0 then raise WrongNumber else let val comun=cmmdc(a,b) in (a*b) div comun end; RUFL: dec cmmdc::(Int,Int)->Int def cmmdc(m,n)=if m==0 then n else cmmdc(n `mod` m ,m) dec cmmmc::(Int,Int)->Int def cmmmc (a,b)=if a<=0 then error "WrongNumber" else if b<=0 then error "WrongNumber" else let comun=cmmdc(a,b) in (a*b) `div` comun 19. Sa se defineasca in ML si RUFL o functie care are ca parametru o lista de intregi ce reprezinta coeficientii unui polinom si care are ca rezultat lista ce contine coeficientii derivatei polinomului respectiv. Coeficientii din listele parametru si rezultat sunt in ordine descrescatoare a puterilor termenilor celor 2 liste ML:

exception ListaVida fun invers []=[] | invers (x::xs) = invers xs @ [x]; fun derive xs=let fun deriv [] p ys=ys |deriv (c::cs) p ys = if p=0 then deriv cs (p+1) ys else deriv cs (p+1) (c*p::ys) in deriv (invers xs) 0 [] end; RUFL: dec invers::[alpha]->[alpha] def invers []=[] | invers (x:xs) = invers xs ++ [x] dec derive::[alpha]->[alpha] def derive xs=let deriv [] p ys=ys |deriv (c:cs) p ys = if p==0 then deriv cs (p+1) ys else deriv cs (p+1) (c*p:ys) in deriv (invers xs) 0 []