Esame 18 05 2015 f#

(*esercizio 1*)
(*numero di fibonacci ricorsivo*)
let rec fib (n: int): int=
    match n with
    0->1
    |1->1
    |n->fib(n-1)+fib(n-2)

let testFib = fib 10
(*numero di fibonacci con ricorsione in coda*)
let fib_tail (n: int): int =
    let rec f a b n =
        match n with
        0->b
        |n->(f b (a+b) (n-1))
    in f 0 1 n

let testFibTail = fib_tail 10

(*numero di cifre di un dato numero*)
let rec countDigits (n: int): int =
    if -10<n && n<10 then 1
    else 1+ countDigits(n/10)

let testCountDigits = countDigits 100


(*esercizio 1:
 la funzione fib_n_digits è una funzione con ricorsione in coda
 ha tipo int->int e usa usa una funzione interna aux int->int->int
 che a sua volta sfrutta una funzione esterna countDigits int->int
 countDigits viene usata per bloccare le chiamate ricorsive (invariante)
 come in un ciclo while, mentre i due valori a e b equivalgono a :
 -a -> Fibonacci n-2
 -b -> Fibonacci n-1 == Fibonacci n-2 + Fibonacci n-3
*)
let fib_n_digits (n: int): int =
    let rec aux (a: int) (b: int): int =
        if((countDigits b) = n) then b
        else aux b (a+b)
    in aux 0 1

let testFibNDigits = fib_n_digits 1


(*esercizio 2*)
let rec moltiplica (k: int) (n: int): int =
    match n with
    0->0
    |n->k+(moltiplica k (n-1))

let testMoltiplica = moltiplica 3 10

let rec tab (k: int) (n: int): int list=
    match (k, n) with
    (_,0)->[]
    |(k,n)->tab k (n-1)@[moltiplica k n]

let testTab = tab 3 10

(*esercizio 3*)
let bellaCifra (n: int): bool =
    match n with
    0|3|7->true
    |_->false;;

let bello (n: int): bool = bellaCifra(n%10) && (not(bellaCifra ((n/10)%10)))

let testBello= bello 147

(*questionario 1*)
let rec g w =
    match w with
    []->0
    |x::y->if (x%2)<>0 then x + (g y) else (g y)
(*g ha tipo int list->int --> risposta C*)

(*questionario 2*)
let testG = g [1; 2; 3; 4; 5; 6; 7; 8]
(*g [1; 2; 3; 4; 5; 6; 7; 8] = 16, g calcola la somma degli interi dispari di una lista
di interi --> risposta C*)

(*questionario 3*)
let lst = [2;4;7;5;9] = [2;4;7]@[5;9]
(*l'operatore concat @ concatena due liste --> risposta D*)

(*questionario 4*)
let rec f (x, y) =
    if x=0 then []
    else y::f(x-1, y)
(*la funzione ha tipo int*'a->'a list, per cui accetta in entrata un coppia come (5, 'a')
che resituitirà una lista del tipo ['a'; 'a'; 'a'; 'a'; 'a'] --> risposta A*)

let rec coppialiste (x: (int*int) list): (int list * int list) =
    match x with
    []->([], [])
    |[(x, y)]->([x], [y])
    |(x,y)::xs->(x::fst(coppialiste(xs)), y::snd(coppialiste(xs)))

let testcoppialiste = coppialiste([(1,2);(3,4);(5,6)])