Programme A

On suppose que le nombre choisi est 6. Alors on peut écrire

nombreChoisi = nouvelle Variable 6

Ceci a pour effet de créer (« new ») une variable appelée nombreChoisi, et de lui donner pour valeur initiale 6. Pour vérifier ceci, on peut demander à sophus de montrer la variable :

nombreChoisi = nouvelle Variable 6
montrer nombreChoisi

Ce script ouvre une boîte de dialogue qui affiche un 6.

Ceci dit, le programme A demande ensuite de soustraire 0,5 au nombre choisi. Cela revient, en Sophus, à diminuer la variable de 0,5 :

nombreChoisi devient nouvelle Variable 6
diminuer nombreChoisi de 0.5
montrer nombreChoisi

L’affichage donne alors 5,5 [1] puisque, une fois qu’on a enlevé 0,5 à 6, il reste 5,5. Mais ensuite on a un problème, le programme de calcul A demandant de multiplier les 5,5 obtenus par le double du nombre de départ, qu’on n’a plus à disposition puisqu’on l’a modifié. Il aurait donc fallu, au départ, créer une copie de nombreChoisi pour doubler celle-ci, et multiplier le résultat par 5,5. Ceci se fait en créant une variable copie initialisée à 6, puis, à la fin du script, en doublant cette variable, et enfin, en multipliant 5,5 par le résultat obtenu :

nombreChoisi devient nouvelle Variable 6
copie devient nouvelle Variable nombreChoisi.valeur
diminuer nombreChoisi de 0.5
doubler copie
multiplier nombreChoisi par copie
montrer nombreChoisi

L’exécution de ce script dans sophus affiche un 66. Pour essayer avec d’autres valeurs on peut simplement modifier la première ligne du script et relancer celui-ci.

Programme B

Les opérations demandées par le programme B (et effectuées cette fois-ci sur la copie) sont, dans l’ordre :

• élever le nombre au carré ;
• doubler le résultat ;
• diminuer le résultat du nombre choisi au départ (ici, 6) :

nombreChoisi devient nouvelle Variable 6
copie devient nouvelle Variable nombreChoisi.valeur
élever copie au carré
doubler copie
diminuer copie de nombreChoisi
montrer copie

Tiens, on constate que pour le nombre 6 au départ, le programme B donne lui aussi 66 en résultat. Pour vérifier si c’est une coïncidence ou si c’est plus général, on va transformer les programmes A et B en fonctions.

Programmes de calcul et fonctions

L’avantage de programmer A et B comme des fonctions est qu’il n’y a plus à se rappeler le nombre choisi au départ, puisque c’est l’antécédent de la fonction. En plus, pour le nombreChoisi, en prennant un nombre de JavaScript plutôt qu’une variable de Sophus, on évite d’avoir à faire explicitement référence à sa valeur. Le fait que A est une fonction se note par une sorte de flèche :

programmeA = (nombreChoisi) ->
    copie devient nouvelle Variable nombreChoisi
    diminuer copie de 0.5
    doubler copie
    multiplier copie par nombreChoisi
    copie.valeur

montrer programmeA(6)

La dernière expression qui se trouve dans le corps de la fonction (indenté) est la valeur retournée par la fonction. Ici il s’agit de la valeur de la variable copie, qui se note copie.valeur.

Le programme B est aussi une fonction :

programmeB = (nombreChoisi) ->
    copie devient nouvelle Variable nombreChoisi
    élever copie auCarré
    doubler copie
    diminuer copie de nombreChoisi
    copie.valeur

montrer programmeB(6)

Raisonner inductivement avec Sophus

Dans le langage des fonctions, la constatation précédente se note A(6)=B(6). La conjecture suggérée par l’énoncé est que A=B, ce qui reste à vérifier (avant de le prouver !) sur d’autres nombres que 6. Pour cela, on va plus vite si on affiche un tableau de valeurs. En Sophus, pour construire un tableau de valeurs, on peut en initialiser un (à un tableau vide de JavaScript) en y mettant des crochets vides (sans rien entre eux), puis en empilant des images d’entiers (indice) par la fonction, et en affichant le tableau à la fin, lorsqu’on a fini d’y empiler tous ces nombres :

programmeA = (nombreChoisi) ->
    copie devient nouvelle Variable nombreChoisi
    diminuer copie de 0.5
    doubler copie
    multiplier copie par nombreChoisi
    copie.valeur

liste = [ ]
x devient nouvelle Variable 0
7.foisFaire ->
    liste.empiler programmeA(x.valeur)
    incrémenter x

montrer liste

Pour tester ces algorithmes

Copier-coller l’un d’eux ci-dessous :

Interpréteur Sophus

nombreChoisi devient nouvelle Variable 6 copie devient nouvelle Variable nombreChoisi.valeur élever copie au carré doubler copie diminuer copie de nombreChoisi.valeur montrer copie

Lancer cet algorithme

Copier-coller l'algorithme

Sortie en français

On peut également programmer en Sophus hors ligne, à l’aide de cet interpréteur en html (comprend aussi la liste des instructions du langage Sophus) :

|

|