Lorsqu’on démarre flow974, il y a déjà une fonction, dont on n’a pas besoin pour ce corrigé. On a donc un peu de nettoyage préliminaire à faire (clic droit sur un bloc puis remove node pour l’enlever, pour ne garder qu’un des nombres présents [1]. On en profite pour ajouter un affichage pour connaître le « résultat des programmes » ; du point de vue fonctionnel, il suffit d’utiliser la fonction identité qui ne modifie rien mais affiche sa valeur. On a donc laissé un nombre, et, si on effectue un clic droit sur la partie vide du plan de travail, le menu qui apparaît alors permet, parmi les fonctions, de choisir l’identité :

Une fois que c’est fait, l’identité est en jaune parce qu’elle vient juste d’être sélectionnée, et il reste encore à effectuer un branchement :

Pour cela, on clique sur la sortie du nombre et, sans lâcher le bouton gauche de la souris, on mène celle-ci vers l’entrée de la fonction :

Une fois qu’on est arrivé et que le bouton gauche de la souris a été lâché, le branchement est effectué :

On s’en rend compte parce que la modification du nombre en entrée se répercute immédiatement à la sortie.

Le programme A modélise une fonction, que l’on va noter A(x) par la suite : Il est clair, selon l’énoncé, que le nombre obtenu en sortie dépend du nombre choisi en entrée, et c’est exactement ce que signifie le mot « fonction ».
Pour programmer proprement, on se propose de créer une fonction, ce qui se fait en cliquant quelque part entre l’entrée et la sortie, et en naviguant dans le menu apparu, jusqu’à trouver la fonction générique. Comme c’est une fonction, elle se trouve parmi les fonctions.

Mais elle va se nommer « module » après sa création :

Pour la programmer et la renommer, il suffit alors de cliquer sur le bouton “Edit”, ce qui fait entrer dans la fonction.

Une fonction se doit d’avoir une entrée : clic gauche puis choix de celle-ci dans “fonctions” :

Une fonction se doit aussi d’avoir une sortie :

Comme l’étape suivante est de « soustraire 3 » on insère un module de soustraction. Il est dans les opérations :

C’est à l’entrée qu’on soustrait 3, d’où ce branchement :

Mais que soustraire ? Un nombre !

Et ce nombre est 3 :

Enfin il faut calculer le carré du résultat :

Après les branchements nécessaires, le contenu du module A(x) est le suivant :

Au passage on a renommé le module en haut. Après avoir cliqué sur “Enregistrer le module” on est de retour au plan de travail, et là on peut brancher le nombre choisi à l’entrée de A(x) et la sortie de A(x) à l’identité qui sert d’affichage :

On vérifie en positionnant l’entrée sur 1, que Corinne obtient bien 4 en sortie (à droite de l’écran) :

Pour répondre à la question de Tidjane, il faut créer un nouveau module nommé B(x) et commencer par y placer le module « carré » puisqu’on a besoin du carré du nombre de départ.

Mais on ne trouve pas de module « triple ». Qu’à cela ne tienne, on va en créer un !
On va donc créer une fonction à l’intérieur d’une fonction : On la nomme « triple » et voici son contenu :

En effet le triple d’un nombre, c’est le produit de 3 par ce nombre.

Avec ce module on peut facilement faire le programme B(x) :

Ci-dessus la partie en jaune correspond à l’expression « ajouter le triple du nombre de départ ». Ce module B(x) permet de répondre à la question de Tidjane : Le nombre trouvé est 17.

La formule saisie est =B3^2+3*B3+7

Pour étoffer un peu cette partie, on propose un prolongement : On verra dans la partie 4 que le but final de l’exercice est de savoir pour quel nombre choisi en entrée, les deux programmes A et B donnent le même résultat. Ce n’est pas difficile en flow programming : il suffit de mettre les deux modules A(x) et B(x) sur un même plan de travail, et d’y injecter le même nombre :

Si le nombre x est au moins 1, B(x) est plus grand que A(x) :

Si le nombre x est négatif ou nul, B(x) est plus petit que A(x) :

Comme les nombres ne prennent que des valeurs entières, on n’a ici que la même information donnée par le tableur : La solution de l’équation A(x)=B(x) est quelque part entre 0 et 1. Ceci dit, dans l’exercice, tous les nombres qui interviennent dans les questions 1, 2 et 3 étant entiers, il faut aller jusqu’à la résolution de l’équation dans la question suivante, pour comprendre que dans cet exercice, « nombre » signifie « réel » et pas nécessairement « entier ».

Pour gagner en précision, on peut ajouter un module de division par 10 au nombre d’entrée, et explorer la situation avec une précision accrue :

Le vocabulaire de Sofus n’est pas très similaire à celui de l’énoncé ; notamment

• Quand on soustrait 3, il faut dire à qui on soustrait 3 ;
• Lorsqu’on calcule un carré, il faut dire quel est le nombre à élever au carré ;
• Lorsqu’on finit un calcul, il faut dire quoi faire du résultat : L’afficher !
• Et il faut savoir que si le nombre de départ s’appelle « x », son triple s’écrit « 3×x »

Mais on s’y fait vite. Avec l’aide de Sofus, Zoé

• prouve que le programme A donne bien x²-6x+9 :

• trouve que le programme B donne x²+3x+7 :

• résout l’équation x²-6x+9=x²+3x+7 :

Comme Python est de plus en plus un langage de programmation fonctionnelle, voici, à titre de comparaison avec les flow-programmes ci-dessus, les fonctions A et B programmées en Python :

def A(x):
    x -= 3
    x **= 2
    return x

def B(x):
    def triple(nombre):
   	    return 3*nombre
    y = x**2
    y += triple(x)
    y += 7
    return y

Dans Sofus, la tortue numéro 1 peut connaître à quelle distance se trouve la tortue numéro 0. On commence donc par créer la tortue 0, qui restera à l’origine ; puis on cache les deux tortues :

On remarque que le script de l’énoncé ne comprend aucun affichage de la variable score et qu’il est fait allusion aux « lignes 5, 6 et 7 du programme » donc à de la programmation textuelle.

En reprogrammant le script avec SofusPy, on obtient ce genre de blocs :

Pas très différents de ceux de l’énoncé. Mais SofusPy donne automatiquement la version Python, laquelle (après quelques retouches comme remplacer les « 0 » par des pointillés) ressemble à ceci :

Et là, on a bien des lignes de programme et pas des blocs à compter...

Une petite variante du programme simplifié permet de dessiner en rouge les points à l’intérieur du disque et en bleu les autres :

On obtient alors ce genre de nuage de points :

La variable score possède alors une signification : C’est le nombre de points rouges dans le nuage.

Avec SofusPy, les couleurs n’étant pas encore implémentées, on peut faire le choix de ne dessiner le point que lorsque la variable score est incrémentée et affichée sa valeur à la fin du script. Celui-ci peut être copié-collé vers SofusPy :

from turtle import * ; from math import *; from random import *
score = 0; reset()
for _ in range(120):
    setposition(randint(-100, 100), randint(-100, 100))
    Carre_de_OF = xcor()**2 + ycor()**2
    distance = sqrt(Carre_de_OF)
    if distance < 100:
        score = score + 1
        dot(10)
setposition(120,0)
write(score)

Il produit ce genre de dessin où on devine, en pointillés, le disque de rayon 100 (la tortue est à droite, en forme de chevron) :

La question 1 porte sur un programme de calcul avec répétition, puisque seule la valeur de la variable côté est considérée. On peut donc ne laisser que les transformations de celle-ci :

La question a porte sur une affectation (initialisation) et la réponse est donc 40, à lire dans le script ; la question b trouve sa réponse dans l’affichage du script ci-dessus :

60
80
100
120

Le réglage de l’épaisseur du stylo est une fonction experte de Scratch, on peut donc s’étonner de sa présence alors même que « l’enseignement de l’informatique au cycle 4 n’a pas pour objectif de former des élèves experts, ni de leur fournir une connaissance exhaustive d’un langage ou d’un logiciel particulier ».

Ceci dit, le seul endroit dans la boucle où il ne faut pas mettre le bloc d’augmentation de l’épaisseur du crayon, est avant le bloc carré.

La programmation fonctionnelle n’est pour autant pas totalement absente de ce sujet puisque, même si la variable côté est globale, elle est argument de la fonction avancer et l’avant-dernier bloc du nouveau script est traduit en Python (voir ci-dessous) par avancer de (côté + 30). La notation parenthésée montre que avancer de est une fonction, et que son argument n’est plus la valeur actuelle de la variable côté mais la somme côté+30.

Le nouveau script

donne ceci

soit le dessin 3. Le dessin 2 est à écarter parce qu’il n’y a pas les levers de stylo, et le dessin 1 pour une raison plus subtile : Après avoir dessiné un carré, la tortue a tourné en tout de 360° et est donc à nouveau sur l’axe des abscisses, ce qui est incompatible avec le dessin 1.

from turtle import * 
def carre():
    global cote
    pendown()
    for _ in range(4):
        forward(cote)
        left(90)
    penup()


reset()

setposition(-200, 0)
cote = 40
for _ in range(4):
    carre()
    forward(cote + 30)
    cote = cote + 20

Le pseudocode de la procédure principale est

téléporter la tortue vers (-200, 0)
côté ← 40
pour _ allant de 0 à 3
    carre( )
    avancer de (côté + 30)
    côté ← côté + 20

fin du pour

Un moyen simple d’avoir un triangle isocèle par script est de donner des coordonnées aux sommets d’icelui :

a = Point("A",0,1);
b = Point("B",0,-1);
c = Point("C",-3,0);
Polygone("motif1","A,B,C");

Mais pour être complet il faudrait fixer les sommets A, B et C, sinon, sous l’effet du Monkey, le triangle ne restera pas isocèle (l’effet est néanmoins intéressant).

La transformation est la symétrie d’axe (AB), mais une translation aurait aussi pu faire l’affaire :

d = SymétrieAxiale("D",Droite("l1","A","B"),"C");
Cacher("l1");
Polygone("motif2","A,B,D");

La première ligne signifie simplement que D est le symétrique de C par rapport à la droite (AB), mais au passage cette droite a été nommée l1 pour pouvoir, à la ligne 2, la cacher.

Voici le script engendrant la frise, on peut aisément y lire le vecteur de la translation, même si on ne connaît pas par cœur la syntaxe des CaRSCripts :

répéter 4 fois {
	a = Translation("C","B",a);
	b = Translation("C","B",b);
	c = Translation("C","B",c);
	d = Translation("C","B",d);
	Polygone("_a,_b,_c");
	Polygone("_a,_b,_d");
}

On voit que le script a bien engendré la frise de l’énoncé :

En mettant CaRMetal en mode pseudo-code, les effets des translations successives se voient mieux :

répéter 4 fois {
   a ⟵ Translation("C","B",a);
   b ⟵ Translation("C","B",b);
   c ⟵ Translation("C","B",c);
   d ⟵ Translation("C","B",d);
}

Pour aller plus loin, on peut aussi utiliser SymPy (calcul formel sous Python), qui possède une variable n de type formel, laquelle peut être utilisée comme valeur initiale du nombre, et l’affichage final de cette variable donne bien 2n+1 :

Le jour où un maraîcher voudra programmer un robot pour désherber ses tomates, il est peu probable qu’il le programme en Scratch. Python ayant plus le vent en cote, voici le script produit par SofusPy à partir des blocs ci-dessus :

from turtle import * 
def Motif_montant():
    forward(80)
    right(90)
    forward(1)
    right(90)

def Motif_descendant():
    forward(80)
    left(90)
    forward(1)
    left(90)

for count in range(24):
    Motif_montant()
    Motif_descendant()
forward(64)

Le programme est celui-ci :

On devine que c’est à la nouvelle valeur du nombre qu’on doit ajouter 8 ; encore un implicite...

Traduit en Sofus, le programme donne ceci (version question 1) :

Du coup le nombre n’est plus un nombre mais une variable. Ce qui est normal puisqu’il varie...

Pour résoudre la question 2, on décide, comme dans la suite du sujet, de nommer « x » le nombre choisi au départ :

On apprend au passage que le programme implémente une fonction affine, à savoir 8x+16. Ce résultat sera utile par la suite.

Pour résoudre l’équation, on écrit celle-ci en ajoutant « =30 » à l’expression obtenue, puis en résolvant l’équation obtenue :

En développant 2(4x+8) on retrouve bien 8x+16 vus à la question précédente. Il reste alors à entrer B :

puis le développer :

• Il y a un gros manque dans l’énoncé à ce stade : Il n’est pas précisé dans quel ensemble on a choisi le nombre de départ. Si on cherche quand le résultat est nul, on constate que la proposition est vraie si l’ensemble ne contient aucun nombre inférieur à -2 :

La réponse est donc oui si le nombre de départ est entier naturel,non s’il est entier relatif, ou réel. On dit que N est un modèle de la proposition, alors que R n’en est pas un. Ce qui manquait à cet énoncé c’est donc la précision sur le modèle dans lequel on travaillait.

• Là encore, on ignore, àla seule lecture de l’énoncé, si l’entier est naturel ou relatif. À moins que la divisibilité des entiers relatifs soit au programme de collège, on supposera donc que le nombre est naturel. Auquel cas la division par 8 donne encore un entier naturel ce qui conclut favorablement à la question :

Puisqu’Alice a choisi la valeur 3, autant initialiser le Nombre à la valeur 3 :

Comme la variable Résultat1 dépend de la valeur initiale de Nombre, le programme de calcul représente de fait une fonction numérique (antécédent : Nombre, image : Résultat1) et l’image de 3 par cette fonction est 81.

Pour Résultat2, il en est de même :

La fonction évoquée ci-dessus est du second degré :

Il s’agit de la fonction 4x²+12x+9 comme on peut d’ailleurs le retrouver en développant et réduisant (2x+3)².

De fait, le Résultat2 dépend du Nombre par la même fonction du second degré :

Il suffit, au lieu d’afficher l’équation, d’afficher ses solutions :

Il semble, à vue de nez, que les deux solutions pourraient s’écrire plus simplement, en utilisant le fait que sqrt(144)=12. Les termes complexes sont donc respectivement 12/8=3/2 et son opposé. Les deux solutions sont donc -3/2-3/2=-3 et -3/2+3/2=0. Mais si le calcul formel de Sofus laisse un peu à désirer sur les équations du second degré, on peut retrouver plus facilement ces solutions, en constatant que dans l’équation, le terme +9 est présent dans les deux membres, et en choisissant de s’en passer, en enlevant le bloc « augmenter Résultat2 de 9 ». Cela aboutit à l’équation 4x²+12x=0 dont on aperçoit immédiatement que 0 est une solution. Alors on simplifie encore l’équation en divisant par x la valeur de Résultat2 ce qui donne la seconde solution :

Avec des noms de variables plus parlants le script devient plus compréhensible :

Ceci dit, la question était justement de deviner le rôle joué par la variable x dans le script de l’énoncé.

Lorsque l’on exécute le programme, quelles sont les coordonnées du point d’arrivée et dans quelle direction est-on orienté ?

On constate une prise de distance par rapport au chat qui est devenu « on » et peut donc très bien être une tortue. C’est le choix qui est fait ici puisqu’on utilise Sofus avec sa concision accrue par rapport à Scratch.

L’orientation de la tortue est la même qu’au départ :

Quand à ses coordonnées, elles aussi sont redevenues celles du départ, comme on le voit si on dessine un repère :

Pour faire varier les variables, on utilise (dans l’énoncé) des expressions algébriques (produits) et des affectations :

Par exemple, pour augmenter la valeur de la longueur,

• on lit sa valeur actuelle longueur
• on calcule le produit de cette valeur par 1,3 (longueur×1,3)
• on remplace le contenu de longueur par le produit effectué.

En terminale voire après, cette suite d’opérations est compliquée. Il est intéressant de comparer avec la version Sofus :

De fait, c’est probablement parce que Scratch n’a pas d’équivalent de « multiplier par » que la version avec expressions algébriques a été choisie dans l’énoncé, à en juger par le choix fréquent de « augmenter de » dans d’autres sujets : On fait au mieux avec ce qu’on a, et les affectations par expressions algébriques ne sont pas forcément ce qu’ily a de mieux.

Sofus permet même de donner un aspect statistique à l’homothétie :

Dans flow974, il faut un nombre (celui que l’on choisit, que l’on positionnera à 1 selon la consigne), un « module » implémentant la fonction B, et un affichage (en l’occurrence une fonction identité qui affiche son entrée). Une fois le nombre créé (à gauche ci-dessous) on a cliqué sur « fonction » pour voir apparaître le module lequel s’appelle, pour l’instant, « module » :

En cliquant sur « edit » on peut renommer le module (B, pour des raisons qui apparaitront plus bas) et mettre dedans, une entrée (« x » par cohérence avec la suite de l’exercice) et une sortie. Mais le premier bloc dont on a besoin est le triple de x, et du coup il faut à nouveau, à l’intérieur de B, créer un module qui s’appellera triple. Son entrée est nommée nombre et sa sortie triple [3]. Comme le triple du nombre est son produit par 3, on ajoute le nombre 3 et un multiplicateur :

En enregistrant ce module, on aperçoit ceci :

Comme on aura aussi besoin, plus tard, de doubler le nombre, on répète les opérations ci-dessus, avec la multiplication pa 2 cette fois-ci :

Une fois enregistré ce nouveau module, on complète avec les additions et soustractions nécessaires et la sortie :

Enfin, on enregistre le module B et il suffit de modifier la valeur de x pour lire celle du nombre envoyé en sortie :

La programmation du programme de calcul avec Sofus permet aussi de vérifier que, si le nombre choisi est 1, on récupère -15 en sortie :

Mais si, au lieu de 1, on laisse « x », on a l’expression formelle du nombre de sortie, en fonction de x :

Comme le développement de l’expression B donne le même résultat que le programme de calcul, on a la réponse à la question 2 :

Et même, de façon similaire, la réponse à la question 3 :