[Turbo Pascal] Solution d'un exercice

slt amine...
si c'est le probleme en pascal concernant l'unité sur le tableau, voici une unité qui pourra t'aider....
pour la taille du tableau, je me suis arreté a 10, a toi d'augmenter juska 50 ou plus si tu veux.


unit U_Tableau;

Interface

type indice = cardinal;

type tableau = array [ 1 .. 10 ] of cardinal ;

// Lecture du tableau
procedure lireTableau ( out t : tableau ) ;

// Affichage des elements du tableau
procedure afficherTableau ( const t : tableau ) ;

// Retourne l'indice du plus grand element du tableau
// à partir de l'indice k jusqu'a taille du tableau
function indice_du_max ( t : tableau; k : indice ) : indice;

Implementation

// Lecture du tableau
procedure lireTableau ( out t : tableau ) ;
var i : cardinal;
begin
for i := low(t) to high(t) do begin
readln(t[i]);
end;
end;

// Affichage des elements du tableau
procedure afficherTableau ( const t : tableau ) ;
var i : cardinal ;
begin
for i := low(t) to high(t) do begin
write(t[i],' ') ;
end;
writeln;
end;

// Retourne l'indice du plus grand element du tableau
// à partir de l'indice k jusqu'a taille du tableau
function indice_du_max ( t : tableau; k : indice ) : indice;
var ind,i : cardinal;
begin
ind := k;
for i := succ(k) to high(t) do begin
if t[i] > t[ind] then begin
ind := i;
end;
end;
indice_du_max := ind;
end;

End.


et si tu veux tester l'unité, utilise ce bout de code.....
il fait aussi le rangement dans l'ordre decroissant.


program teste_U_Tableau;

uses crt,U_Tableau;

// Procedure qui echange les valeurs de 2 elements
procedure echanger ( var x,y : cardinal );
var z : cardinal;
begin
z := x;
x := y;
y := z;
end;

var tab : tableau;
var i,k,a,b : cardinal;

begin
clrscr;

lireTableau(tab);
writeln('******************');
afficherTableau(tab);
writeln('*************************************');
// Je met juste a partir de l'indice 7 du tableau pour tester
// tu peux changer l'indice, à condition de ne pas depasser ton indice
// max de ton tableau.
writeln('Indice du Max du Tableau = ',indice_du_max(tab,7));

a := low(tab);
b := high(tab);
for k := a to (b-1) do
begin
i := indice_du_max(tab,k);
echanger(tab[k],tab[i]);
end;

writeln('*************************************');
afficherTableau(tab);

end.


en esperant ke ca puisse t'aider....
bon courage.

program neg;
uses wincrt;
type
tab=array[1..60]of integer;
var
n,i,j,k:integer;
t,tp,tn:tab;

procedure saisie_n(var n:integer);
begin
repeat
writeln('donner entier');
readln(n);
until (n>0)and (n<60);
end;

procedure remplir_t(n:integer;var t:tab);
var i:integer;
begin
for i:=1 to n do
begin
writeln('donner entier');
readln(t[i]);
end;
end;
procedure classement(n:integer;t:tab;var tp ,tn:tab);
var i,j,k:integer;
begin
for i:=1 to n do
begin
if t[i]<0 then
begin
for j:=1 to n do
tn[j]:=t[i];
end;
if t[i]>=0 then
begin
for k:=1 to n do
tp[k]:=t[i];
end;
end;
end;
procedure affichage(n:integer;t,tn,tp:tab);
begin
for i:=1 to n do
writeln('le tableau a analyser :'t[i]);
for j:=1 to n do
writeln('le tableau positif est :',tp[j]);
for k:=1 to n do
writeln('le tableau negatif est:',tn[k]);
end;
begin
saisie_n(n);
remplir_t(n,t);
classement(n,t,tp,tn);
affichage(n,t,tp,tn);
end.

****************************************************************************************
essaye le c mieux que rien chui pas sur et je ne l'ai pas encore compilé.bonne chance!
****************************************************************************************

@robinTa procedure classement ne donne pas le résultat voulu...
En fait dans ton algoritme tn=t si t[n]<0 et tp=t si t[n]>=0...
De plus le type de tab est inadapté...

const Nmax=60;

type Tab=record
         a:array[1..Nmax] of integer;
         n:integer;
         end;

procedure Neg(var t,tn,tp:Tab);
var i:integer;
begin
tn.n:=0;
tp.n:=0;
for i:=1 to t.n do
    if t.a[i]<0 then begin
                     tn.a[i]:=t.a[i];
                     inc(tn.n);
                     end
                else begin
                     tp.a[i]:=t.a[i];
                     inc(tp.n);
                     end
end;

Pour le reste il est à noter que remplir_t et affichage sont également fausses

procedure remplir_t(n:integer;var t:tab); // avec TON type tab
var i:integer;
begin
     for i:=1 to n do
         saisie_n(t[i]);
end;

procedure affichage(n:integer;t,tn,tp:tab); // avec TON type tab
var i:integer;
begin
write('le tableau a analyser : ');
for i:=1 to n do
    write(t[i],' ');
writeln('le tableau positif  : ');
for i:=1 to n do
    write(tp[i],' ');
writeln('le tableau negatif  : ');
for i:=1 to n do
    write(tn[i],' ');
end; 

--
La confiance n'exclut pas le contrôle 

la solution d'un programme qui cherche les point selle d''une matrice