decomposition chaine texte

**CaptainChoc** · 03/08/2006, 02h29

Bonjour,

Voilà je cherche un algo qui avec une chaine de caractere du type :

Code :

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

1
2
 
" Fract(A, B) + Bar(A) + Fract(ABar(B), Bar(A)) "

me donne des objets (car j'utilise un language objet) :

ce qui me donnerai :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
F1 = new Fract(A, B)
T1 = new Texte (" + ")
B1 = new Bar(A)
T2 = new Texte(" + ")
 
t2 = new Texte(A)
b2 = new Bar(B)
b3 = new Bar(A)
F2 = new Fract(t2+b2, b3)
 
liste = [F1, T1, B1, T2, F2]

les "mots clefs" étant : Fract, Bar
le reste est considéré comme du texte

En fait je ne sais meme pas si c'est possible... mais si vous avez des idées ?

merci de votre aide

**CaptainChoc** · 04/08/2006, 01h48

en faite il faudrait que j'arrive a a voir :

[[ 'Fract', 'A', 'B'], ' + ', ['Bar', 'A'], ' + ', ['Fract', ['A', ['Bar', 'B']], ['Bar', 'A']]

ca simplifie peut etre....?

**pop_up** · 04/08/2006, 12h07

tu peux commencer a faire un split avec le caractere '+' pour commencer.
tu obtiendras alors
liste=['Fract(A, B)' , 'Bar(A)' , 'Fract(ABar(B), Bar(A))']

le probleme c'est que je vois pas encore comment tu veux faire la différence entre "ne rien faire si je vois Bar" et "séparer A et Bar quand je vois ABar".

au pire, sois tu connai le nom de la fonction et c'est faisable, soit tu regardes en fonction des majuscules

**borisd** · 04/08/2006, 15h02

[[ 'Fract', 'A', 'B'], ' + ', ['Bar', 'A'], ' + ', ['Fract', ['A', ['Bar', 'B']], ['Bar', 'A']]

En fait, je trouverais ça plus logique de renvoyer

['+',['+',[ 'Fract', 'A', 'B'], ['Bar', 'A']], ['Fract', ['A', ['Bar', 'B']], ['Bar', 'A']]]

comme ça tous les opérateurs sont en notation préfixée.
Tu peux classer tes opérateurs/fonctions par priorité de traitement croissant : d'abord +, puis Fract, Bar et ABar ex aequo.
Ensuite, tu vois la chose récursivement : tu sépares la chaîne selon l'opérateur de priorité la plus faible. Ca te donne un ensemble de chaînes sur lesquelles tu recommences.
Exemple :

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
 
"Fract(A, B) + Bar(A) + Fract(ABar(B), Bar(A))"
Séparation sur le premier '+' --> 2 chaînes : 
 1. "Fract(A,B)"
  Séparation sur '+' : on fait rien, on passe à l'opérateur suivant
  Séparation sur 'Frac' : on renvoie la liste ['Frac' | R], R étant composé de l'analyse des deux chaines en paramètre :
    1.1 'A'
     Séparation  sur '+' : rien à faire
     ... plus d'opérateurs, on a un singleton --> on renvoie l'élément de liste 'A'
    1.2 'B'
     ... on renvoie l'élément de liste 'B'
  1 renvoie : ['Frac','A','B']
 2."Bar(A) + Fract(ABar(B), Bar(A))"
   Séparation sur '+' :
   2.1 "Bar(A)" --> ['Bar','A']
   2.2 "Fract(ABar(B), Bar(A))"
     On renvoie ['Fract' |R] avec R composé de :
     2.2.1 "ABar(B)" --> ['ABar','B']
     2.2.2 "Bar(A)" --> ['Bar','A']

Ce qui te donnes comme algo général :

Code :

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

1
2
3
4
5
6
7
8
 
Analyse(st) : renvoie une liste
  RechercherOpérateurDePrioritéLaPlusFaible(st,op,L)     // L : liste des arguments de op trouvée, longueur variable selon le nombre de paramètres de op
  Si op non trouvé, renvoyer st
  Sinon
    Renvoyer [op,Analyse(L[1]),Analyse(L[2]),...]
  Fin Si
Fin Analyse