Loading...
(define diffs
(lambda (txt)
(if (null? (cdr txt)
'()
(cons (- (cadr txt) (car txt)) (diffs (cdr txt)))
)
))
Valori Procedurali di una funzione g(x)= f(x-s)
(define shift
(lambda (fs t)
(lambda (m)
(fs (- m t))
)))
(define h (shift (lambda (x) (* x x )) 3))
(h 0)
Loading...
Scheme:
(define ht
(lambda (d)
(lambda (k)
(if (= k 0)
(if (> d 0) 0 1)
(+ (* 2 ((ht d) (- k 1)))
((ht (remainder (+ d 3) 4)) (- k 1))
((ht (remainder (+ d 1) 4)) (- k 1)))
))))
(let ((f (ht 1))) (f 2))
Java:
public class tile {
public static int tiles (int d, int k){
if (k == 0)
if (d > 0)
return 0;
else
return 1;
else
return (2* (tile.tiles (d, (k-1)))) + (tiles (((d + 3) %4), (k -1))) + (tiles (((d + 1) % 4), (k - 1)));
}
}
Loading...
Definisci in Scheme un programma su una procedura ricorsiva di coda, più eventuali procedure non ricorsive, per trovare minimo e massimo da una lista.
(define mix
(lambda (m n)
(if (< m n)
m
n)
))
(define max
(lambda (m n)
(if (> m n)
m
n)
))
(define f
(lambda (txt)
(f-tr txt (car txt) (car txt))
))
(define f-tr
(lambda (t m n)
(if (null? (cdr t)) (list m n)
(f-tr (cdr t) (mix m (mix (car t) (cadr t))) (man n (man (car t) (cadr t))))
)))
(f '(2 3 4 1 5 4 3 7 9 10))
Altra soluzione assai più esigua che utilizza molto l’ingegno ;)
(define min-max
(lambda (nums)
(min-max-tr (car nums) (car nums) (cdr nums))
))
(define min-max-tr
(lambda (min max nums)
(if (null? nums)
(list min max)
(min-max-tr
(if (< (car nums) min) (car nums) min)
(if (> (car nums) max) (car nums) max)
(cdr nums))
)))
Loading...
Definiamo in Scheme una procedura a valori procedurali cycle-funzione che data una lista restituisce una funzione periodica e restituisce il valore alla posizione indicata della lista:
(define cycle-fun
(lambda (n)
(lambda (count)
(if (= count 0)
(car n)
(if (> count 7) ((cycle-fun n)
(- count 8))
(list-ref n count)
)
)
)))
(define f (cycle-fun '(0 -1 -2 -1 0 1 2 1)))
;esempi di lancio della procedura
; f di 2 -> -2
; f di 11 -> -1
(f 2)
(f 11)
Soluzione “matematica” alternativa più complessa (secondo il mio punto di vista)
(define cycle-fun
(lambda (p)
(lambda (x) ; x >= 0
(list-ref p (remainder x (length p)))
)))
Loading...
Soluzione del problema con Scheme implementata da me:
(define shared
(lambda (g h)
(shared_com g h null )
))
(define shared_com
(lambda (u v t)
(cond ((=(length u) 0) t)
((=(length v) 0) t)
((= (car u) (car v)) (append t (list(car u)) (shared_com (cdr u) (cdr v) t)))
((> (car u) (car v)) (shared_com u (cdr v) t))
((< (car u) (car v)) (shared_com (cdr u) v t))
)
))
(shared '(1 3 5 6 7 8 9 10) '(0 1 2 3 4 5 7 9))
Soluzione del problema proposta a lezione
(define shared
(lambda (u v)
(cond ((or (null? u) (null? v)) null)
((< (car u) (car v)) (shared (cdr u) v))
((> (car u) (car v)) (shared u (cdr v)))
(else (cons (car u) (shared (cdr u) (cdr v))))
)))
Loading...
Valori procedurali in scheme:
(define tab-fun ; valore: procedura
(lambda (args vals) ; args, vals: liste di uguale lunghezza
(lambda (n)
(if (= n (car args))
(car vals)
((tab-fun (cdr args) (cdr vals)) n)
))
))
(define f (tab-fun '(0 1 2 3 4 5) '(2 3 5 7 11 13)))
(f 2)
Loading...
Vedi un esempio dell’albero di Steinhaus con Scheme (lisp Language):
(define nxt
(lambda (sq op)
(let ((n (string-length sq)))
(if (= n 1)
""
(string-append
(if (op (string-ref sq 0) (string-ref sq 1))
(string-append (string #\0) (nxt (substring sq 1) op))
(string-append (string #\1) (nxt (substring sq 1) op))
)
)
))))
(define tri
(lambda (sq op)
(if (= (string-length sq) 1)
(list sq)
(cons sq (tri (nxt sq op) op))
)))
(tri "1101" char=? )
Altra soluzione potrebbe essere questa, più complessa da capire, ma più semplice da implementare!
(define nxt
(lambda (sq op)
(let ((n (string-length sq)))
(if (= n 1)
""
(string-append
(op (string-ref sq 0) (string-ref sq 1))
(nxt (substring sq 1) op))
))))
(define tri
(lambda (sq op)
(if (= (string-length sq) 1)
(list sq)
(cons sq (tri (nxt sq op) op))
)))
(tri "1101" (lambda (u v) (if (char=? u v) "0" "1")))
Loading...
Vediamo ora le differenze tra la programmazione in Scheme e Java; partiamo da una funzione semplice semplice che permette il reverse di una stringa (alfanumerica) e la vedremo nei vari linguaggi di programmazione:
1) In Scheme:
(define revi
(lambda (txt)
(if (= (string-length txt) 0)
txt
(string-append (string (string-ref txt (- (string-length txt) 1))) (revi (substring txt 0 (- (string-length txt) 1))))
)
))
Il concetto di base della funzione è la RICORSIONE, cioè richiamo la stessa funzione fino al termine del caso base.
2) Vediamo la stessa ricorsione in Java:
class rev
{
public static String revi (String parola)
{
int k = parola.length();
if (k < 1)
return parola;
else
{
parola = parola.charAt(k-1) + rev.revi (parola.substring (0, k-1));
}
return parola;
}
}
3) Vediamo la stessa funzione in Java con un ciclo:
class ribalta {
public static String ribalto (String testo)
{
int rigth ;
rigth = testo.length();
StringBuffer dest = new StringBuffer(rigth);
for (int index = (rigth -1); index >= 0; index--)
dest.append(testo.charAt(index));
return dest.toString();
}
}