Partage
  • Partager sur Facebook
  • Partager sur Twitter

Algorithme calculatrice

avec python

    29 décembre 2021 à 19:32:13

    @mps:
    tu as écrit:
    >>> a = (mul, 4, (sub, 3, 1))
    Comment as-tu obttenu cette expression?
    On a au départ: 4*(3-1)
    C'est la conversion de l'un dans l'autre qu'il faut faire.
    • Partager sur Facebook
    • Partager sur Twitter

    Le Tout est souvent plus grand que la somme de ses parties.

      29 décembre 2021 à 20:21:02

      Le PO ne dit pas comment il a construit expression = AB('*', feuille(4), AB('-', feuille(3), feuille(1))). C'est l'objet qu'il passe à son calc supposé évaluer l'expression.

      • Partager sur Facebook
      • Partager sur Twitter
        30 décembre 2021 à 4:52:54

        Selon moi, le plus compliqué (comme l'a dit mps) n'est pas d'évaluer l'expression. C'est plutôt de construire un arbre qui soit valide.
        Et j'insiste sur l'idée que d'associer une priorité à chaque élément facilite grandement la tâche.
        Pour la validation, on parcourt l'arbre récursivement.
        Si une feuille a des fils, il manque un opérateur.
        Si un opérateur manque d'un fils (ou deux), il manque un opérand.
        Rien d'auttre, mais il faut le faire ...

        Je vois trois étapes:

        + parsing: analyse et reconnaissance des éléments sémantiques.

        + construction de l'arbre des priorités.

        + évaluation de l'expression.

        -
        Edité par PierrotLeFou 30 décembre 2021 à 7:39:17

        • Partager sur Facebook
        • Partager sur Twitter

        Le Tout est souvent plus grand que la somme de ses parties.

          30 décembre 2021 à 7:45:52

          PierrotLeFou a écrit:

          Merci mps pour l'info, je pensais que c'était pour des float.
          Ce que YesyesyesOkokok veut faire est évaluer l'expression avec un arbre.
          Ce que tu suggères oblige à construire l'expression sous forme de chaîne et utiliser eval() pour l'évaluer.
          Ce que j'ai fait ne respecte pas tout à fait la philosophie de la POO, mais c'est nettement plus simple.
          Je réussis à tout coder en incluant la validation en environ 75 lignes.


          Pouvons nous avoir un aperçus de celui ci ?
          • Partager sur Facebook
          • Partager sur Twitter
            30 décembre 2021 à 8:40:58

            C'est finalement plus long que je pensais. Ça inclus les exposants ('**')
            -
            from operator import *
            class Node:
                def __init__(self, value='', priority=0, father=None, left=None, right=None):
                    self.value = value
                    self.priority = priority
                    self.father = father
                    self.left = left
                    self.right = right
            # Analyse de l'expression.
            def parsing(expression):
                digits = "0123456789"
                number = ""
                tokens = []
                p = ""
                for c in expression:
                    if c in digits:
                        number += c
                        p = c
                        continue
                    if number:
                        tokens.append(int(number))
                        number = ""
                    if c in "+-*/%()":
                        if p+c in ('//', '**'):
                            c = c+p
                            tokens[-1] = c
                        else:
                            tokens.append(c)
                    elif c != ' ':
                        print(f"'{c}' est invalide")
                        exit()
                    p = c
                if number:
                    tokens.append(int(number))
                if tokens.count('(') != tokens.count(')'):
                    print("Parenthèses non jumelées")
                    exit()
                return tokens
            # Validation de l'arbre.
            def check(node):
                if isinstance(node.value, int):
                    if node.left is not None or node.right is not None:
                        print(f"'{node.value}' opérateur absent")
                        return False
                    else:
                        return True
                elif node.left is None or node.right is None:
                    print(f"'{node.value}' opérand absent")
                    return False
                else:
                    return check(node.left) and check(node.right)
            # Génération de l'arbre.
            def tree(tokens):
                dicPri = {'+': 1, '-': 1, '*': 2, '/': 2, '%': 2, '//': 2, '**': 3}
                base = 0
                root = Node(value='=')
                current = root
                for el in tokens:
                    if el == '(':
                        base += 10
                        continue
                    elif el == ')':
                        base -= 10
                        continue
                    elif el in dicPri.keys():
                        added = Node(value=el, priority=base+dicPri[el])
                    else:
                        added = Node(value=el, priority=base+9)
                    while added.priority < current.priority:
                        current = current.father
                    added.left = current.right
                    if added.left is not None:
                        added.left.father = added
                    current.right = added
                    added.father = current
                    current = added
                if not check(root.right):
                    exit()
                return root
            # Évaluation de l'expression.
            def my_eval(node):
                dicOpe = {'+': add, '-': sub, '*': mul, '/': truediv, '%': mod, '//': floordiv, '**': pow}
                if isinstance(node.value, int):
                    return node.value
                else:
                    return dicOpe[node.value](my_eval(node.left), my_eval(node.right))
            # Code principal.
            expression = input("Entrez une expression")
            tokens = parsing(expression)
            root = tree(tokens)
            print(my_eval(root.right))
            • Partager sur Facebook
            • Partager sur Twitter

            Le Tout est souvent plus grand que la somme de ses parties.

            Algorithme calculatrice

            × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
            • Editeur
            • Markdown