( tiens mais au fait plus personne ne respecte l´habitude de mettre entre parenthèses le type de sujet abordé dans le topic )

Bon alors je vais donner une petite définition d´une structure de donnée un peu formelle mais elle va s´éclairer par la suite :

Soit une structure ( rien a voir avec struct) que je nommerai S définie de la sorte :
( note : il s´agit d´une chaine de caractère)

S = " ("x"op"y")"

( bon c´est un mélange de C pour la concaténation des chaines adjacentes et de n´importe quoi pour l´affectation, mais on s´en fout )

Donc en faite ca se compose de :

" ("
" )"
" op" : un operateur, type +,-,*,/...
x ou y : qui est soit un caractère ( compris entre 0 et 9) soit une autre structure S imbriquée dedans.

On peux ainsi avoi un truc genre :

( 2+(3*5))
ou ( 3*5) est une structure S imbriquée dans une autre.

Ma question, existe-t-il un moyen académique reconnu ou beau pour formatter une chaine de caractère de sorte que :
Le programme accepte en entrée :

" 2+3*5"

et renvoie la chaine :

" (2+(3*5))" ?

( _:(´a ref*´a)->unit=unit ? )

post ton message dans le topic programmation,
tu auras surement + de réponses!

dans les choses parenthésées ou à parentheser, des systemes avec des piles ça marche assez bien en général ; mais je n´ai pas d´algo clef en main à te proposer...

Ouai c´est ce que je comptais faire mais bon, ca me semble un peut bourrin
Faut que j´écrive une fonction propre...

putain, vous faites des trucs bien mieux que chez nous.

n´empêche sur le site de l´inria, parmis les exemple de code pour du caml, il y a si je me souvient bien des trucs dans ce genre, par contre je n´ai pas la moindre idée où, va falloir chercher, mais je croit qu´il donne un interpréteur complet de chaine de ce type.

sinon ça passe par de l´analyse syntaxique, mais c´est assez compliqué.

dnob700 > Ca c´est pour mon TIPE, on en est pas encore aussi loin en cours, mais c´est vrai qu´on rush pas mal ( du coup les 4/5 du groupe info sont là polymorphisme ? )

Et je compte le réaliser en C

ah en C... dans ce cas là, le " plus simple" sans passer par des analyseur syntaxique, c´est d´utiliser des piles.

on en a déjà parler ya quelques temps et j´avais vu une fois une page vraiment géniale qui expliquait comment le faire, malheureusement, pas moyen de la retrouver.

mais l´idée c´est de découper en tronçon de valeurs et d´opérateurs, puis de regarder uniquement les opérateur juste a coté pour voir s´il ont priorité ou non. comme ça en un seul balayyage de ta chaine tu peut la formatter.

Dommage que tu aies paumé ta page
Ouai je pense me tourner vers les piles.

C´est quand même pas mal CAML : au début ca me faisait un peu , mais en fait le fait de considérer chaque ojet comme une entitée mathématique avec pour les fonction les ensembles de départ et d´arrivé ( ce qui donne parfois des trucs en cascade assez bourrin avec la curryfication ) est bien pensé.
Le typage des données automatiques et le phénomène de " template implicites" ( ´a : polymorphisme ) qui en découle est appréciable.
Bon y a quand même quelques bizarrerie ( les références comme variables locales dans les blocs de séquences d´instruction bizarre...)