Et encore, la version Scratch devait être précédée de la liste des variables :

Oui, la première variable s’appelle bien « étape 1 » et pas « variable 1 » : Au brevet, les étapes ne sont plus des instants, mais des nombres ! En fait, pour justifier que le nombre final est 20 lorsque le nombre initial est 5, on devrait rédiger quelque chose comme :

• au départ le nombre est égal à 5 (par hypothèse) ;
• à l’étape suivante (après l’avoir sextuplé), le nombre est devenu égal à 30 ;
• à la seconde étape (après augmentation de 10), le nombre a encore changé et est devenu égal à 40 ;
• enfin, à la dernière étape (après division par 2), le nombre (qui ne cesse de varier, c’est pour ça qu’on l’appelle une variable), est finalement égal à 20, cqfd.

Le problème avec les variables, c’est qu’elle varient. On ne peut donc parler de la valeur de la variable, que si on précise à quel instant on veut connaître la valeur. Ce qui, conceptuellement, est difficile à suivre [1], surtout avec des langages de programmation ne possédant pas de mots comme « sextupler », permettant de faire les transformations in situ. Alors la solution trouvée dans ce sujet, consiste à n’utiliser aucune variable mais que des constantes. Et à donner à chaque constante le nom qui évoque à quel moment on l’a affectée histoire de s’y retrouver dans tout ça [2].

Mmmmh et quand on veut programmer des boucles, on fait comment avec cette méthode ? Et pourquoi le programme (qui était autrefois dit « de calcul ») ne donne pas de nombre, mais se borne à dire des messages ? Quoiqu’il en soit, la partie sur le calcul formel ressemble à une démonstration, si on la rédige ainsi :

• au départ le nombre choisi est égal à x ;
• donc étape 1 = 6x ;
• donc étape 2 = 6x+10 ;
• donc le résultat est la moitié de 6x+10, soit 3x+5.

On se rapproche d’un raisonnement logique, mais le nom des variables constantes comportant des espaces, les égalités laissent croire que 1=6x ce qui n’est pas nécessairement le cas...

En redéfinissant le programme de Julie comme une fonction, on peut l’exporter vers Xcas ; on a ceci :

function Julie(nombre) {

  nombre := nombre * 6;
  nombre := nombre + 10;
  nombre := nombre / 2;
  return nombre;
}:;

Mais depuis la version 2.0 de Sofus on peut, dans le programme ci-dessus, entrer « x » à la place de 7 :

L’affichage final permet de voir que le programme de calcul est affine.

Comme les élèves du collège de Pondichery n’ont pas encore droit à Sofus pendant l’épreuve, ils doivent, soit faire les calculs à la main (faire le 3 avant le 2), soit savoir qu’on doit « remonter les calculs à l’envers » s’ils veulent faire le 2 d’abord. C’est ainsi qu’on résout l’équation :

• on part de la fin : (6x+10)/2=8 ;
• on multiplie les deux membres par 2 : 6x+10=8×2=16 ;
• on soustrait 10 aux deux membres de la nouvelle équation : 6x=16-10=6 ;
• on divise les deux membres par 6 : x=1.

Voici le script Sofus :

En collant (« ajouter ») à l’expression 3x+5, le texte « =8 », on construit une équation : 3x+5=8, dont les solutions (en fait il n’y en a qu’une) peuvent être calculées et affichées avec Sofus.

L’approche ci-dessus qui est celle d’Al Khwarizmi, permet d’évaluer la compétence « résolution des équations » ; mais comme « Comprendre et utiliser la notion de fonction »
constitue un attendu de fin de cycle, on peut préférer l’approche transformationelle ci-dessous, qui lui est, dans ce cas, équivalente [3] :

En calcul formel, cette remontée des calculs s’exprime ainsi, par des substitutions :

Pour la dernière question, on peut programmer le nombre de Julie et celui de Maxime comme deux fonctions, et les exporter vers Xcas :

function Julie(nombre) {

  nombre := nombre * 6;
  nombre := nombre + 10;
  nombre := nombre / 2;
  return nombre;
}:;

function Maxime(nombre) {
  nombre := nombre + 2;
  nombre := nombre * 5;
  return nombre;
}:;

Mais le calcul formel de Sofus est suffisant pour trouver l’unique nombre donnant la même réponse avec les deux programmes :

Dans un premier temps, on peut envisager de raccourcir les noms des variables constantes, selon le dictionnaire suivant :

Du coup, le script se traduit (sans les affichages) ainsi :

Et ça y est, on a une feuille de tableur ! Celle-ci peut servir de support de preuve, et des questions sur les formules à écrire dans un tableur, ont déjà été posées au brevet des collèges, même si ce n’a pas jusqu’à présent été pour des programmes de calcul. D’ailleurs, l’onglet « Blockly/Xcas » de mathem@algo permet un export automatique depuis le programme Sofus, vers le tableur Xcas.

On peut même faciliter l’entrée des données à l’aide des curseurs :

Voici la version Python du programme de Julie, faisant appel à l’affiche « formaté » de Python. Pour conserver la concision de ce langage, on fait tout sur une seule variable n :

n = float(input('Choisis un nombre : '))
print('Je multiplie le nombre {0} par 6.'.format(n))
n *= 6
print("J'ajoute 10 à {0}".format(n))
n += 10
print('Je divise {0} par 2'.format(n))
n /= 2
print("J'obtiens finalement {0}.".format(n))

Le sujet parle bien de programme, mais ce n’est pas un programme de calcul, mais un programme de construction :

Avec un logiciel de géométrie, on exécute le programme ci-dessous.

Le programme de construction :

• Construire un carré ABCD ;
• Tracer le cercle de centre A et de rayon [AC] ;
• Placer le point E à l’intersection du cercle et de la demi-droite [AB) ;
• Construire un carré DEFG.

La traduction en CaRScript :

a = Point("A",0,0);
b = Point("B",3,0);
[n,d,c] = ExécuterMacro("Polygones/Quadrilatères/Carré","_a,_b");
z = Circle(a,c);
l = Ray(a,b);
[e,n] = Intersections(z,l).split(",");
[n,g,f] = ExécuterMacro("Polygones/Quadrilatères/Carré","_d,_e");

Chaque fois qu’une variable anonyme a été nécessaire, on l’a nommée n puisqu’on ne s’en sert plus par la suite. L’avant-dernière ligne s’explique par le fait que du point de vue des intersections, la demi-droite (« Ray ») est considérée comme une droite, et son intersection avec le cercle est donc formée de deux points (dont l’un est invisible). L’instruction Intersections renvoie une liste de noms de points, et split transforme cette liste en un tableau JavaScript [4], dont le premier élément est le point E qu’on utilise dans la suite de la construction.

Voici la figure CaRMetal obtenue :

Et, avec une longueur de 3 unités, le dessin obtenu :

Pour la démonstration du fait que l’aire du carré DEFG est le triple de celle du carré ABCD, on calcule le côté DE à l’aide du théorème de Pythagore dans le triangle AED :

• AD est une donnée : Le côté a du carré ABCD (dans le problème, 10) ;
• La distance AC se calcule par le théorème de Pythagore dans le triangle ABC (on trouve a√2, soit dans le problème, √200)
• Le côté DE se calcule alors avec le théorème de Pythagore dans AED, dont les côtés de l’angle droit mesurent a et a√2 : On trouve a√3 (dans le problème, √300, ce qui donne bien une aire de 300).

On peut d’ailleurs en faire un exercice de géométrie repérée :

Du coup, pour la dernière question, on sait que l’aire de ABCD doit être le tiers de 48 cm², soit 16 cm², et donc AB=4 cm.

Voici les réactions du chat de Scratch 1.4 aux appuis de flèches :

La différence avec la version 2.0 qui est dans l’énoncé est que la version 1.4 ne permet pas de définir ses blocs, aussi a-t-on dû faire appel au broadcast.

Aucune des deux flèches horizontales ne modifie y qui reste constante. Mais l’appui sur la flèche droite va augmenter x de 80 (c’est ce que dit le script) alors que l’appui sur la flèche gauche va augmenter x de -40 ce qui revient à diminuer x de 40 [5]. Le résultat est une augmentation de x de 40 unités. Dans le détail :

• au départ x=-120 (d’après l’énoncé) ;
• après l’augmentation de 80 on a x=-40 ;
• après la diminution de 40 on a x=-80.

La position finale du chat est donc (-80 ;-80) et ce n’est pas la position de départ.

Pour les questions suivantes on propose un script Sofus (à utiliser sur le site Sofus). Cette fois-ci, le chat s’est transformé en tortue, c’est la magie de l’informatique :

Tout d’abord, il y a une information manquante dans l’énoncé : On suppose, bien que ce ne soit pas écrit, que le chat est revenu à son point de départ, et n’est pas resté en (-80 ;-80), avant l’appui sur ces nouvelles flèches.

On peut rédiger les étapes dans un tableau :

Mais un dessin devrait, au brevet des collèges, constituer une preuve acceptable , pour ce genre d’exercice.

Le déplacement 1 :

fait sortir le chat de l’écran, il n’atteint pas la balle même en cours de chemin.

Le déplacement 2 :

atteint le but, comme le montre le trajet :

Le déplacement 3 :

donne ce trajet :

Il rate donc la balle, de relativement peu, mais il la rate.

Là on est clairement en programmation événementielle :

Que se passe-t-il quand le chat atteint la balle ?

Aucun des blocs de l’énoncé ne commence par « quand le chat atteint la balle ».Mais le dernier script (qui se déclenche à l’appui de n’importe quelle touche) comporte un test « si Balle touché » et le candidat doit comprendre que c’est là qu’on trouve la réponse à la question : Le chat dit « je t’ai attrapé » pendant 2 secondes, puis retourne au départ.

Cette dernière question est probablement destinée à favoriser ceux qui ont de la pratique de programmation en Scratch, et qui savent que « pendant 2 secondes » relègue l’instruction suivante à la fin des 2 secondes...

Pour en savoir plus sur cette question, voir cette réaction sur le calcul parallèle de Scratch.

Pour connaître la position finale du lutin de la tortue, il suffit de l’afficher par un print (Le « u » devant le mot signifie qu’il est écrit en unicode, que Python3 reconnaît) :

from turtle import * 
def depart():
	reset()
	penup()
	setposition(160,120)
	pendown()
	circle(5)
	penup()
	setposition(-120, -80)
	pendown()


def haut():
	left(90)
	forward(80)
	right(90)

def bas():
	left(90)
	backward(40)
	right(90)

def gauche():
	backward(40)

def droite():
	forward(80)

jouer = {u'←': gauche,	u'→': droite, u'↑': haut, u'↓': bas}


mot = u'→→↑←↓'

depart()
for m in mot:
	jouer[m]()
print(position())

Pour tester les trois parcours de l’énoncé, il suffit d’écrire ces mots :

mot = u'→'*7+u'↑'*5
mot = u'→'*3+u'↑'*3+u'→↓←'
mot = u'↑→'*3+u'→↓↓'

Pour la dernière question, ce script devrait fonctionner :

depart()
for m in mot:
	jouer[m]()
if position()==(160.0,120.0):
	print("Je t'ai attrapé")

Mais il ne le fait pas, probablement parce que des nombres très proches à la précision de la machine près, ne sont pas réellement égaux, bien qu’ils en aient l’air...

Les toits simples peuvent être dessinés (avec affichage des coordonnées) à l’aide de ce script :

from turtle import * 
import math

def maison():
	left(90)
	forward(50)
	right(45)
	forward(50)
	right(90)
	forward(50)
	right(45)
	forward(50)
	left(90)


reset()
penup()
setposition(-130, 0)
pendown()
for count in range(5):
	write(round(xcor()))
	maison()
	forward(20)

Et la version avec cheminées :

def maison():
	left(90)
	forward(50)
	right(60)
	forward(24)
	left(60)
	forward(13)
	right(90)
	forward((5 * math.sqrt(3)))
	right(90)
	forward(8)
	left(120)
	forward(16)
	right(60)
	forward(50)
	right(60)
	forward(50)
	left(90)

Voici le programme de Salomé en Scratch 1.4 :

On retrouve la difficulté découverte à Pondichéry : Il est nécessaire pour ne pas compliquer le script à l’excès, de résumer le programme de calcul en une expression algébrique et de faire une affectation avec le résultat (celle-ci est ici cachée dans le test). En fait, une fois ce pas effectué, on pouvait raccourcir encore le script de Salomé :

Pour tester ce script, à fin de comparaison, voici la version Sofus : Si Salomé entre 12, elle aura ceci :

puis « Bravo » :

Mais puisqu’on a quitté le monde des variations de variables, pour celui des affectations par expressions algébriques, autant les écrire d’un coup et les faire évaluer (ici, en entrant -5, on a bien le « essaye encore » auquel on s’attendait) :

En bref, ce genre de programme est peut-être plus à programmer en Python qu’en Scratch :

x = input("Choisir un nombre")
if -4*x+5<0:
    print("Bravo")
else:
    print("Essaye encore")

L’énoncé précisait bien que le programme de calcul est décrit par l’expression littérale -4x+5, il était donc prévu que le changement de cadre ne soit pas vécu comme évident par tous les élèves. D’ailleurs la suite est une résolution d’inéquation, a priori sans grand rapport avec les questions précédentes.

La difficulté était qu’il faut bien trouver que x doit être supérieur à 1,25. La question vise donc bien à évaluer la résolution d’inéquations. Mais cette question est l’occasion de montrer comment on peut, par la programmation évènementielle, améliorer grandement l’« expérience utilisateur » du programme : Comment faire pour que l’utilisateur n’aie pas à entrer des tas de nombres jusqu’à l’affichage de « Bravo » ?

Par habitude, on a fait ici le choix de CaRMetal, mais les techniques utilisées ici sont typiques des logiciels de géométrie dynamique en général :

• On commence par créer un point M attaché à l’axe des abscisses : C’est lui qui servira à entrer le nombre, par simple déplacement à la souris.
• On crée une expression E1, dont la valeur est égale à l’abscisse de M : x(M) :

• On ajoute une seconde expression E2, obtenue en multipliant E1 par -4 :

• Puis une troisième expression E3, obtenue en ajoutant 5 à E2 :

• Ensuite, on colorie M en rouge quand E3 est négative et uniquement dans ce cas :

• Enfin on active la trace de M et en bougeant ce point, on aperçoit, en rouge, la demi-droite constituée des solutions de l’inéquation :

Voici le fichier obtenu :

Il est à noter que, les lutins de Scratch étant déplaçables à la souris, cette technique est tout-à-fait possible avec Scratch, et entre tout-à-fait dans le programme sur la programmation évènementielle, avec un petit plus : C’est comme distance ou comme abscisse qu’on entre un nombre.

Le programme de calcul est assez simple :

x = float(input('Choisir un nombre '))
x *= -4
x += 5
print(x)

Il a fallu une conversion de type, « input » entrant par défaut du texte, ce texte a été converti en « float » (nombre) pour pouvoir effectuer des calculs dessus.

Le programme de Salomé aussi est assez simple :

x = 1
while -4*x+5 >= 0:
	x = float(input('Choisir un nombre '))

On remarque que le script était encore raccourcissable en définissant au préalable une fonction « rectangle » ayant les paramètres L et l en entrée [6]. C’est ce qui avait été fait dans le sujet zéro, mais pas ici.

Pourtant l’énoncé demandait aussi ce qui change si on remplace les deux gros blocs par

On obtient alors ceci :

Voici comment la tortue de Python peut simuler le drone :

from turtle import * 

reset()
penup()
setposition(-200, -100)
pendown()
longueur = 0
largeur = 0
while not (longueur >= 400 or largeur >= 200):
	longueur = longueur + 80
	largeur = largeur + 40
	for count in range(2):
		forward(longueur)
		left(90)
		forward(largeur)
		left(90)

Et pour la dernière question, on change juste le début de la boucle :

while not (longueur >= 400 or largeur >= 200):
	longueur = longueur + 40
	largeur = largeur + 20
        (...)

Le mot ayant permis le tracé comprenant une lettre (mise en exergue par Blockly) qui n’a pas été programmée par Margot, est donc celui qui n’a pas pu être tracé avec le programme de Margot. Mais cela ne constitue pas une preuve, en effet il y a d’autres manières de tracer ce dessin, comme celle-là, faisant également appel à un mouvement vers la gauche :

En fait, les mots 1 et 3 prouvent le résultat souhaité par élimination, il s’agit là de preuves constructivistes. Cette preuve fait appel à toutes les données de l’énoncé, y compris celle selon laquelle un seul des 3 dessins ne peut être fait par le programme de Margot. Sinon il faut constater que le tracé comprend un carré et qu’il n’est pas possible de tracer un carré en n’allant jamais vers la gauche (parce qu’aucun des trois mouvements ne fait baisser l’abscisse par exemple).

La seule modification que Julie a apportée au programme de Margot est que les mouvements vers la droite se font sans tracé. Ce qui produit alors le dessin suivant :

L’usage d’unicode, permis par Python3, incite à écrire la suite de déplacements directement dans le script, sous la forme d’un mot :

from turtle import * 
def initialisation():
	reset()
	penup()
	setposition(-240, 0)
	pendown()


def haut():
	left(90)
	forward(50)
	right(90)

def bas():
	left(90)
	backward(50)
	right(90)

def gauche():
	backward(50)

def droite():
	forward(50)

jouer = {u'←': gauche,	u'→': droite, u'↑': haut, u'↓': bas}


mot = u'→→→↑→↓↓→'

initialisation()
for m in mot:
	jouer[m]()

On notera que chaque lettre m possible du mot est associée à une fonction par un dictionnaire jouer : jouer[m] est une fonction et en la faisant suivre de parenthèses vides, on l’invoque, ce qui provoque le déplacement.

Les trois suites de déplacements de l’énoncé sont résumés par ces trois mots :

mot = u'→→→↑→↓↓→'
mot = u'→→→↑→→↓↓←↑→'
mot = u'↑→↑→↑→↓'

Pour le programme de Julie, c’est la fonction droite qui est modifiée :

def droite():
	penup()
	forward(50)
	pendown()

Tout d’abord, le bloc « triangle » était défini sur la partie droite des scripts, ce qui laisse penser qu’on doit d’abord réfléchir à ce qu’on fait avec le triangle, avant de réfléchir à la manière de le dessiner. Manière de voir qui reposera en Python l’habituelle question « faut-il d’abord savoir comment on additionne les termes d’une liste de nombres, ou faut-il d’abord savoir comment on passe de la somme à la moyenne ? ». Mais cette définition du bloc « triangle » permet déjà de faire la comparaison avec Blockly, laquelle est à l’avantage de Blockly, parce qu’en Scratch rien n’aide vraiment à voir où s’arrête la définition du bloc ; en Blockly, la définition est en mauve, et en forme de « C » ce qui visualise la fin de la définition :

Contrairement à Scratch qui ne sait, comme on l’a vu, qu’ajouter (du moins, en place) une quantité fixe à une variable, Sofus permet de diminuer la variable, non seulement d’une quantité fixe, mais aussi d’un pourcentage ou d’une fraction : Les longueurs des côtés suivent alors non plus une progression arithmétique (laquelle finit rapidement par aboutir à 0) mais une progression géométrique, ce qui permet de dessiner plus de triangles. Voici un script typiquement « sofusien » :

et l’effet obtenu :

Un autre prolongement possible aurait été de faire utiliser Thalès pour montrer que les sommets des 5 triangles de l’énoncé du brevet, sont alignés...

Mais il y avait plusieurs réponses possibles :

ou

Avec ces rotations, on peut comme précédemment « aller plus loin » en remplaçant la diminution de 20 pixels par une diminution de 20 pourcents, mais les triangles se chevaucheront alors. En réduisant d’un tiers à chaque fois, on a ce script :

et ce dessin :

Le script de l’énoncé faisait appel à une variable globale, qui est la longueur du côté du triangle. Le fait que cette variable est globale, ne revêt aucun caractère obligatoire : On aurait pu, en lieu et place, faire de la procédure triangle une fonction triangle(côté). En dehors du risque de glissement vers la récursivité, il est bon de savoir que cette tentation existait déjà chez Papert, qui cherchait essentiellement à introduire par la pratique, la notion mathématique de fonction.

Les 5 triangles alignés sont produits par ce script :

from turtle import * 

def triangle():
	global côté
	pendown()
	for count in range(3):
		forward(côté)
		left(120)
	penup()


reset()
penup()
setposition(-200, -100)
côté = 100
for count2 in range(5):
	triangle()
	forward(côté)
	côté = côté - 20

La version spiralée est obtenue à l’aide de cette modification de la fin du script :

for count2 in range(5):
	triangle()
	forward(côté)
	left(60)
	côté = côté - 20

L’abscisse initiale révèle que ce tracé est fait à droite ; et la différence entre la longueuret la hauteur révèle que le tracé n’est pas celui d’un carré : Ce programme dessine le rectangle 3 :

Ce programme dessine un carré, et le dessine 40 pixels plus à gauche que le rectangle 3 dessiné par le programme A : Il s’agit donc de celui qui trace le rectangle 2 (un carré en fait) :

Seule la hauteur du rectangle était différente dans le programme C, il suffit donc de remplacer le 10 du programme A par un 20 :

Seulement il faut aussi (bien que ce ne fût pas demandé) modifier l’abscisse de départ, pour que le rectangle soit bien tout à gauche.

Voici le programme dessinant la grille, les trois rectangles et les nombres (à utiliser avec Sofus :

Il suffit d’ajouter un bloc « cacher la tortue » pour avoir un dessin ressemblant beaucoup à celui de l’énoncé.

Le dessin du podium par la tortue de Python peut se faire ainsi :

from turtle import * 
def programme_A():
	setposition(80, 0)
	for count in range(2):
		forward(40)
		left(90)
		forward(10)
		left(90)

def programme_C():
	setposition(0, 0)
	for count2 in range(2):
		forward(40)
		left(90)
		forward(20)
		left(90)

def programme_B():
	setposition(40, 0)
	for count3 in range(4):
		forward(40)
		left(90)


reset()
penup()
setposition(15, 5)
write('2')
setposition(55, 15)
write('1')
setposition(95, 0)
write('3')
pendown()
programme_A()
programme_B()
programme_C()

Noter que, la tortue de Python étant capable d’exporter son dessin au format eps, on peut aisément intégrer ce genre de dessin à un compte-rendu de TP à l’aide de Libre Office Writer...

Enfin on demandait comment modifier le bloc pour obtenir la figure 2. En fait il suffit de changer d’angle :

La seule difficulté se pose sur la forme attendue pour la réponse sur une copie rédigée par écrit : Le candidat doit-il recopier tous les blocs en modifiant ceux sur les rotations ? Doit-il ne recopier que les blocs modifiés ? Si oui doit-il marquer les encoches, colorier en bleu ? Doit-il rédiger des phrases du genre « remplacer les occurences de 90 par des 60 dans chaque bloc concerné » ? Une narration de recherche non aboutie était-elle valorisée ?

Avec SofusPy les blocs (de Blockly en l’occurence) donnent ce script Python, montrant le fait que la longueur est une variable globale :

from turtle import * 
longueur = None

def un_tour():
	global longueur
	for count in range(2):
		forward(longueur)
		left(90)
	longueur = longueur + 30
	for count2 in range(2):
		forward(longueur)
		left(90)


longueur = 30
for count3 in range(2):
	un_tour()
	longueur = longueur + 30

La version pseudocode engendrée par l’outil idoine est

algorithme un_tour()
	répéter 2 fois
		avancer de longueur
		tourner vers la gauche de 90°
        fin boucle
	longueur ← longueur + 30
	répéter 2 fois
		avancer de longueur
		tourner vers la gauche de 90°
        fin boucle
    fin définition de l'algorithme


longueur ← 30
répéter 2 fois
	un_tour()
	longueur ← longueur + 30
fin boucle

Il y avait aussi un programme de calcul dans le « vrai ou faux justifié » plus bas :

On demandait s’il est vrai que « Le résultat du programme de calcul A est toujours égal à 6 ». Les possibilités de calcul formel de Sofus lui permettent de répondre à cette question :

Et l’affirmation 4 « Pour tous les nombres entiers n compris entre 2 et 9, 2ⁿ −1 est un nombre premier » semble nettement plus facile à vérifier avec Blockly qu’avec Scratch :

Mais puisque les étapes du programme de calcul étaient occultées dans le sujet, et que toutes les questions, sans exception, portaient sur le lien entre le nombre choisi au départ et le nombre obtenu à l’arrivée, pourquoi pas définir une fonction au lieu de tous ces affichages qui n’apportent pas grand-chose au problème lors d’une évaluation écrite ?

Cette fonction facilite grandement la résolution des questions 1, 2a et 2b :

Mais aussi le passage au calcul formel nécessaire pour la question 3 ; d’abord la vérification que le programme de calcul donne bien x²-9 :

Puis la résolution de l’équation :

Là Sofus se montre peu doué pour la simplification, le nombre √9 n’ayant pas été reconnu comme étant 3.

Ceci dit, le logiciel Scratch ne semble, ici, qu’avoir servi à habiller un exercice sur les fonctions, lequel aurait pu ressembler à ceci :

On considère la fonction f qui, à un nombre x, associe x²-9.
1. Vérifier que l’image de 2 par cette fonction est -5, c’est-à-dire que la fonction associe, à 2, le nombre -5.
2.a. Quelle est l’image de 5 par la fonction f, c’est-à-dire le nombre f(5) ?
b. Quelle est l’image de -4 par la fonction f ?
3. Résoudre l’équation f(x)=0, c’est-à-dire déterminer tous les nombres auxquels f associe le nombre 0.

On pouvait même utiliser des blocs pour habiller cet exercice avec le vocabulaire des fonctions :

Et bien entendu la version Python est plus concise :

def f(x): return x**2-9

print(f(2))
print(f(5))
print(f(-4))

Voire

for x in [2,5,-4]:
    print(f(x))

Quel est l’intérêt d’avoir un bloc sans variable d’entrée mais qui manipule une variable globale, plutôt que de définir une fonction dépendant de la longueur ?

Ça donnerait ce bloc :

et ces programmes :

Programme n° 1
Programme n° 2

L’utilisation des fonctions évite d’avoir à mémoriser la valeur actuelle d’une variable globale : On voit tout de suite les dimensions du carré tracé.

Voici les dessins effectués par les programmes :

Programme 1
Programme 2

Voici, à côté de chacun des 3 programmes, le dessin qu’il trace :