Discussion :

[Fullmetale]

Bonjour,

Je viens vous demander votre aide car, je galère un peu. Etant "débutant" en C, je dois faire une calculatrice qui prend en compte la priorité des parenthèses.

Voici mon ébauche de code (je vous passe juste ma priorité des parenthèses, pas le reste qui est juste les calculs)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int     parenthesis(char *str)
44{
45  int   a;
46  int   b;
47
48  a = 0;
49  b = my_strlen(str);
50  while (str[a] != '\0')
51    {
52      while (str[a] == ')')
53        {
54          a = a -1
55        }
56      while (str[b] != '(' || b < a)
57        {
58          b = b - 1;
59        }
60    }
61}

En gros, je ne sais pas vraiment comment stocker ce qu'il y a entre parenthèse quelque part pour faire le calcul et mettre le résultat de ce calcul à la place des parenthèses.

Merci de votre aide.

[royalxm]

Hey
tu connais les tableaux ou pas ?

si oui stocke-les dans un tableaux ou struct et tu mets un tableau du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
#DEFINE MAX 200
 
struct sauv{
   int sav[MAX];
 
};
 
typedef struct sauv sauve;

sinon bas tableau

EDIT :

Aussi tu fais un int dans ta fonction tu renvois rien, normal ?

et s'il n'y a pas de parenthèses tu fais comment ?


Bon mon idée avec le tableau tu fais comme ça


(10 + (10 + 10))
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
tu va au premier ")" et tu gardes la position de ")" vu que c'est un char la qui est 14

je recule jusqu’au "(" qui est à la position 6 ou 5 je me suis perdu ^^

et la tu crées une fonction qui envoi (10 + 10) qui la calcule puis qui renvoie 20

Essai la fonction atoi mais je pense vu le my je vois quel est ton école donc google chercher comment crée la fonction fais maison

ça envoie le 20 en char conversion aussi une fonction cherche la de char au int et int au char

Après bah tu remplaces hein
(10 + 20)
et tu refais encore un tour


sinon moi je dis tableau, conversion et tu stockes

[Fullmetale]

Bonsoir,

Déjà, merci pour ton aide.

Ensuite, c'est une ébauche de code donc non je ne renvois rien pour l'instant mais tu as raison il faudrait que je renvois.
Ensuite pour un tableau, je sais faire un tableau à double entrée.
Mais par exemple pour copier ce qu'il y a dans les parenthèse autre un my_strncpy fonctionne normalement ?

[royalxm]

Crée une fonction maison ou fais la dans la même fonction
mais vu les limite de ligne vous devais faire préférable une fonction

j'aurais fais ça perso

(10 + (10 + 12))

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
char capture(char *str,int a,int b)
{
 // a la position du premier )
 // b la position du (
  char tmp[5000];
  int i;
  b = b + 1; // le ( on sen fou donc on avance on veux 10 + 12
  i = 0;
 
   while(b != a)
    {
       tmp[i] = str[b];
       b = b + 1;
    }
   calcul(tmp); // normalement tu vas envoyer 10 + 12 bas fonction calculé 
   prend un pointeur du tmp après sera 22
 
 
   return tmp; 
 
 
}

[AASProni]

Je croix q'un algo recursif s'impose!

(10+(11+12))
1-tu dois conaitre la première position d'un prenthese fermant (ici 10)
2-tu connaitre la derniere position d'un parenthese ouvrant dont la position est inferieur à reultat algo 1 (ici 4)
3- faire le calcul entre ces deux positions (donc 11+12 = 23)
4-supprimer les parentheses traités c-à-d position 4 et 10 et tu retourne la concatenantion du reste avec le resultat entre les prenthese (donc il ne reste que "(10+23)")
5-apel recursif de la fonction jusqu'a ce qu'il n'y a plus de parenthese

rq= arret de l'appel recursif: "aucun parenthese fermant detecté"
Un exemple plus long
(10 + (11 + 12)+(13+14))

1er appel recursif du fonction: char* calc=(10 + (11 + 12)+(13+14))

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
algo1: positParentFermant=10
algo2: positParentOuvrant (tel que positParentOuvrant <10) = 4
algo3: calcul 11+12=23
algo4: calc=((10 +23+(13+14)))

2em appel recursif du fonction char*calc=((10+23+(13+14)))

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
algo1: positParentFermant=14
algo2: positParentOuvrant (tel que positParentOuvrant <14) = 8
algo3: calcul 13+14=27
algo4: calc=((10+23+27))

Bon,je ne vais pas tous les faire!

les fonctions que tu doit definir en dehors de la fonction recursif

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
int positParentFermant(char*)// qui retourne l'algo1
int positParentOuvrant(char*,int)// qui retourne l'algo2 avec le reultat de l'algo1 en param
calcul(char*)// pour l'algo 3

bon codage! j'ai donner bcp trop de détail je crois

[AASProni]

@royalxm :

problèmes :
- #DEFINE MAX 200 cela donne une limite si on a un calcul très long
- la définition d'un struct est un peu excessif je crois. on peut l’éviter char* suffit


Pour l’arrêt récursif, je doit faire une petite précision, s'il n'y a plus de parenthèse, exemple 10+13, on retourne tout de suite 10+13

[Fullmetale]

J'ai finalement trouvé une solution, merci de ton aide.

Il me reste à gerer les priorités de calcul, et les calculs infinis, le plus dur !

[Bktero]

Merci de cliquer sur en bas de la page si le problème est clos.