La programmazione si compone di tre categorie fondamentali:
- programmazione funzionale (es. Scheme, Lisp)
- programmazione imperativa (es. C/C++, Java, Pascal, etc..)
- programmazione logica (es. ProLog)
Scheme è un linguaggio funzionale (a differenza di Pascal, C/C++, Java che sono imperativi)... tuttavia è grazie alla funzionalità di Scheme che mi è stato più facile imparare il Java... anche se come sintassi sono completamente diversi... ti faccio vedere solo due esempi semplici semplici:
TEMA: Creare un programma, in linguaggi Scheme e Java, che, dati un indice naturale
n, calcoli l'n-esimo numero di Fibonacci.
i numeri di fibonacci sono definiti come fib(n-2) + fib(n-1); esempi:
fib(0) = 0 //convenzione
fib(1) = 1 //convenzione
fib(2) = fib(0) + fib(1) = 0 + 1 = 1
fib(3) = fib(1) + fib(2) = 1 + 1 = 2
fib(4) = fib(2) + fib(3) = 1 + 2 = 3
fib(5) = fib(3) + fib(4) = 2 + 3 = 5
fib(6) = fib(4) + fib(5) = 3 + 5 = 8
...
più in generale: fib(n) = fib(n-2) + fib(n-1)
soluzione del problema
Soluzione SCHEME
Code:
(define (fibn n)
(if (< n 0)
(error "ERRORE! Inserire un valore intero positivo.")
(fibn-alg n '(1 0) 0 1)))
(define (fibn-alg n fib fib1 fib2)
(let ((fibn (+ fib1 fib2)))
(cond ((= n 0) 0)
((= n 1) (car fib))
(else (fibn-alg (- n 1) (cons fibn fib) fib2 fibn)))))
Soluzione JAVA (usando gli array (impropriamente chiamati "vettori"))
Code:
public class Fibn {
public static void main (String[] args) {
if (args.length<1)
System.out.println("ERRORE! Inserire un indice naturale.");
else {
int[] fibarray = new int[3];
int fib1=0, fib2=1, fibn;
int n = Integer.parseInt(args[0]);
if (n >= 1) {
for (int i=2; i<(n+1); i++) {
fibarray[2] = fibn = fib1 + fib2;
fibarray[0] = fib1 = fib2;
fibarray[1] = fib2 = fibn;
}
}
System.out.println(indice (fibarray));
}
}
public static int indice(int[] fibarray) {
int j = 2;
return fibarray[j];
}
}
Soluzione JAVA (usando il ritorno intero)
questo te l'ho anche commentato (se ti può servire per capire meglio)
Code:
public class Fibn {
// Main class
public static void main(String[] args) {
// controllo sul valore n passato in input
if (args.length<1)
System.out.println("ERRORE! Inserire almeno un valore intero positivo.");
else {
// se esiste un n in input, viene prelevato ed assegnato alla variabile n
int n=Integer.parseInt(args[0]);
if (n < 0) {
System.out.println("ERRORE! Il valore deve essere intero positivo.");
} else {
// si passa il valore n alla funzione ausiliaria che itera il risultato
System.out.println(algorithm(n));
}
}
}
// Algoritmo (funzione ausiliaria) per il calcolo dell'ultimo numero della serie
public static long algorithm(int n) {
// dichiarazione e inizializzazione delle variabili
long fib;
long fib1=0, fib2=1, fibn;
// algoritmo in un ciclo for con dichiarazione del contatore i
if (n >= 1) {
for (int i=2; i<(n+1); i++) {
fibn = fib1 + fib2; // calcola l'n-esimo numero della serie
fib1 = fib2; // assegna a fib1 il penultimo numero della serie
fib2 = fibn; // assegna a fib2 l'ultimo numero della serie
}
return fib2; // restituisce l'n-esimo numero della serie
} else {
fib = 0;
return fib;
}
}
}
se hai dubbi o incertezze chiedi pure (magari via pm... che se no qua ci prendono per pazzi... lol)
