« Code Puzzle », un logiciel intermédiaire entre Scratch et Python

Article mis en ligne le 6 décembre 2022

dernière modification le 25 décembre 2022

par Patrick Raffinat

A) Introduction

Dans cet article du N°82, j’ai présenté 2 environnements pédagogiques facilitant l’enseignement de Python au lycée via la programmation par blocs : SofusPyScratch et l’interface développée par Vittascience. Les deux environnements permettent notamment de programmer de façon « hybride » : on débute par un « squelette de programme par blocs », puis on en obtient automatiquement la traduction en Python qu’il reste alors à compléter (voir activité SofusPyScratch et exemple Vittascience) .

Depuis, j’ai découvert l’existence du logiciel « Code Puzzle », développé par Laurent Abbal, sur le site de l’IREM TICE : voir lien. Comme son nom le suggère, ce logiciel demande à l’élève de reconstituer un programme Python à partir de « petits bouts façon puzzle » (à déplacer par des clics-glissés) :

Il faut non seulement réordonner les instructions, mais aussi les indenter correctement : on peut le vérifier sur la copie d’écran ci-dessus, où « Code Puzzle » détecte une erreur d’indentation pour l’instruction « print(« admis ») » alors que les instructions sont pourtant dans le bon ordre.

Dans la première partie de cet article, je présenterai quelques exemples extraits de https://www.lycee-en-foret.fr/defis-python/, que j’ai testés avec mes étudiants de 1ère année en IUT.

J’expliquerai ensuite dans une deuxième partie comment créer divers types de puzzles : sans ou avec fausses pistes (c’est à dire des instructions n’appartenant pas au programme à reconstituer), avec des « trous » à compléter ou avec des listes déroulantes.

B) Exemples : les défis Python du Lycée En Forêt (Montargis)

Introduction

Sur le site de Code Puzzle, seuls deux exercices sont disponibles : moyenne d’une liste (sans et avec « fausses pistes »). J’en ai donc cherché d’autres « prêts à l’emploi » sur internet et n’en ai trouvé que sur https://www.lycee-en-foret.fr/defis-python/. Et parmi les 25 défis proposés (à des élèves de NSI), j’en ai choisi quelques-uns que j’ai soumis à mes étudiants de première année d’IUT.

Il est probable que le nombre d’exercices « prêts à l’emploi » va rapidement croître, en particulier parce que « Code Puzzle » vient d’être intégré à la plate-forme « Capytale » :

Défis sans listes

La plupart des défis sont avec des listes, mais j’en ai néanmoins trouvé quelques-uns sans listes :

Approximation du nombre Pi (instruction for, entiers impairs) : lien.
Vérification du tri croissant d’une liste (numérotation d’une liste, booléens) : lien.
Algorithme du rendu de monnaie (instruction while) : lien.

Voici à titre d’exemple la solution du second défi, très utile pour vérifier si vos élèves savent correctement indenter un code Python :

Le troisième défi porte sur le rendu de monnaie : à partir d’une somme entière à rendre, il faut déterminer le nombre de billets de 5 euros (n1), le nombre de pièces de deux euros (n2) et le nombre de pièces de un euro (n3). Certains de mes étudiants ont constaté que seule une des solutions possibles était acceptée :

Quand je l’ai signalé à Laurent Abbal, l’auteur du logiciel, il m’a répondu ceci :

Effectivement, il n’est pas possible de contrôler le cas des lignes interchangeables. Dans ce cas, on peut guider les élèves avec des consignes supplémentaires.
Pour résoudre ce problème, la prochaine version de Code Puzzle proposera de valider le code avec des jeux de tests.

Je reviendrai sur ce défi en annexe, car il a débouché sur plusieurs exercices complémentaires sur le rendu de monnaie : même s’ils n’ont pas été traités avec « Code Puzzle », j’en parlerai car cela peut donner de bonnes idées d’activités Python à des collègues.

Défis avec listes

Beaucoup des défis n’utilisent pas d’indices de listes, par exemple celui-ci qui compte le nombre de fois où une valeur est présente dans une liste :

Comme je voulais faire travailler mes étudiants sur les indices, j’ai donc choisi cet autre défi où il faut déterminer si une liste est croissante :

Alors que ce puzzle a été proposé au septième TP du module (sans compter 6 Tds d’algorithmique, et 4 cours magistraux), il a néanmoins posé de nombreux problèmes à près de la moitié de mes étudiants…

Faut-il y voir une conséquence de la réduction du nombre d’heures de mathématiques en Première et Terminale (à partir de 2019) dans le (gros) manque de logique de ces étudiants ? Faut-il y voir l’effet des confinements pendant leur scolarité en Seconde et en Première ? Je ne sais pas, mais c’est le faible niveau constaté cette année en classe qui m’a conduit à inclure « Code Puzzle » dans quelques Tps, alors qu’initialement je ne l’avais pas prévu.

C) Création de puzzles

Introduction

Sur le site de Code Puzzle, il faut cliquer sur le bouton « créer un puzzle » puis renseigner plusieurs champs, dont obligatoirement le champ « code » (contenant le programme à reconstituer) et facultativement le champ « faux code » :

On récupère alors un lien, ou un code à insérer dans une page web, ou un code à insérer dans un « notebook » Jupyter :

Code à trous et liste déroulante

Voici un exemple avec deux trous à compléter et une liste déroulante :

Et voici comment il a été créé :

Les deux trous sont créés à partir de crochets et de points d’interrogation dans l’instruction « while », tout comme la liste déroulante.

D) Conclusion

« Code Puzzle » est un logiciel que je recommande vivement, sinon je n’aurais pas pris la peine de rédiger cet article ! Et les concepteurs du projet « Capytale » ont été visiblement du même avis que moi, puisque « Code Puzzle » y a été intégré...

Annexe 1 : exercices complémentaires sur le rendu de monnaie

Je reviens sur le puzzle « rendre la monnaie », car il a débouché sur plusieurs exercices complémentaires : même s’ils n’ont pas été traités avec « Code Puzzle », j’en parle car cela peut donner de bonnes idées d’activités à des collègues. Pour mémoire, le code Python obtenu était le suivant :

def rendu(somme_a_rendre):
n1, n2 = 0, 0
while somme_a_rendre >= 5 :
somme_a_rendre = somme_a_rendre - 5
n1 = n1 + 1
while somme_a_rendre >=2 :
somme_a_rendre = somme_a_rendre - 2
n2 = n2 + 1
n3 = somme_a_rendre
return [n1, n2, n3]

Télécharger

1) Un premier exercice complémentaire peut être de demander aux étudiants d’utiliser la fonction « floor » du module « math », afin de supprimer les deux boucles du programme ci-dessus. La solution attendue est alors la suivante :

import math
def rendu(somme_a_rendre):
n1 = math.floor(somme_a_rendre/5)
somme_a_rendre = somme_a_rendre - 5*n1
n2 = math.floor(somme_a_rendre/2)
somme_a_rendre = somme_a_rendre - 2*n2
n3 = somme_a_rendre
return [n1, n2, n3]

Télécharger

2) Un second exercice complémentaire plus ambitieux consiste à généraliser le rendu de monnaie à des espèces quelconques, qu’on met dans un tableau où elles sont rangées par ordre décroissant (par exemple [5, 2, 1] ou [10, 5, 2, 1]) :

def rendu(somme_a_rendre, especes) :
quantites = [0]*len(especes)
# à compléter …
return quantites
# quelques tests
print(rendu(13, [5,2,1]))
print(rendu(13, [10,5,2,1]))

Télécharger

3) Certains étudiants ont constaté que leur solution à la question 2 ne marchait pas dans certains cas : par exemple, « print(rendu(13.7, [5,2,1,0.1])) » donne 6 pièces de 0.1 euro au lieu de 7. Je leur ai donc demandé de faire afficher dans la boucle les valeurs successives prises par la variable « somme_a_rendre » :

def rendu(somme_a_rendre, especes) :
quantites = [0]*len(especes)
for k in range(0, len(especes)) :
while (somme_a_rendre >= especes[k]) :
somme_a_rendre = somme_a_rendre - especes[k]
quantites[k] = quantites[k] + 1
print(somme_a_rendre)
return(quantites)
# un test
print(rendu(13.7, [5,2,1,0.1]))

Télécharger

Et là, on constate en examinant la trace que le résultat erroné provient de calculs « approximatifs » de Python sur les nombres réels :

8.7

3.6999999999999993

1.6999999999999993

0.6999999999999993

0.5999999999999993

0.49999999999999933

0.39999999999999936

0.2999999999999994

0.19999999999999937

0.09999999999999937

[2, 1, 1, 6]

Une parade est d’ajouter initialement un millième d’euro à la somme à rendre, mais c’est trop « bidouillage » à mon avis. J’ai donc préféré orienter les étudiants vers une solution plus « sophistiquée », en leur demandant d’utiliser la fonction « round » (pour un arrondi à 2 décimales).

Annexe 2 : exercices autocorrectifs (hors Code Puzzle)

Comme je l’ai signalé précédemment dans l’article, c’est le faible niveau constaté cette année en classe qui m’a conduit à inclure « Code Puzzle » dans quelques Tps, alors qu’initialement je ne l’avais pas prévu. Pour pallier les lacunes des étudiants, j’ai aussi recherché sur internet s’il y avait des sites d’enseignants du secondaire avec des exercices autocorrectifs adaptés à mes besoins. Et j’en ai découvert un que je conseille aux collègues de lycée : https://python.dellasantina.corsica/.

J’ai commencé par une séance de soutien (avec une dizaine d’étudiants en grosse difficulté) où j’ai proposé des exercices autocorrectifs de Seconde :

pour les instructions conditionnelles, j’en ai choisi quelques-uns ici.
pour les boucles, j’en ai sélectionné d’autres ici.

Ensuite, lors plusieurs séances de Tps, j’ai demandé à tous les étudiants de résoudre quelques exercices de Première NSI sur les listes.

Concernant tous ces exercices, une alternative pédagogique pourrait être de les proposer en tant que puzzles : avis aux amateurs...

A) Introduction

B) Exemples : les défis Python du Lycée En Forêt (Montargis)

C) Création de puzzles

D) Conclusion

Dans le même numéro