La programmation au brevet des collèges 2017

samedi 24 juin 2017
par  Alain BUSSER

Le brevet des collèges 2017 a vu l’apparition de programmes en Scratch dans les sujets. C’est la première session depuis que Scratch est au programme. Et c’est aussi la dernière étape vers la programmation textuelle au lycée. D’ailleurs la version Python sera ajoutée en bas de chaque exercice Scratch. Ces scripts Python ont souvent été rédigés à l’aide de SofusPy.

Note : Cet article est lié à l’actualité, et évoluera donc selon celle-ci, au gré de l’apparition (a priori fréquente) de programmes dans les sujets du brevet 2017.

Inde

Le calendrier a fait qu’une fois de plus, Pondichery a été l’académie pionnière. Ce sont les élèves de ce collège qui ont découvert à quoi peut ressembler un sujet sur Scratch par écrit. Les élèves des deux classes de 3e de Pondichery, n’ayant pas trop souffert de problèmes d’équipement, et malgré la disparition d’une demi-heure, ont été régulièrement entraînés à Scratch durant tout le tiers de cycle 2016-2017, et ne semblent pas avoir été trop déroutés par le sujet : Leurs enseignants ont anticipé sur l’utilisation algébrique de Scratch.

Voici, à fin de comparaison, les versions Sofus et Scratch du programme de calcul de Julie :

Sofus Scratch

Variables et constantes

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].

logique ?

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...

calcul formel

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 :

tableur

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

énoncé tableur
x A1
étape 1 A2
étape 2 A3
résultat A4

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

7
=6*A1
=A2+10
=A3/2

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 :

OpenDocument Spreadsheet - 14.7 ko

En résumé, ce sujet, s’il est intéressant per se, pose la question de la pertinence de Scratch pour des activités numériques, du moins sur des programmes de calcul. Il pose aussi la question du mode d’évaluation, un sujet écrit n’étant pas nécessairement pertinent sur un logiciel fait pour manipuler en ligne.

Python

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))

USA

Le sujet de Washington met la barre haut : Deux exercices portant sur des programmes !

Exercice 2

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 :

CarMetal - 13.8 ko

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 cm2, soit 16 cm2, et donc AB=4 cm.

Exercice 5

L’exercice 5, faisant appel à Scratch (et même précisément à la version 2.0), était plus prévisible. Il n’en est pas moins innovant parce que les déplacements ne sont pas de type « tortue » mais de vraies translations y sont appliquées au chat.

Voici la position de départ du jeu : Le chat est en (-120 ;-80) et la balle est en (160,120) :

script du chat

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.

Les variables x et y sont les coordonnées du chat (il vaut mieux le savoir si on veut faire la suite de l’exercice). Les flèches ont donc pour effet de faire avancer ou reculer le chat parallèlement à l’un des axes de coordonnées. Donc un appui sur la flèche droite suivi d’un appui sur la flèche gauche a pour effet que le chat va avancer de 80 pixels puis reculer de 40 pixels : Il ne sera donc pas au point de départ.

Variables

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 :

Zip - 747 octets

Le raisonnement ci-dessus permet de suivre le chemin effectué par le chat si on appuie sur ces touches :

Le parcours montre que les coordonnées finales sont (0 ;-40) :

Preuve

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 :

étapes x y
départ -120 -80
-40 -80
40 -80
40 0
0 0
0 -40

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

Pour le QCM, là encore, il y a un implicite : Le chat est supposé de retour au point de départ. C’est peut-être évident pour le rédacteur du sujet, ça l’est peut-être moins pour les candidats...

Déplacements

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.

Dernière question

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.

Python

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...

Maroc

Le sujet Centres étrangers comportait lui aussi un exercice sur Scratch, mais en fait c’était un exercice portant essentiellement sur une tâche complexe et de la géométrie.

Une maison était définie, au départ, comme un quadrilatère ouvert ou un pentagone privé d’un de ses côtés, défini ainsi :

L’affichage de l’abscisse donne bien, comme il était demandé de le vérifier, environ 71 :

On ne peut tracer que 5 maisons comme le montre ce script avec affichage des abscisses directement sur le dessin :

Le dessin obtenu autovalide le script, en passant :

La dernière question donne lieu à des modifications non précisées dans l’énoncé : Les maisons simplifiées avaient des toits inclinés à 45°, il est évident que le nouvelles maisons ont des toits inclinés à 30° :

Outre les modifications d’angles, il fallait remplacer dans le script « initial », le bloc mis en exergue, par les 9 blocs de droite :

On y voit que EM=8, MC=13 (calculés par trigonométrie) et HE=5√3.

Ceci pose la question du sens du mot calculer de la dernière question : S’agissait-il comme dans la première question, de donner un résultat arrondi à l’entier ? Fallait-il arrondir autrement ? La réponse exacte devait-elle être écrite comme 5√3 ou pouvait-on écrire √75 ?

Python

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)

Polynésie

série générale

Le sujet est disponible ici

Encore un programme de calcul :

En fait la fonction ainsi programmée est affine (on se sert de ce résultat pour la suite) :

Pour savoir quel nombre on doit choisir au départ pour avoir à -3 l’arrivée, on peut fabriquer une équation en concaténant les -4x+5 avec le texte « =-3 » ; La chaîne de caractères ainsi obtenue (ici, -4x+5=-3) est une équation, qu’il suffit ensuite de résoudre :

Comme on l’a vu dans l’onglet sur Pondichéry, on pouvait aussi « remonter les calculs », en suivant ce plan :

  • Si on a -3 après avoir augmenté de 5, c’est qu’on avait -8 avant ;
  • Si on a -8 après avoir multiplié par -4, c’est qu’on avait 2 avant.

Salomé

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 » ?

Sans entrée pénible de données

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 :

CarMetal - 2.2 ko

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.

Python

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 '))

série professionnelle

Dans le sujet du brevet professionnel, il y avait un long script de déplacement (le chat imitait un drone, on n’est pas certain que la ressemblance soit frappante !)

Version Scratch simplifiée Version Sofus

Dans Sofus, c’est la tortue qui se prend pour un drone, mais l’énoncé disait bien qu’on teste le drone. D’ailleurs un drone qui « efface tout », ça fait un peu peur : On se demande si on veut vraiment garer son vélo sous un tel drone...

Voici le dessin tracé :

Bref, ce drone parcourt des rectangles. Et il en parcourt 10 puisque 400=40×10.

factorisation du script

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 :

Python

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
        (...)

Asie

Le sujet est dispnible ici.

Encore un programme de déplacement de tortue, et encore un qui se situe en dehors du paradigme de la tortue puisqu’il est fait assez explicitement usage, au lieu des rotations de la tortue, d’une boussole, ou plutôt d’une rose des vents :

Margot a écrit un programme permettant de faire des dessins à l’aide des touches ↑, → et ↓ du sujet d’Amérique du Nord (exercice 5, voir onglet « USA » : Il manque ici la touche « vers la gauche »). Par défaut les déplacements du lutin laissent des traits sur l’écran, mais pour obtenir cela, le stylo est baissé à chaque déplacement puis relevé après, systématiquement. Le programme aurait été plus simple si le stylo était tout le temps baissé, mais lorsqu’on téléporte le lutin de Scratch dans le bloc initialisation, il laisserait une trace si son stylo était baissé : La téléportation se fait, sous Scratch, au ras de l’écran, et pas par le cycle dématérialisation/rematérialisation immortalisé par Monsieur Spock...

Le sujet, comme celui d’Amérique du Nord, présente un programme (de déplacement) sous forme d’un mot (sur l’alphabet ↑, → , ↓) et, comme dans l’onglet « USA » on va ici écrire ces mots plutôt que décrire des séquences d’appui de touches [7]. Voici les trois dessins du sujet, avec les mots les traçant :

Preuves

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).

Julie

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 :

Python

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()

Métropole

Le sujet de juin Métropole/Réunion comportait un exercice pas trop difficile, comportant de belles figures. On va donc ici en profiter pour proposer quelques prolongements.

Triangle

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 :

Voici la version Sofus du script de l’énoncé :

La seconde ligne (3e sur la version Scratch) comprend les coordonnées demandées dans le sujet, mais on remarque que leur notation est plus cohérente avec celle du cours de maths, que celle de Scratch : Aller à x : -200 y : -100 qui semble héritée de la programmation objet, ce qui nécessite un effort de lecture.

Le script fait ce dessin :

On y voit les 5 triangles dessinés (information qui elle aussi se lisait dans le script : C’est le nombre de répétitions).

Dans la version Sofus, la variable côté est diminuée de 20, alors que dans la version Scratch, on lui ajoute -20 : Cette version, moins naturelle [8], donne lieu à une question qui aurait perdu son intérêt avec la version Sofus : Quelle est la longueur du côté du deuxième triangle ?. On trouve bien sûr 80...

Pour aller plus loin

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...

Pour obtenir cette figure :

il n’y avait qu’un bloc à ajouter.

Pluralité

Mais il y avait plusieurs réponses possibles :

ou

Vers une spirale logarithmique

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 :

Variables locales et globales

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.

Python

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

Sujet section professionnelle

Savoureux style littéraire que permet l’allusion à Scratch sans le citer :

Le chat doit dessiner le podium ci-dessous constitué de trois plots numérotés de 1 à 3 :

En effet dans le monde de Scratch, non seulement les chats savent dessiner, mais en plus ils doivent le faire ! On se permettra ici, une fois encore, de préférer le paradigme de la tortue de Papert, que l’on pouvait, à l’aide d’un stylo, transformer en table traçante, et qui sera vue de dessus afin de permettre de voir à la fois la tortue et son plan de travail (là où elle dessine) [9].

Le but de l’exercice était de programmer ces trois tracés de rectangles, d’une part avec un QCM à deux choix, demandant de déterminer quel programme trace quel rectangle, et ensuite avec une modification demandée à l’un des programmes (le A) pour avoir le programme (qu’on appellera C ici) dessinant le troisième rectangle.

Programme A

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 :

Programme B

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) :

On constate que la première question portait sur une relation, ou plus précisément une application entre

  • l’ensemble des programmes (tout au moins A et B) ;
  • l’ensemble des rectangles.

L’objet de cet exercice était donc de mettre en relation, d’une part A et 3, d’autre part B et 2. Ce qui peut aisément se représenter par un diagramme sagittal de ce genre :

A ⟶ 3
B ⟶ 2

C’est peut-être l’occasion de remettre au programme les notions de théorie des graphes qui prévalaient à l’époque des « maths modernes » et plus particulièrement les ensembles et les relations, représentées par diagrammes sagittaux...

Programme C

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.

Bonus

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é.

Python

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...


[1On remarque que le même mot « résultat » désigne, dans le script, trois choses différentes :

  • le premier résultat intermédiaire (le nombre sextuplé, auquel on ajoute 10) ;
  • le second résultat intermédiaire (destiné à être divisé par 2) ;
  • une variable contenant le nombre « dit » à la fin.

[2En fait, l’affichage des quatre constantes l’une en-dessous de l’autre aboutit à une émulation de tableur par Scratch. Dans ce cas on peut se demander qu’est-ce qui, en dehors d’un effet de mode, a pu faire préférer Scratch au tableur, dans lequel les quatre constantes se seraient appelées par exemple A1, A2, A3 et A4 tout simplement...

[3Schéma préparé par l’un des collègues ayant essuyé les plâtres de l’autre côté de cet océan.

[4Transformer une chaîne de caractères en une liste de noms, c’est quelque chose qu’on fait couramment en Python, et là aussi avec split ; on peut donc considérer cet exercice comme une préparation à la programmation en Seconde...

[5Si l’équipe de Scratch avait daigné rajouter un bloc « diminuer de » le script serait plus simple à comprendre. Mais le but de l’équipe de Scratch n’est apparemment pas de simplifier la vie des programmeurs...

[6C’est encore un pas vers la programmation en Python : Définir des fonctions comme « rectangle(L,l) ».

[7Ce qui éloigne ce corrigé de l’aspect « programmation évènementielle » préconisé au cycle 4. Mais cette approche n’est pas sans inconvénient...

[8C’est le cas de le dire, puisque -20 n’est justement pas un entier naturel !

[9Le chat de Scratch, parfois appelé lui-même « Scratch », effectue de dangeureux saltos arrières à chaque tracé de rectangle, le tout sans jamais cesser de tracer son parcours sur la feuille.


Commentaires

Logo de Alain BUSSER
mercredi 28 juin 2017 à 11h30 - par  Alain BUSSER

Merci pour ces encouragements : Sofus étant un logiciel libre, l’autorisation de l’utiliser est automatique, il n’y a pas besoin de demander ! C’est ça la magie des logiciels libres, on peut faire un fork sur github et le modifier comme on le veut !

Maintenant, en renommant les différents fichiers JavaScript en « fr » et en les duplicant sous forme espagnole on peut avoir une version bilingue de Sofus, qu’il devrait être possible d’intégrer dans la version « officielle » de Sofus. En attendant je peux toujours placer la version espagnole actuelle dans cette rubrique.

Logo de Jose Manuel Ruiz Gutiérrez
vendredi 26 mai 2017 à 15h18 - par  Jose Manuel Ruiz Gutiérrez

Bonjour Alain.

Mon nom est Jose Manuel Ruiz Gutierrez, je suis professeur de l’enseignement secondaire dans le domaine de la technologie Informatica. J’ai téléchargé votre programme Sofus et je l’aime vraiment.

Je voudrais l’utiliser avec mes élèves et pour cela, je l’ai fait la traduction en espagnol et que vous voulez savoir comment je peux l’envoyer pour vous de voir et de me donner l’autorisation d’utiliser votre matériel pédagogique et jouer avec.

Il serait bon de développer un manuel expliquant des exemples et un guide d’utilisation pour les étudiants et les utilisateurs.

Je voudrais savoir si vous avez des exemples qui peuvent utiliser et ajouter à cette version Sofus-espagnole.

Cordialement

José Manuel Ruiz Gutiérrez
professeur
IES Fco. Garcia Pavon
Tomelloso (Ciudad Real) ESPAGNE

Annonces

Prochains rendez-vous de l’IREM

Séminaire EDIM-IREM

- Mercredi 13 septembre 2017, 14h-18h, PTU, Saint-Denis, salle S23.6
- Mercredi 4 octobre 2017, 14h-18h, PTU, Saint-Denis, salle S23.6
- Mercredi 11 octobre 2017, 14h-18h, campus du Tampon
- Mercredi 22 novembre 2017, 14h-18h, campus du Tampon
- Mercredi 7 février 2018, PTU, Saint-Denis, salle S23.6
- Mercredi 7 mars 2018, 14h-18h, campus du Tampon
- Mercredi 4 avril 2018, PTU, Saint-Denis, salle S23.6
- Mercredi 2 mai, 14h-18h, campus du Tampon
- Mardi 5 juin 2018, PTU, Saint-Denis, salle S23.6
- Mercredi 6 juin, 14h-18h, campus du Tampon

Fête de la science

Du 13 au 18 novembre 2017.
Thème : « La recherche à l’heure du numérique »

Semaine des mathématiques

Du 26 au 31 mars 2018.
Thème : « Mathématiques et mouvement »


Brèves

Décès de Roger Mohr

mardi 27 juin

On sait bien que Nicolas Bourbaki n’était pas le nom d’une personne mais le pseudonyme d’un groupe. L’équivalent en informatique théorique est Claude Livercy, auteur de la théorie des programmes. Roger Mohr était un des membres de Claude Livercy.

À travers les labyrinthes : algorithmes et fourmis

dimanche 1er septembre 2013

Quand les chercheurs mettent au point des modèles d’optimisation et de recherche de plus court chemin qui s’inspirent du comportement de masse de colonies de fourmis...
À écouter : Sur les Épaules de Darwin, émission diffusée sur France Inter samedi 31 août 2013.

Rencontres Mondiales du Logiciel Libre à St-Joseph

mardi 20 août 2013

Les RMLLd se dérouleront pour la 2e fois à Saint-Joseph du 22 au 25 août.
C’est une opportunité pour les élèves qui suivent la spécialité ISN et les passionnés d’informatique.

Voici pour le samedi et le dimanche quelques interventions choisies :
- http://2013.d.rmll.info/Raspberry-votre-ordinateur-au-format-carte-de-credit?lang=fr
- http://2013.d.rmll.info/Materiel-libre-et-DIY?lang=fr
- http://2013.d.rmll.info/Arduino-de-l-electronique-libre?lang=fr

Noter aussi les conférences Art et Culture du dimanche, ainsi qu’une conférence plus engagée.

Le programme complet se trouve ici. Une radio sera ouverte pour l’occasion.
Des plaquettes à distribuer se trouvent ici.

Hyper-vidéos pour l’algorithmique au lycée

dimanche 19 août 2012

Olivier Roizès, à la demande de l’ADIREM, a réalisé une collection d’hyper-vidéos de présentation de logiciels et environnements de programmation. Ces hyper-vidéos, c’est-à-dire des vidéos contenant des éléments clicables, devraient être utiles aux enseignants désireux de se familiariser avec Python, CaRMetal, R, Rurple, Scilab ou Xcas.

Ouverture du SILO

mardi 1er novembre 2011

Le SILO (Science Informatique au Lycée : Oui !) est un espace collaboratif documentaire de partage et de formation collégiale, à destination des professeurs appelés à enseigner l’informatique au lycée.

Une initiative du CNDP, de l’INRIA et de Pasc@line, à laquelle se sont associés SPECIF, fuscia, EPI et ePrep.

Sur le Web : Site du SILO

Introduction à la science informatique

lundi 12 septembre 2011

Le CRDP de Paris publie le premier ouvrage destiné aux professeurs chargés d’enseigner la nouvelle spécialité « Informatique et sciences du numérique » en Terminale S à la rentrée 2012. Cet ouvrage a été coordonné par Gilles Dowek, directeur de recherche à l’INRIA.

Sur la création de la spécialité ISN, on pourra également consulter l’interview donnée au Café pédagogique par l’inspecteur général Robert Cabanne.

Sur le Web : CRDP de Paris

Deux publications sur l’algorithmique

samedi 17 octobre 2009

L’IREM d’Aix-Marseille publie une brochure de 73 pages, téléchargeable librement, intitulée Algorithmes et logique au lycée. Ces notions sont illustrées et déclinées sur des exercices du programme de spécialité mathématique en série L, mais sont adaptables aux programmes à venir.

Le hors série thématique n° 37 du magazine Tangente, disponible actuellement en kiosque, s’intitule « Les algorithmes. Au cœur du raisonnement structuré ». Extrait de l’éditorial : « La rédaction de Tangente a conçu la quasi-totalité de ce hors série thématique pour qu’il puisse être lu par des élèves de Seconde ».

Une carte mentale pour l’algorithmique

jeudi 10 septembre 2009

Sur son site, Jean-Jacques Dhénin a publié une carte mentale géante qui renvoie vers plus de 30 documents en ligne sur l’algorithmique. Tout ce qu’il faut — et même davantage — pour faire face au nouveau programme de Seconde !

Un catalogue libre d’algorithmes pour le lycée

dimanche 30 août 2009

Guillaume Connan, de l’IREM de Nantes, publie un catalogue libre de 119 pages d’algorithmes pour le lycée. Sur son site très riche, on trouvera d’autres documents en rapport avec l’algorithmique, notamment sur l’utilisation des langages fonctionnels au lycée et sur la comparaison programmation fonctionnelle/programmation impérative.

L’algorithmique à l’IREM de Lille

vendredi 26 juin 2009

Le groupe AMECMI de l’IREM de Lille vient de mettre en ligne des ressources importantes au service des professeurs de Seconde :

- Algorithmique et programmation (Emmanuel Ostenne)
- Bibliographie amoureuse de l’algorithmique (Alain Juhel)

Statistiques

Dernière mise à jour

dimanche 24 septembre 2017

Publication

766 Articles
Aucun album photo
133 Brèves
11 Sites Web
132 Auteurs

Visites

31 aujourd'hui
1180 hier
2101275 depuis le début
10 visiteurs actuellement connectés