Première méthode : Avec une calculatrice (par exemple la console Python)

On entre, au clavier, la séquence de touches suivantes : 0,+,1,+,2,+,3,+,4,+,5,+,6,+,7,+,8,+,9,+,1,0, etc

Vous je sais pas mais moi je n’ai pas eu la patience d’arriver à 99...

Il arrive fatalement un moment où on se dit que l’ordinateur (ou la calculatrice) doté d’une console Python, devrait pouvoir faire le boulot pénible à la place de l’humain, après tout c’est bien pour ça qu’on l’a inventé (l’ordinateur, pas l’humain, quoique...).

C’est là qu’on se dit que peut-être, avant de se précipiter sur la machine, on pourrait s’arrêter un instant pour réfléchir, en l’occurrence à la manière dont ladite machine peut nous aider. Et c’est là qu’apparaît une première composante de la pensée algorithmique : Se mettre à la place de la machine, voir ce qu’elle peut faire et penser comme elle, autant que faire se peut.

Deuxième méthode : Un algorithme (de programmation impérative séquentielle)

On propose d’utiliser deux variables :

• La variable contenant les nombres entiers à additionner, que l’on propose d’appeler entier ;
• Une autre variable, destinée à contenir, in fine, le total à calculer, et que l’on propose donc d’appeler total

Voici alors le script obtenu (clic droit pour ouvrir dans un autre onglet du navigateur).

L’idée de base est d’initialiser la variable total à 0 puis d’y ajouter, au fur et à mesure, les nombres à additionner. Ce qui, en Python, donne

total = 0
for entier in range(0,100):
	total = total + entier
print(total)

Ah oui c’est vrai, l’usage « normal » de Python sur une calculatrice, c’est la console. Dans ce cas on a un peu plus simple :

total = 0
for entier in range(100):	total = total + entier
total

Ce script répond à la question mais il apparaît deux problèmes :

1. La plupart des élèves, s’ils savent programmer l’algorithme, ne savent pas l’inventer, ni même, souvent, le retrouver de mémoire [1] ;
2. Il est peut-être exagéré de qualifier d’algorithme une méthode ne permettant que de résoudre un problème bien particulier et non toute une classe de problèmes.

Il apparaît donc le besoin de généraliser comme le suggère J. Wing. Avec un bénéfice inattendu :

Troisième méthode : Avec une fonction

À quel moment exactement a-t-on utilisé le fait qu’il y a 100 nombres à moins de 3 chiffres (de 0 à 99) ? Jamais. On peut donc directement modifier le programme précédent pour obtenir des sommes similaires, mais aussi le dire, ou plutôt l’écrire, en Python, sous la forme de définition d’une fonction. Dans un module on écrirait

def S(n):
	total = 0
	for entier in range(n+1):
		total = total + entier
	return total

et on n’aurait plus qu’à écrire, dans la console,

S(99)

pour avoir la réponse à la question.

Avec l’avantage qu’on n’a plus résolu un problème particulier (une « instance » du problème) mais toute une classe de problèmes (une infinité dénombrable, pour être précis). Cela résout la seconde difficulté évoquée ci-dessus, mais pas la première : Pourquoi tant d’élèves de 2^nde éprouvent-ils du mal à inventer cet algorithme de sommation ?

Quatrième méthode : Avec une fonction récursive

Peut-être parce que la méthode de sommation en question est basée sur une récursivité latente ? En effet, la somme des 99 premiers entiers est égale à 99 plus la somme des 98 premiers entiers, laquelle est égale à 98 plus la somme des 97 premiers entiers, etc.

Autrement dit, si dans le programme ci-dessus on a avait rédigé la fonction S de la manière qui suit :

def S(n):
	if n==0:
		return 0
	else:
		return n+S(n-1)

on aurait eu le même affichage dans la console, avec

S(99)

Ceci montre

• qu’il peut y avoir plusieurs manières différentes de calculer la même fonction (ou plusieurs algorithmes différents résolvant un même problème)
• que la récursivité se cache parfois là où on ne l’attend pas
• l’intérêt qu’il y a à généraliser (on est passé de 99 dans la description de l’algorithme récursif, à n dans sa programmation en Python)

t = time()
S(99)
t = time() - t
print(t)

Cinquième méthode : Demander à Python de faire l’addition

La plupart des langages modernes possèdent une fonction somme ou sum qui fait le travail à notre place. Elle s’applique à une liste de nombres.

La fonction S devient alors

def S(n):
    return sum(range(n+1))

Dans le bloc sur l’efficacité des algorithmes, on voit que cette fonction est à peu près aussi rapide que la version itérative : Comme avec Haskell, on peut avoir confiance en le fait que Python fait les choses au mieux et lui déléguer les basses besognes (variables, boucles, ...).

def moyenne(tableau):
    return sum(tableau)/len(tableau)

Sixième méthode : Sans Python

On conjecture que S(n)=n(n+1)/2 et on calcule directement 99×100/2=4950. Reste à voir comment on peut prouver le résultat utilisé (récurrence, dessin, ...)