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

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