Dépôt GitHub : [https://github.com/xiu-ye/zuoye2]

PSP:

1.Organisation du Code

Le module de calcul a pour fonctions principales la génération d'expressions mathématiques, l'évaluation de leur valeur et la vérification de leur validité. L'organisation du code se présente comme suit :

• Classes :
• Nombre : Encapsule les entiers et les fractions, offrant la simplification de fractions, la représentation en chaîne et la conversion entre types.
• NoeudExpression : Représente un nœud de l'arbre d'expression, supportant les nœuds feuilles (nombres) et les nœuds internes (opérateurs avec sous-arbres gauche et droit).
• Fonctions :
• creer_expression : Génère récursivement un arbre d'expression mathématique aléatoire.
• evaluer : Calcule récursivement la valeur de l'arbre d'expression.
• est_valide : Vérifie la validité de l'arbre d'expression.
• valider_operation : Vérifie la validité d'un opérateur spécifique (comme les contraintes de soustraction et de division).
• generer_nombre : Génère un nombre aléatoire (entier ou fraction).
• forme_canonique : Convertit l'arbre d'expression en forme canonique pour éviter les expressions dupliquées.
• formater_expression : Formate l'arbre d'expression en chaîne avec parenthèses et espaces.

Relations entre Classes et Fonctions

• Nombre et NoeudExpression constituent les structures de données fondamentales, représentant respectivement les nombres et les nœuds d'expression.
• creer_expression utilise NoeudExpression pour construire l'arbre et appelle generer_nombre pour générer des nombres aléatoires.
• evaluer et est_valide s'appuient sur la structure de NoeudExpression pour calculer ou valider l'expression récursivement.
• valider_operation est une fonction auxiliaire de creer_expression garantissant la validité des expressions générées.
• forme_canonique et formater_expression standardisent et mettent en forme les expressions.

2.Diagramme de Flux des Fonctions Clés

Voici le diagramme de flux pour creer_expression :

Début
  |
  v
Générer un nombre aléatoire (probabilité 0.3 ou atteint nb_opérations_max) -> Retourner nœud feuille
  |
  v
Sélectionner un opérateur aléatoire (+, -, *, /)
  |
  v
Générer récursivement le sous-arbre gauche
  |
  v
Générer récursivement le sous-arbre droit
  |
  v
Valider la legality de l'opération (valider_operation) -> Si invalide, régénérer
  |
  v
Retourner le nœud interne
Fin

Points Clés et Originalité de l'Algorithme

• Génération récursif d'expressions : La génération aléatoire récursive d'arbres d'expression assure la diversité et la complexité des expressions.
• Forme canonique : L'utilisation de forme_canonique empêche la génération d'expressions dupliquées.
• Vérification de validité : La validation en temps réel de la légalité des opérations de soustraction et de division garantit que les expressions sont calculables.

3.Code Clé du Projet et Explications

Génération d'Expression

def creer_expression(nb_operations_max, valeur_max, operations_courantes=0):
    if operations_courantes > nb_operations_max:
        return None

    if random.random() < 0.3 or operations_courantes == nb_operations_max:
        return NoeudExpression(valeur=generer_nombre(valeur_max))

    operateur = random.choice(['+', '-', '*', '/'])
    gauche = creer_expression(nb_operations_max, valeur_max, operations_courantes + 1)
    droite = creer_expression(nb_operations_max, valeur_max, operations_courantes + 1)

    if not valider_operation(gauche, droite, operateur, valeur_max):
        return creer_expression(nb_operations_max, valeur_max, operations_courantes)

    return NoeudExpression(gauche=gauche, op=operateur, droite=droite)

• Fonctionnalité : Génère récursivement un arbre d'expression aléatoire.
• Points essentiels :
• Le contrôle de la probabilité de génération des nœuds feuilles via random.random().
• L'utilisation de valider_operation pour garantir la légalité des opérations.

Évaluation de la Valeur d'Expression

def evaluer(noeud):
    if noeud.est_feuille():
        return noeud.valeur.vers_fraction()

    gauche = evaluer(noeud.gauche)
    droite = evaluer(noeud.droite)

    return {
        '+': lambda a, b: a + b,
        '-': lambda a, b: a - b,
        '*': lambda a, b: a * b,
        '/': lambda a, b: a / b
    }[noeud.op](gauche, droite)

• Fonctionnalité : Calcule récursivement la valeur de l'arbre d'expression.
• Points essentiels :
• L'utilisation d'un dictionnaire pour mapper les opérateurs vers les fonctions de calcul correspondantes.
• L'évaluation récursive des valeurs des sous-arbres gauche et droit.

4. Cas de Test

Voici 10 cas de test avec leurs descriptions :

Vérification de Correctness

• Chaque résultat attendu est vérifié par calcul manuel.
• La fonction evaluer est utilisée pour calculer les résultats et les comparer aux valeurs attendues.

5. Bilan du Projet en Binôme

• Encouragement à l'expérimentation : « Détecter les problèmes est plus précieux que d'avancer rapidement »
• Expression active de la pensée : Expliquer pendant le codage, comme « ici j'utilise la récursion pour traiter la structure arborescente car le nombre de niveaux est indéterminé »
• Questions et retours immédiats : Signaler directement les problèmes détectés
• Éviter le silence prolongé : En cas de blocage, dessiner ensemble un diagramme de flux ou du pseudo-code pour clarifier la logique.