urgent

Question

programme en c , c'est une sorte de calculatrice 
En fait il faut empiler l'expression completement parenth&#233;s&#233;e dans une pile et le but du programme c'est de nous renvoyer le resultat.
exemple: (((2+4)+(4/2))*3 )devrait me renvoyer 24
Les op&#233;rations sont sur des entiers de 0 &#224; 9 et les op&#233;randes +,-, /, *
Au niveau de l'empilement il n'y a pas de soucis par contre je ne sais pas vraiment comment m'y prendre pour le calcul 
et il faut que je rendre le projet dans une semaine
Si vous avez des tuyaux a me filer ca serait trop cool

neodelphi · Answer

Tu peut essayer d'analyser le premier groupe de parenth&#232;se: tu r&#233;cup&#232;re le contenu, ce qui donne:



((2+4)+(4/2))*3



Tu extrait l'op&#233;rateur (qui ne doit pas &#234;tre entre des parenth&#232;ses),
donc *, puis tu traite la partie gauche et droite. Si une op&#233;rande
n'est pas directement un chiffre, tu refait le traitement pour le
nouveau groupe de parenth&#232;se, puis calcul le r&#233;sultat.



op&#233;rande 2 :

3 (c'est termin&#233; pour l'op&#233;rande 2)



op&#233;rande 1:

((2+4)+(4/2))



calcul de l'op&#233;rande 1:

(2+4)+(4/2)

op&#233;rateur: +

sous-op&#233;rande 1: (2+4)

sous-op&#233;rande 2: (4/2)



ainsi de suite...



A chaque fois qu'une op&#233;rande n'est pas un chiffre, tu descend d'un
niveau... Tu remonde les niveau en calculant les diff&#233;rentes &#233;tapes.

neodelphi

ctx_man · Answer

Pour ma part je pencherai plutot pour une reecriture de l'expression a calculer

Voici un algorythme possible

Debut
   Faire
      Obtenir un groupe minimal
      faire le calcul
      remplacer ce groupe dans l'expression par le resultat du calcul
   Tant qu'il y a des operateurs dans l'expression   
Fin

Les differentes etapes de l'execution de cet algorythme donnerai ceci :
1 : expression = ((2+4)+(4/2))*3
2 : expression = (6+(4/2))*3
3 : expression = (6+2)*3
4 : expression = 8*3
5 : expression = 24 <-plus d'operation a executer, on a donc le resultat

Je pense que cette solution est tr&#232;s simple &#224; mettre en oeuvre et ne devrait te poser aucune difficult&#233;e

Le travail c'est la sant&#233;, ne rien faire c'est la pr&#233;serv&#233; !!!

cs_Joky · Answer

Moi j'ai fais un truc comme &#231;a mais en &#233;criture pr&#233;fix&#233;e, mais bon c'est quasi pareil

Donc pour ma part, je calculer le nombre de parenth&#232;se, je me
positionner &#224; la moiti&#233; et j'effectu&#233; le calcul, et je recommencer avec
2 parenth&#232;ses en moins ;)



Si &#231;a t'int&#233;resse c'est la source Dr Joky, va voir dans mes sources parce que j'ai pas le lien dans la t&#234;te :D



;)

Bonne soir&#233;e ;)
if(!Meilleur("Joky")) return ERREUR;<

cs_Klephte · Answer

Voici ma r&#233;ponse sous forme de fonction r&#233;cursive de 40 lignes.
Je te laisse mettre les commentaires dans le code  
Je pr&#233;cise que je ne fais pas de contr&#244;le du s&#233;quencement des parenth&#232;ses et que je ne g&#232;re pas les priorit&#233;s de calcul des op&#233;rateurs et j'esp&#232;re pour toi que ton prof ne connais pas ce site ....

#include "stdafx.h"

int iPos=0;
int iNewPos=0;

double Calcul(char* szChaine,int iPos){

    double Operande = 0;

    if(szChaine[iPos]=='('){
        iNewPos=0;
        Operande = Calcul(szChaine,++iPos);
        iPos = iNewPos;
    }
    else{
        Operande = szChaine[iPos]-48;
    }

    if(szChaine[iPos+1] == '+'){
        iNewPos=iNewPos+2;
        return Operande+Calcul(szChaine,iPos+2);
    }

    if(szChaine[iPos+1] == '-'){
        iNewPos=iNewPos+2;
        return Operande-Calcul(szChaine,iPos+2);
    }

    if(szChaine[iPos+1] == '*'){
        iNewPos=iNewPos+2;
        return Operande*Calcul(szChaine,iPos+2);
    }

    if(szChaine[iPos+1] == '/'){
        iNewPos=iNewPos+2;
        return Operande/Calcul(szChaine,iPos+2);
    }

    if(szChaine[iPos+1] == '\0' || szChaine[iPos+1] == ')'){
        iNewPos = iPos+1;
        return Operande;
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    //char buffer[]="((((2+4)+(4/2))*3)*2)";
    //char buffer[]="(2+4)+6";
    char buffer[]="(1+3)+6+6+(2*4)";
    //char buffer[]="2+4";

    printf("%f",Calcul(buffer,iPos));

    return 0;
}

Arnaud Grandville

neodelphi · Answer

Au moins on est tous d'accord pour que ce soit une fonction r&#233;cursive !

neodelphi

ctx_man · Answer

Euh, non, pas forc&#233;ment, la r&#233;cursivit&#233;e n'est pas n&#233;c&#233;ssaire dans notre cas. L'algo que j'ai donn&#233; peut tr&#232;s bien se passer de recursivit&#233;.
un "Faire tant que" correspond a une boucle type while ou autre.

Le travail c'est la sant&#233;, ne rien faire c'est la pr&#233;serv&#233; !!!

cs_Klephte · Answer

Je suis tout &#224; fait d'accord
avec toi, il est possible de s'en sortir sans r&#233;cursivit&#233;. Le code sera
d'ailleurs vraisemblablement plus long, mais aussi certainement plus
compr&#233;hensible.

neodelphi · Answer

Oui... Apr&#232;s c'est une question de style. L'embriquement de parenth&#232;se,
indicant l'existence d'une arborescence de groupes, me pousse
naturelement &#224; traiter le probl&#232;me de fa&#231;on r&#233;cursive.



Je pense qu'avec de l'exp&#233;rience, la r&#233;cursivit&#233; est plus facile dans ce genre de probl&#232;me...

neodelphi

Urgent

8 réponses

Votre réponse