Laborator 10
Problema 1
Cod:
let rec fibo = fun n->
if n=0 then 0 else
if n=1 then 1 else
fibo (n-1) +fibo(n-2);;
Apel:
fibo 7;;
Rezultat obtinut:
- : int = 13
Explicatii:
Am considerat ca primul termen sa fie 0. Adica incep de la termenul t0.
Problema 2
Cod:
let rec geninterval s e =
if s <= e then (s :: geninterval (s+1) e) else [] ;;
Apel:
geninterval 3 8 ;;
Rezultat obtinut:
- : int list = [3; 4; 5; 6; 7; 8]
Explicatii:
Cat timp este mai mic sau egal termenul de stanga cu cel din dreapta, adaug recursiv in lista, incrementand termenul din stanga.
Problema 3
Cod:
let my_and = fun expresion1 expresion2 ->
if expresion1=true then
if expresion2=true then
true else
false
else
false;;
let my_or = fun expresion1 expresion2->
if expresion1=true then
true else
if expresion2=true then
true
else
false;;
let my_not = fun expresion->
if expresion=true then false
else
true;;
Apel:
my_and (1=1) (1=1);;
my_and (1=2) (1=1);;
my_and (1=2) (1=2);;
my_or (1=1) (1=1);;
my_or (1=2) (1=1);;
my_or (1=2) (1=2);;
my_not (1=1);;
my_not (1=2);;
Rezultat obtinut:
- : bool = true
- : bool = false
- : bool = false
- : bool = true
- : bool = true
- : bool = false
- : bool = false
- : bool = true
Explicatii:
Simpla explicitare a operatiilor logice.
Problema 4
Cod:
let rec digits x =
if x == 0 then [] else (List.append (digits (x/10)) ((x mod 10) :: []));;
Apel:
digits 12345;;
Rezultat obtinut:
- : int list = [1; 2; 3; 4; 5]
Explicatii:
x mod 10 ne da ultima cifra a numarului x
x/10 elimina ultima cifra
Problema 5
Cod:
let maxim lst =
let rec aux lst x=
match lst with
| [] -> x
| hd :: tl -> aux tl (max x hd)
in aux lst (List.hd lst) ;;
Apel:
maxim [1;2;3;4;7;6;5];;
Rezultat obtinut:
- : int = 7
Explicatii:
Cu ajutorul variabilei auxiliare "x" calculez maximul.
Problema 6
Cod:
let rec cmmdc = fun a b ->
if b=0 then a
else
cmmdc b (a mod b);;
Apel:
cmmdc 12 4;;
Rezultat obtinut:
- : int = 4
Explicatii:
Algoritmul lui Euclid recursiv.
Problema 7
Cod:
let rec reverse lst =
match lst with
| [] -> []
| hd :: tl -> reverse tl @ (hd :: []);;
Apel:
reverse [1;2;3];;
Rezultat obtinut:
- : int list = [3; 2; 1]
Explicatii:
Daca lst este de forma unei liste cu head si tail, atunci concatenez tail-ul cu head-ul .
Problema 8
Cod:
let rotateLeft lst =
match lst with
| [] -> []
| hd :: tl -> tl @ (hd :: []);;
let rec rotateRight lst =
reverse (rotateLeft (reverse lst));;
Apel:
rotateLeft [1;2;3;4;5];;
rotateRight [1;2;3;4;5];;
Rezultat obtinut:
- : int list = [2; 3; 4; 5; 1]
- : int list = [5; 1; 2; 3; 4]
Explicatii:
Aceeasi logica ca si la rotatiile facute in Lisp.
Problema 9
Cod:
let u x y = x + y;;
let f x y = 2 * x + y;;
let rec apply f i lst =
match lst with
| [] -> i
| hd :: tl -> f hd (apply f i tl);;
Apel:
apply u 0 [1;2;3;4];;
apply f 1 [1;2;3;4];;
Rezultat obtinut:
- : int = 10
- : int = 21
Explicatii:
Simpla transcriere in cod a enuntului. Apelurile se fac recursiv.
Se dă o listă reprezentand o expresie aritmetica (cu operatori binari +,-,*,/) în formă prefix care conţine numere întregi şi variabile. Valorile variabilelor sunt specificate într-o a doua listă de forma ((variabila1 valoare1) (variabilă2 valoare2)…(variabilăn valoaren)). Să se scrie o funcţie LISP care returnează rezultatul evaluării unei expresii oarecare, luand în considerare valorile variabilelor. In caz că expresia conţine variabile nedefinite se returnează NIL.
Exemplu:
(evalexp ‘(* 3 (- x 1) (/ y (+ z 1))) ‘((x 6) (y 8) (z 3))
->30
OBS: Să se evidenţieze parametri actuali şi valoarea rezultată a funcţiei (funcţiilor) apelate în ordinea apelurilor/terminărilor funcţiei(funcţiilor) pentru determinarea rezultatului pe exemplul de mai sus.
Punctaj:
-din oficiu 1p, - cod 9p, (- comentarii + exemplificare cod in caz de nefunctionalitate-2p)