Adloun

NSI (première) · Chapitre 11 · Exercice de TD

Le groupe hésite entre deux représentations de la grille du morpion

Conduire un projet · Conduire le groupe · niveau 3 (difficile)

Énoncé

Le groupe hésite entre deux représentations de la grille du morpion.


# Conception A : une liste de listes
g = [["X", ".", "."], [".", "O", "."], [".", ".", "."]]

# Conception B : un dictionnaire des cases occupees
g = {(0, 0): "X", (1, 1): "O"}
  • Écrire, pour chaque conception, lire(g, i, j) et ecrire(g, i, j, v).
  • Laquelle rend pleine(g) la plus simple ? Et gagnant(g) ?
  • Le projet passe à une grille où l'on aligne pions. Laquelle choisir, et pourquoi ?
  • Trancher pour le morpion , et justifier.

Corrigé

1.


# Conception A
def lire_A(g, i, j):
    return g[i][j]

def ecrire_A(g, i, j, v):
    g[i][j] = v

# Conception B
def lire_B(g, i, j):
    return g.get((i, j), ".")   # ".", et non une erreur, si la case est vide

def ecrire_B(g, i, j, v):
    g[(i, j)] = v

La différence tient dans get : en B, une case vide n'existe pas, et c'est la fonction de lecture qui invente le ".". Toute la suite du programme peut alors ignorer cette différence — c'est précisément le rôle d'une interface.

2.

  • pleine est plus simple en B : len(g) == 9, contre un double parcours en A.
  • gagnant est identique dans les deux cas si l'on passe par lire : la version à huit trios écrite plus haut ne change pas d'une ligne. C'est le signe que le découpage était bon.

3. B, sans hésitation. Une liste de listes occupe un million de cases, dont sont vides après cinquante coups ; le dictionnaire n'en garde que cinquante. Surtout, gagnant ne peut plus parcourir tous les alignements possibles — il y en a des millions : il faut examiner uniquement les alignements passant par le dernier coup joué, et le dictionnaire s'y prête directement.

4. Pour une grille , A, et l'argument n'est pas technique. Neuf cases : aucune considération de mémoire ni de vitesse ne pèse quoi que ce soit. Ce qui pèse, c'est que la liste de listes s'écrit et se lit telle quelle dans les tests :


assert gagnant([["X", "X", "X"], [".", ".", "."], [".", ".", "."]]) == "X"

La même grille en dictionnaire s'écrit {(0,0):"X", (0,1):"X", (0,2):"X"} : juste, mais illisible. Un jeu de tests qu'on ne relit pas volontiers est un jeu de tests qu'on n'enrichit pas.

Ce que l'exercice montre : il n'y a pas de bonne conception dans l'absolu, seulement une bonne conception pour un cahier des charges. Et le critère décisif, ici, n'est ni la mémoire ni la vitesse — c'est la lisibilité des tests. Un projet de première se juge sur ce qu'on peut vérifier, et l'on ne vérifie bien que ce qu'on lit facilement.

100 % gratuit

Essaie le suivant avec le tuteur

Faire l'exercice suivant avec le tuteur

Sans compte : le cours, 2 minutes de podcast et de vidéo et un exercice avec le tuteur. Pour tout le reste : inscription gratuite en 30 secondes, sans carte bancaire.

Le cours du chapitre · Tous les exercices du chapitre

Exercice suivant avec le tuteur →