Bonjour,

Çà s'apprend encore le turbo pascal ?

Comment sont définis les polynômes dans ton exercice ? S'agit-il d'une structure comme celle-ci :

Type Poly = array[0..200] of real;

où le tableau contient les coefficients (ici le degré étant limité à 200) ?

Sinon, ta fonction peut retourner plusieurs résultats possibles, non ?

P est représenté par 1 tableau [a0, ... a(2n-1)]

OK, mais, il y a quand même une difficulté car, si on prend p(x)=1+x+x²

Alors on peut choisir p₁(x)=1+x  et p₂(x)=1. Ainsi, on a bien p₁(x)+x²p₂(x)=p(x)
Mais on peut aussi choisir p₁(x)=1+x+2x²  et p₂(x)=-1 et on a encore p₁(x)+x²p₂(x)=p(x).

N'y-a-t'il pas une condition supplémentaire pour permettre de définir les polynômes p₁ et p₂ de façon unique ?

Par ailleurs, dans ton message initial, que signifie n et N ? Je crois me souvenir que, dans turbo pascal, le nom donné aux variables est insensible à la casse ...

je pensais assimiler la procedure decoupe à une simple division euclidienne, mais on me demande juste d'écrire une procédure pour trouver P1 et P2.
N est le degré de P, n l'integer pour incrémenter

OK : s'il s'agit d'une division euclidienne alors, effectivement, il n'y a qu'une seule solution pour P₁ et P₂.

Voici comment je ferais :

Type TPolynomes = Record
                   Degre : integer;           //degré du polynome
                   Coef : array of real;     //tableau "ouvert" des coefficients du polynôme
                  end;

Procedure Decoupe(P : TPolynomes; var P1,P2 : TPolynomes);
var n : integer;
begin
   P1.Degre:=1;
   P1.Coef[0]:=P.Coef[0];
   P1.Coef[1]:=P.Coef[1];
   P2.Degre:=P.Degre-2;
   For n:=2 to P.Degre do P2.Coef[n-2]:=P.Coef[n];
end;

Bon, je n'ai pas essayé, mais ça devrait marcher... sous réserve qu'il ne faille pas utiliser SetLength pour préciser la taille des variables P1 et P2. Je n'utilise plus turbo pascal depuis 12 ans mais Delphi qui est son successeur sous windows. Il est possible que ce qui marche avec Delphi ne fonctionne pas avec turbo pascal

ta boucle c'est prendre le (n-2)e coeff de P2 égal au nième de P. Parce que si c'est ça, je tenterai sous pascal, mais on n'a pas l'habitude d'écrire "P2.Coef(n-2)". Si ça veut dire autre chose, dis le merci

L'écriture P2.Coef[n-2] s'utilise lorsqu'on a une variable de type Record. Dans le type TPolynomes, j'ai mis deux champs : le degré et le tableau Coef. Donc P2.Degre désigne le degré du polynome P2 et P2.Coef[3] représente le coefficient a₃ de ce même polynôme.

Maintenant on peut utiliser d'autres structures si tu n'as pas vu les structures "Record".

Attention aussi de ne pas confondre les parenthèses (qui s'utilisent par exemple pour les arguments des procédures et des fonctions) et les crochets (qui s'utilisent pour les ensembles ou pour les tableaux)...

tu n'aurais pas une autre manière qu'avec record, car je ne l'ai pas vu!

On peut toujours contourner la difficulté en prenant uniquement un tableau. Cependant, comme le degré d'un polynôme est variable, il faut utiliser un tableau sans préciser sa dimension :

Procedure Decoupe(P : array of real; N:integer; var P1,P2 : array of real);
var k : integer;
Begin
   SetLength(P1,2);
   SetLength(P2,N-2);
   P1[0]:=P[0];
   P1[1]:=P[1];
   For k:=2 to N-2 do
      P2[k-2]:=P[k];
End;

Par contre, j'ai un doute sur l'utilisation de SetLength en Turbo Pascal. De même, je ne suis pas certains qu'on puisse utiliser des paramètres tableaux ouverts (sans préciser leur dimension) dans une procédure ...

par contre, expliques moi pourquoi tu poses "P2[k-2] := P [k]" ?

Si j'ai bien compris, le polynôme P, de degré N, doit être découpé en 2 parties :

P1 de degré 1 (fonction affine) contenant les coefficients a₀ et a₁, stockés dans le tableau P aux indices 0 et 1 : P[0] et P[1],
P2 de degré N-2, contenant les coefficients a₂...a_N, stockés dans le tableau P aux indices 2 à N : P[2]...P[N]. Donc l'affectation des coefficients de P2 se fait comme j'ai écrit.

Ainsi, on a bien P(x)=P1(x)+x²P2(x).

Decoupe à partir d'1 polynome P appartenant à R (2n-1)[X], renvoie les polynomes P1 et P2 de R(n-1)[X] définis par P = P1 + X^n * P2. Je ne pense pas que c'est ce que tu as effectué : P1 n'est pas de degré 1, et c'est X^n * P2 : pour l'affectation des coeffs de P2 à partir ce que tu as fait, je vois pas trop

En effet, c'est très différent de ce que j'avais cru comprendre... J'y réfléchirai demain matin.

merci en tout cas!

Bon, en relisant plus attentivement je crois comprendre que :

P(x)=a₀+a₁x+a₂x²+...+a_n-1x^n-1+a_nxⁿ+...+a_2n-1x^2n-1

et on veut écrire :

P(x)=a₀+a₁x+a₂x²+...+a_n-1x^n-1+xⁿ(a_n+a_n+1x+...+a_2n-1x^n-1)

Le problème est aussi simple : il s'agit juste d'un décalage de coefficients :

P est représenté par le tableau [a₀,a₁,...a_n-1,a_n,...a_2n-1]
P1 est représenté par le tableau [a₀,a₁,...a_n-1]
P2 est représenté par le tableau [a_n,a_n+1,...a_2n-1]

Donc la procédure qui convient est la suivante :

Procedure Decoupe(P : array of real; N:integer; var P1,P2 : array of real);
var k : integer;
Begin
   SetLength(P1,N-1);
   SetLength(P2,N-1);
   For k:=0 to N-1 do
   begin
      P1[k]:=P[k];
      P2[k]:=P[n+k];
   end;
End;

Les paramètres P1 et P2 sont transmis par variable et non par valeur (présence du mot-clé var dans la liste des paramètres de la procédure), car il n'est pas possible d'écrire une fonction qui retourne 2 variables ...

Voila : j'espère que c'est mieux comme ça

je comprends beaucoup mieux en effet. par contre, je n'ai pas vu en cours ce qu'est Setlength : tu pêux m'expliquer ce que c'est ?

Je crois bien que setLength n'exsite pas en Turbo Pascal, mais seulement en Delphi. Ça correspond à l'instruction dim des calculatrices lorqu'on veut préciser la dimension d'une liste...

Si ça ne marche pas, alors il faut définir un type Polynome pouvant contenir tout polynôme de degré inférieur ou égal à 200 (par exemple)comme ceci :

Type TPolynome = Array[0..200] of real;

Le degré du polynôme peut être alors calculé en parcourant le tableau à partir de la fin (indice 200) jusqu'à ce qu'un coefficient soit non nul.

Du coup, il faut obligatoirement initialiser tous les coefficients au moment de l'affectation, en complétant au besoin par des coefficients nuls.

L'intérêt de définir un type est de permettre le passage en paramètre de n'import quel polynome.

Du coup la procédure sera différente :

Type TPolynome = array[0..200] of real;

Procedure Decoupe(P : TPolynome; var P1,P2 : TPolynome);
var k,N : integer;
Begin
   k:=200;
   While P[k]<>0 do dec(k);   //recherche du degré de P
   N:=k;
   For k:=0 to N-1 do
   begin
      P1[k]:=P[k];
      P2[k]:=P[n+k];
   end;
   For k:=N to 200 do  // initalisation des coefficients
   begin
      P1[k]:=0;
      P2[k]:=0;
   end;
End;

Maintenant, si je me souviens bien, il faut déclarer l'unité CRT, et rédiger un programme qui fera appel à la procédure decoupe avec un polynôme P donné.

"While P[k]<>0 do dec(k)" : qu'est ce que dec (k) ??

"dec(k)" équivaut à "k:=k-1". "inc(k) équivaut à "k:=k+1". dec et inc sont des fonctions de base en Pascal.