Bonjour à tous,
Je suis étudiant en Maths et j'ai une option informatique où j'ai un projet à faire en Pascal.

Voilà l'intitulé :
L'utilisateur entre un polynôme par exemple : 3*x^5 + 2 * x^4 - 3*x +2
On suppose qu'il entre le polynôme sous la forme (somme des an*x^n) comme ci-dessus donc pas de polynômes type (3*x^2+5)*(2*x-4)

Donc je dois mettre le polynôme dans un arbre (j'ai choisi de mettre pour chaque noeud 2 champs de valeurs (une pour les coefficients une pour l'exposant) et un champ char pour le signe (qui ne pourra etre que '+' car le '-' sera géré dans le champ du coefficient))
On avait le choix sur l'arbre sur la structure.

Ensuite il faut pouvoir réafficher le polynôme trié et mis en forme (pas de signe ^ mais un exposant mis un peu plus en hauteur derrière x) et trié c'est-à-dire que, si l'utilisateur entre 2 + x^2 -3*x, il ressort x²-3x+2.

Je dois ensuite pouvoir évaluer le polynôme pour un x donné.

JVoilà, je n'ai pas l'énoncé sous les yeux, j'oublie sans doute des choses mais voilà les grandes lignes.
J'ai déjà fait la plupart du projet et j'aurais voulu avoir l'avis des plus expérimentés et si il y avait moyen d'alléger mon code.
J'utilise IPCute qui est un logiciel créé par mon prof et qui permet de voir le tas, et donc de voir comment se forme mon arbre.

Merci d'avance.
Voila mon code :
(code édité suite aux remarques des 3 messages suivants)
Code pascal : 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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
program projet;
 
type pnoeud=^noeud;
     noeud=record
     coef:real;   {$V 0:25}
     expo:real;   {$V 25:50}
     op:char;     {$V 50:60}
     g:pnoeud;
     d:pnoeud;
end;
 
function cree(n,e:real;op:char):pnoeud;
begin
new(result);
result^.coef:=n;
result^.expo:=e;
result^.op:=op;
result^.d:=nil;
result^.g:=nil;
end;
 
var s,mot:string; sgn:boolean;
 
{ Cette procédure sert à nettoyer le txt entré par
l'utilisateur (espaces inutiles et signe * oublié, elle prend en charge l'éventuel - en début
de polynôme  géré par un booléen}
 
procedure nettoie;
var i,p:integer;
begin
sgn:=false;
if length(s)=0 then exit;
p:=length(s);
i:=1;
while i<>p do begin                           {on enlève tous les espaces inutiles }
              if s[i]=' ' then begin
                               delete(s,i,1);
                               i:=i-1;
                               p:=p-1
                               end;          
              i:=i+1
              end ;
p:=length(s);
i:=1;
while i<>p+1 do begin                       {on ajoute le signe * si il a été oublié}
              if (s[i]='x') and_then (i>1) then begin
                                                if (s[i-1] in ['0'..'9','.'])
                                                then begin
                                                     insert('*',s,i);
                                                     p:=p+1
                                                     end
                                                end;
              i:=i+1
              end;
 
if s[1]='-' then begin                     {gestion du moins en début d'expression}
                    delete (s,1,1);
                    sgn:=true
                    end
end;
 
{Cette procédure prépare le mot suivant (nombre ou signe) pour la fonction polytotree}
procedure mot_suivant;
begin
if length(s)=0 then mot:=' '
else begin if s[1] in ['0'..'9'] then begin
                                      mot:='';
                                      while (length(s)>0) and_then (s[1] in ['0'..'9','.']) do
                                            begin
                                            mot:=mot+s[1];
                                            delete(s,1,1);
                                            end
                                      end
                                      else begin
                                           if s[1]='-' then begin
                                                            mot:='+';
                                                            sgn:=true;
                                                            end
                                           else mot:=s[1];
                                           delete(s,1,1);
                                           end
 
     end
end;
 
{fonction principale qui met mon polynôme dans un arbre, elle est
composée de la sous fonction termtotree qui met un terme de la forme a*x^n
dans un noeud de la forme coefficient/exposant/champs op vide }
function polytotree:pnoeud;
function termtotree:pnoeud;
var valeur1,valeur2:real;er:integer;
begin
if mot[1] in ['0'..'9'] then begin
                             val(mot,valeur1,er);
                             mot_suivant;
                             if mot='*' then begin
                                             mot_suivant;mot_suivant;
                                             if mot='^' then begin
                                                             mot_suivant;
                                                             val(mot,valeur2,er);
                                                             if sgn=true then begin
                                                                              result:=cree(-valeur1,valeur2,' ');
                                                                              sgn:=false;
                                                                              end
                                                             else result:=cree(valeur1,valeur2,' ');
                                                             mot_suivant;
                                                             end
                                             else if sgn=true then begin
                                                                   result:=cree(-valeur1,1,' ');
                                                                   sgn:=false
                                                                   end
                                                  else result:=cree(valeur1,1,' ');
                                             end
                             else if sgn=true then begin
                                                   result:=cree(-valeur1,0,' ');
                                                   sgn:=false
                                                   end
                                  else result:=cree(valeur1,0,' ');
                             end
else if mot[1]='x' then begin
                        mot_suivant;
                        if mot='^' then begin
                                        mot_suivant;
                                        val(mot,valeur1,er);
                                        if sgn=true then begin
                                                         result:=cree(-1,valeur1,' ');
                                                         sgn:=false
                                                         end
                                        else result:=cree(1,valeur1,' ');
                                        mot_suivant;
                                        end
                        else if sgn=true then begin
                                              result:=cree(-1,1,' ');
                                              sgn:=false
                                              end
                             else result:=cree(1,1,' ');
                        end
else result:=nil
end;
 
var p:pnoeud;
begin
result:=termtotree;
if result=nil then exit;
if mot='+' then begin
                mot_suivant;
                p:=cree(0,0,'+');
                p^.g:=result;
                p^.d:=polytotree;
                if p^.d=nil then begin //gestion erreur
                               //  libere(p);
                                 result:=nil
                                 end
                                 else result:=p;
                end;
end;
 
{programme principal}
var p:pnoeud;
begin
write('Entrez un polynôme : ');readln(s);
nettoie;
writeln('chaîne nettoyée : ',s);
{mot_suivant;
p:=polytotree;}
 
end.