--------------------------------------- x + 0 = x x + succ(y) = succ(x + y) --------------------------------------- fatt(0) = 1 fatt(n) = n * fatt(n - 1) --------------------------------------- 7 + 3 = 7 + succ(2) = succ(7 + 2) = succ(7 + succ(1)) = succ(succ(7 + 1)) = succ(succ(7 + succ(0))) = succ(succ(succ(7 + 0))) = succ(succ(succ(7))) = = succ(succ(8)) = succ(9) = 10 --------------------------------------- fatt(4) = 4 * fatt(3) = 4 * 3 * fatt(2) = 4 * 3 * 2 * fatt(1) = 4 * 3 * 2 * 1 * fatt(0) = 4 * 3 * 2 * 1 * 1 = 24 --------------------------------------- x + 0 = x x + y = pred(succ(x) + y) --------------------------------------- 5 + 4 = pred(succ(5) + 4) = pred(6 + 4) = pred(pred(succ(6) + 4)) = pred(pred(7 + 4)) = pred(pred(pred(succ(7) + 4))) = ... --------------------------------------- F(0) = 1 F(1) = 1 F(n) = F(n - 1) + F(n - 2) --------------------------------------- F(7) = F(6) + F(5) = F(5) + F(4) + F(5) = Basta calcolare F(5) e F(4): F(4) = F(3) + F(2) F(5) = F(4) + F(3) Basta calcolare F(3) e F(2): F(2) = F(1) + F(0) = 1 + 1 = 2 F(3) = F(2) + F(1) = 2 + 1 = 3 Quindi: F(4) = 3 + 2 = 5 F(5) = 5 + 3 = 8 Quindi: ecc. ecc. --------------------------------------- static int fatt(int n) { if (n == 0) return 1; else return n * fatt(n - 1); } --------------------------------------- static int F(int n) { if (n == 0 || n == 1) return 1; else return (F(n - 1) + F(n - 2)); } --------------------------------------- class Fattoriale { static int fatt(int n) { if (n == 0) return 1; else return n * fatt(n - 1); } public static void main (String[] args) { int x = 5; System.out.println(fatt(x)); } } --------------------------------------- pari(n) = dispari(n - 1) dispari(n) = pari(n - 1) --------------------------------------- pari(0) = true pari(n) = dispari(n - 1) dispari(n) = pari(n - 1) --------------------------------------- pari(4) = dispari(3) = pari(2) = dispari(1) = pari(0) = true; dispari(5) = pari(4) = ... = pari(0) = true --------------------------------------- pari(5) = dispari(4) = pari(1) = dispari(0) = pari(-1) = ...? --------------------------------------- dispari(0) = false --------------------------------------- boolean pari(int n) { if (n == 0) return true; else return dispari(n - 1); } boolean dispari(int n) { if (n == 0) return false; else return pari(n - 1); } --------------------------------------- import java.io.*; /*Ricerca binaria ricorsiva. Assume che l'array a sia ordinato*/ class RicercaBinariaRicorsiva { static int ricerca (char[] a, char e, int low, int up) { int m; m = (up + low) / 2; if (up < low) return -1; else if (a[m] == e) return m; else if (a[m] < e) return ricerca(a, e, m + 1, up); else //a[m] > e return ricerca(a, e, low, m - 1); } public static void main (String[] args) throws IOException { char x; char[] a = {'a', 'b', 'c', 'd', 'f', 'g', 'h', 'i', 'j', 'k'}; int pos; for (int i = 0; i < a.length; i++) System.out.print(a[i]); System.out.print("\nInserisci l'elemento da trovare: "); x = (char) System.in.read(); pos = ricerca(a, x, 0, a.length - 1); if (pos == -1) System.out.println(x + " non trovato"); else System.out.println(x + " trovato in posizione " + pos); } } --------------------------------------- for (int i = 0; i < N - 1; i++) for (int j = i; j < N; j++) if (a[i] > a[j]) { temp = a[i]; a[i] = a[j]; a[j] = temp; } --------------------------------------- import java.io.*; class OrdinamentoFusione { /** "Fonde" due parti dell'array a, da l a m e da m + 1 a u */ static void fondi (char[] a, int l, int m, int u) { char[] b = new char[u - l + 1]; int i = l, j = m + 1, k = 0; while (i <= m && j <= u) if (a[i] <= a[j]) b[k++] = a[i++]; else b[k++] = a[j++]; while (i <= m) b[k++] = a[i++]; while (j <= u) b[k++] = a[j++]; for (k = 0; k <= u - l; k++) a[k + l] = b[k]; } /** Ordina l'array a dalla locazione l alla locazione u */ static void ordina(char[] a, int l, int u) { int m; if (l != u) { m = (l + u) / 2; ordina(a,l,m); ordina(a,m + 1, u); fondi(a,l,m,u); } } public static void main (String[] args) throws IOException { final int N = 16; char temp, v[] = new char[N]; for (int i = 0; i < N; i++) v[i] = (char) System.in.read(); ordina(v, 0, N - 1); System.out.println("Vettore ordinato:"); for (int i = 0; i < N; i++) System.out.print(v[i]); System.out.println(); } } --------------------------------------- import java.io.*; class Euclide { static int mcd (int x, int y) { if (x == y) return x; else if (x > y) return mcd(x-y,y); else // x< y return mcd(x,y-x); } static void main (String[] args) throws IOException { System.out.println(mcd(1717,34)); } } --------------------------------------- static boolean palindroma (char[] s, int l, int u) { if (l >= u) return true; else return ((s[l] == s[u]) && palindroma(s, l + 1, u - 1)); }