Besoin d'aide pour un Algo

**Spinoza23** · 13/02/2007, 15h31

Voila, j'ais un algo a créer pour que cela devienne un programme en java... Le souci c'est que je n'arrive pas a faire l'algo... Je vous montre ce que je dois faire...

L'utilisateur veut faire une addition par exemple... de 15 + 3 + 2 ( =20 j'suis trop fort... )

Voici une expression :

"Addition de [valeur1 ou expression1] avec [valeur2 ou expression2]"

Admetons que l'utilisateur veuille changer la première valeur (entendez ici le contenu des premiers crochets [...] ) , il clique alors sur valeur1, la modifie et met a la place 15. Il valide alors et voici l'expression qui apparait :

"Addition de [15] avec [valeur2 ou expression2]"

Es ce que c'est clair??? Je continue; Il clique donc maintenant sur expression2 car il veut ajouter une autre addition... Il choisi l'expression Addition, valide et voici a quoi ressemble l'expression :

"Addition de [15] avec [Addition de [valeur1 ou expression1] avec [valeur2 ou expression2]]"

Ca devient plus chaud a suivre mais j'espère que vous comprenez...; Il modifie enfin les deux valeurs (valeur1 et valeur2) pour ajouter 2 et 3.... L'expression finale est donc :

"Addition de [15] avec [Addition de [2] avec [3]]"

Et la je vous parle que de l'affichage...donc imaginez un peut le code pour une telle chose...
Il est évident pour moi que ceci va se faire via des Si imbriqués...
Une autre précision : je dois faire cela pour plusieurs expressions...

Addition de [valeur1 ou expression1] avec [valeur2 ou expression2]
Soustraction de [valeur1 ou expression1] avec [valeur2 ou expression2]
Multiplication de [valeur1 ou expression1] avec [valeur2 ou expression2]
Division de [valeur1 ou expression1] avec [valeur2 ou expression2]
Arrondi la [valeur1 ou expression1] sur [valeur2 ou expression2] décimal
Partie entière de [valeur1 ou expression1]
Entier supérieur à [valeur1 ou expression1]
Valeur absolue de [valeur1 ou expression1]
Signe de [valeur1 ou expression1]
Elève [valeur1 ou expression1] à la puissance [valeur2 ou expression2]
Modulo de [valeur1 ou expression1] par [valeur2 ou expression2]
Racine carrée de [valeur1 ou expression1]
Concaténation de [valeur1 ou expression1] avec [valeur2 ou expression2]
Longueur de [valeur1 ou expression1]
Extraction de [valeur1 ou expression1] à partir de [valeur2 ou expression2] sur une longueur de [valeur3 ou expression3]
Position de [valeur1 ou expression1] dans [valeur2 ou expression2]
Suppression des espaces à gauche de [valeur1 ou expression1]
Suppression des espaces à droite de [valeur1 ou expression1]
Conversion en Majuscule de [valeur1 ou expression1]
Conversion en Minuscule de [valeur1 ou expression1]
Conversion en texte de [valeur1 ou expression1] sur une longueur de [valeur2 ou expression2]
Conversion en numérique de [valeur1 ou expression1]
Code ASCII du caractère [valeur1 ou expression1]
Caractère du code ASCII [valeur1 ou expression1]
Si [aleur1 ou expression1] est NULL affiché [valeur2 ou expression2]
Première valeur non NULL dans [valeur1 ou expression1], [valeur2 ou expression2], …..
Dans le cas où [valeur1 ou expression1] est égal à [valeur2 ou expression2] affiché [valeur3 ou expression3] sinon si égal à [valeur4 ou expression4] affiché [valeur5 ou expression5] … sinon affiché [valeur6 ou expression6]
Moyenne de [valeur1 ou expression1]
Somme de [valeur1 ou expression1]
Minimum de [valeur1 ou expression1]
Maximum de [valeur1 ou expression1]
Nombre de valeur de [valeur1 ou expression1]
Nombre de valeur distincte [[U]valeur1 ou expression1]

Et donc etre capable de passer de l'une a l'autre sans problème...

Mon code en java (le début) donne ceci :

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
23
24
25
26
27
28
29
          if ("valeur1".equals(he.getDescription().toLowerCase()))
          {
          /**            Addition de [valeur1 ou expression1] avec [valeur2 ou expression2]**/
              lo_wbuffer.append ("<html><body>");              
              lo_wbuffer.append ("Addition de <b>[</b>"); 
              lo_wbuffer.append ("<a href=\"valeur1\">Valeur1</a>");
              lo_wbuffer.append (" <b>]</b>");
              lo_wbuffer.append ("</body></html>");
              statusBar.setText ("Valeur1");
          }
          else if ("expression1".equals(he.getDescription().toLowerCase()))
          {
              lo_wbuffer.append ("<html><body>");              
              lo_wbuffer.append ("Addition de <b>[</b>"); 
              lo_wbuffer.append ("<a href=\"valeur4\">Valeur4</a>");
              lo_wbuffer.append (" <b>]</b>");
              lo_wbuffer.append ("</body></html>");
              statusBar.setText ("Valeur2");
          }              
          else
          {
              lo_wbuffer.append ("<html><body>");              
              lo_wbuffer.append ("Expression : <b>[</b>"); 
              lo_wbuffer.append ("<a href=\"valeur1\">Valeur1</a>");
              lo_wbuffer.append (" <b>] ou [</b><u> ");
              lo_wbuffer.append ("<a href=\"valeur2\">Valeur2</a></u><b>]</b>"); 
              lo_wbuffer.append ("</body></html>");
              statusBar.setText ("Expression");
          }

Je suis donc bloqué sur mon algo... voila... j'espere avoir été assez clair... Merci d'avance pour votre aide

**reggae** · 13/02/2007, 17h58

C'est plus spécifiqus au langage qu'à l'algorithmique...

En gros, une fois ta chaîne finale obtenue, il te suffira de la diviser en parcelle telle "Addition de" ou "Soustraction", etc.

Tu sauvegarde tout dans un tableau de String. Grâce à la position des éléments dans le tableau, tu pourra prévoir l'imbrication des éléments et les résoudre ainsi plus facilement...

**Spinoza23** · 13/02/2007, 18h00

Ca a l'air assez chaud... tu ne pourrais pas me montrer un exemple? ca m'aiderais beaucoup... Merci

**reggae** · 13/02/2007, 18h48

Malheureusement, mes connaissances Java sont plutôt faibles...

Mais voilà comment je procéderais:
L'affichage à l'écran serait formé de plusieurs chaîne String, de type Opération, Argument et Séparateur(parenthèses et crochets). L'utilisation des classes me semble indiquée.

Ensuite tu peux manipuler tes chaînes en les insérant dans le nombre de String équivalent à celui de tes paranthèses.
Prenons un cas "((3-1)+2)...". Parcours ton String jusqu'à ")". Attention! si tu tombes sur "(" en premier, cela change la donne!

Un fois ta chaîne rognée, il te suffira d'y lire les opérateurs(tu peux utiliser des enum) que tu transformeras donc en signes mathématiques...
Ex: "Addition de" sera remplacé par "+".

Te voici donc avec une chaîne similaire à un vulgaire calcul arithmétique...
Ex: 5*((3+2)-1)

Pour éviter de réinventer la roue, tu files ton String final à un interprêteur qui va te résoudre simplement le calcul... Ca doit certainement être possible en Java...

C'est pas très clair, j'en suis conscient et navré. Mais il m'apparaît comme inévitable de faire déplacer ton post vers le forum Java, car tes ennuis, ainsi que les solutions semblent être plus liés au langage qu'à l'algorithmique.

A++

PS: tu devrais sûrement pouvoir trouver de l'aide ici.

**souviron34** · 14/02/2007, 03h20

euh...

Non moi je ferais pas dépendre ça du langage..

Mais ton algo de base me semble beaucoup trop compliqué... Enfin pas compliqué mais pas générique.

Tu n'as pas assez modélisé (eh oui c'est quelqu'un qui fait du C qui te dit que c'est pas assez orienté objet

)

j'ai déjà fait un truc comme ça...

Attends je le cherche...

OK voilà le principe :

1) tu définis les opérateurs que tu souhaites ( +, -, *, / , &, etc..)
2) tu définis une structure d'opération (forcément uniquement 2 opérandes)
3) dans cette structure tu prévois un ordre, et un type de variable pour chaque opérande
4) tu saisis ou fait saisir l'opération
5) tu analyses la CONCEPTION de l'opération :

tu cherches les opérateurs, tu comptes les parenthèses ouvertes et fermées, donc tu déduis un ordre dans lequel la succession des opérateurs doit se faire, avec quel type d'opérande à chaque fois. Un opérande peut être lui-même une opération.
6) tu exécutes la suite des opérations dans l'ordre :

celles qui ont le plus grand indice d'ordre (le plus grand nombre de parenthèses) en premier
Pour chacune des opérations ET pour chacun des opérandes, tu vérifies si l'opérande est lui-même une opération.
Si oui tu le calcules

7) tu as le résultat

un exemple de structure d'operation :

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
 
#define OPER_ADD  0
#define OPER_SUB  1
#define OPER_MUL  2
#define OPER_DIV  3
 
typedef struct _Mon_Operation {
 
  int               Type ;
  int               Order ;
 
  int               FirstOper ;
  int               SecondOper ;
 
  Mes_Variables    *First ;
  Mes_Variables    *Second ;
 
  Boolean            ResultIsInTempo ;
 
} Mon_Operation ;

Et un exemple de code :

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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
 
/* Exemple de code */
 
      /* For each point does the succession of operations */
 
for ( i = 0 ; i < N_Operations ; i++ )
  {
     if ( Operations[i].Type == OPER_NOP )
       continue ;
 
      /* First checks for real operands */
     IsConstant1 = False ;
     IsConstant2 = False ;
 
  // ici on affecte les variables du premier opérande 
      if ( Operations[i].First != (Mes_Variables *)NULL )
        {
           IsConstant1 = Operations[i].First->IsConstant ;
 
           if ( ! IsConstant1 )
             {
             }
           else
             {
             }
        }
 
  // ici on affecte les variables du second opérande
      if ( Operations[i].Second != (Mes_Variables *)NULL )
        {
           IsConstant2 = Operations[i].Second->IsConstant ;
 
           if ( ! IsConstant2 )
            {
            }
          else
            {
            }
        }
 
 // Et maintenant on fait les vraies opérations
 
      switch ( Operations[i].Type )
        {
 
           case OPER_ADD :
                     // Si type est numérique 
              if ( le_type_de vals_0 est numérique )
                    Result = vals_0 + vals_1 ;
              else
                     // Sinon ajoute 2 chaines par exemple
              break ;
 
           case OPER_SUB :
              Result = vals_0 - vals_1 ;
              break ;
 
           case OPER_DIV :
              Result = vals_0 / vals_1 ;
              break ;
      }