(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)

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)));
 }
}

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))
        )))

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)))
      )))

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))))
          )))

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(); } }