Il y a essentiellement deux manières pour "deviner" ce que fait un algorithme :

• Repasser mentalement les étapes (ce qu’on peut faire à l’écrit)
• ou "traduire" l’algorithme dans un langage de programmation (ce qu’on peut faire à l’écrit aussi, mais à condition que la calculatrice soit autorisée).

C’est la deuxième méthode qui sera utilisée ici, puisqu’il s’agit d’un TP.

Exploration de l’algorithme

Voir la version algobox en ligne

La traduction directe depuis le pseudocode vers JavaScript donne ceci (à part qu’il a fallu ajouter l’entrée (affectation de $N$) et la sortie (affichage de la valeur finale de $P$) :

var N=Input("Entrer un entier : ");
var P=1;
for(I=1;I<=N;I=I+1){
	P=P*I;
	}
Alert("Avec "+N+", le programme donne "+P);

Ceci dit, il est plus confortable pour la suite d’écrire une fonction (au sens algorithmique du terme) qui sera réutilisable par la suite. Voici la fonction JavaScript [1] :

function algo(n){
	var p=1;
	for(i=1;i<=n;i=i+1){
		p=p*i;
	}
	return(p)
}

Avec ça, c’est facile d’écrire une boucle appelant la fonction algo(n) pour les valeurs consécutives de n :

function algo(n){
	var p=1;
	for(i=1;i<=n;i=i+1){
		p=p*i;
	}
	return(p)
}
for(n=1;n<=20;n=n+1){
	Println("|"+n+"|"+algo(n)+"|");
}

Son exécution sous CaRMetal donne le tableau suivant [2] :

La conjecture sur la nature de la fonction algo(n) est laissée au lecteur [3]

Les suites

On appelle $u$, $v$ et $e$ les termes courants des suites $u_n$, $v_n$ et $e_n$ (ce sont des variables mises à jour dans la boucle sur $n$). Comme $u_n$ est une somme, on effectue une nouvelle boucle sur $k$, dans laquelle on additionne la valeur courante de la somme $u$ et de $\frac{1}{k !}$ (en effet, $u_k=u_{k-1}+\frac{1}{k !}$) :

/*Programme tp 60a
*/
function fact(n){
	var p=1;
	for(i=1;i<=n;i=i+1){
		p=p*i;
	}
	return(p)
}
var u,v,e;
for(n=1;n<=20;n=n+1){
	u=0;
	for(k=0;k<=n;k=k+1){
		u=u+1/fact(k);
		}
	v=u+1/n/fact(n);
	e=v-u;
	Println("|"+n+"|"+u+"|"+v+"|"+e+"|");
}

(On remarque que, par définition de $v_n$, $e_n=\frac{1}{n \cdot n !}$ ce qui rend l’exercice quelque peu circulaire.)

L’exécution du script sous CaRMetal produit le tableau suivant :

Pour mieux voir ce qui se passe, on peut légèrement modifier le script ci-dessus pour, au lieu d’afficher les valeurs numériques de $u$, $v$ et $e$, les représenter par des nuages de points ($u_n$ en bleu, $v_n$ en rouge et $e_n$ en vert) : Le script ci-dessous

/*Programme tp 60b
*/
function fact(n){
	var p=1;
	for(i=1;i<=n;i=i+1){
		p=p*i;
	}
	return(p)
}
var u,v,e;
for(n=1;n<=20;n=n+1){
	u=0;
	for(k=0;k<=n;k=k+1){
		u=u+1/fact(k);
		}
	v=u+1/n/fact(n);
	e=v-u;
	a=Point(n,u);
	SetColor(a,"blue");
	SetPointType(a,"dcross");
	b=Point(n,v);
	SetColor(b,"red");
	SetPointType(b,"cross");
	c=Point(n,e);
	SetColor(c,"green");
	SetPointType(c,"circle");
}

produit l’image suivante :

Il y en assez pour conjecturer la convergence de $e_n$ et l’adjacence de $u_n$ et $v_n$.