uitlezen array

Ik ben voor school een programma aan het schrijven, maar ik ben nu op het volgende probleem gestuit. 

Ik wil de 100 hoogste waardes van een array uitlezen, en deze 100 waardes middelen. Met welk commando kan ik het
array uitlezen zodat ik de 100 hoogste waardes te pakken hebt.

--

Ludo, 

kijk eens naar de 'low' en 'high' functies zoals hieronder in het voorbeeld : 

procedure TForm1.Button1Click(Sender: TObject); 
var 
myarray : array[5..12] of string; 
min, 
max, 
i : integer; 
begin 
for i := 5 to 12 do 
myarray[i] := inttostr(i); 
{Uit de delphi help: 
When applied to an array-type identifier or a variable reference 
of an array type, the Low and High standard functions return 
the low and high bounds of the index type of the array.} 

min := low(myarray); 
max := high(myarray); 
for i := min + 1 to max - 1 do 
showmessage(myarray[i]); 
end; 

Hans 

--

Op mij kwam de vraag iets anders over, het kwam op mij over dat je de hoogste waardes uit een array wil lezen. Bovendien
moet hier het gemiddelde over berekend worden. 

Probeer de volgende code maar eens uit. Start hiervoor een nieuwe applicatie, plaats een TButton en een TMemo op het
formulier en klik tweemaal op Button1. 

De code voor de complete unit is als volgt: 
unit Unit1; 

interface 

uses 
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, 
StdCtrls; 

type 
TForm1 = class(TForm) 
Button1: TButton; 
Memo1: TMemo; 
procedure Button1Click(Sender: TObject); 
private 
{ Private declarations } 
public 
{ Public declarations } 
end; 

var 
Form1: TForm1; 

implementation 

{$R *.DFM} 

type 
TIntArray=Array of Integer; 
TUiterste=(tuLaagste, tuHoogste); 

function VulArray(AantalGetallen: Integer): TIntArray; 
var 
I: Integer; // Iteratie 
begin 
SetLength(Result, AantalGetallen); // Initialisatie 
Randomize; 
for I := Low(Result) to High(Result) do // Vullen 
Result[I]:=Random(1000); 
end; 

function VulUiterstenArray(const Waarden: TIntArray; AantalUitersten: Integer; const Uiterste: TUiterste): TIntArray; 
var 
I, J: Integer; // Iteratie 
WisselWaarde: Integer; // Wordt gebruikt om te wisselen 
WaardenCopy: TIntArray; // Kopie van waarden 
begin 
if AantalUitersten > High(Waarden) then 
AantalUitersten := High(Waarden); // Corrigeer als aantal niet klopt. 
SetLength(Result, AantalUitersten); // Resultaat initialiseren 
SetLength(WaardenCopy, High(Waarden)); 
for I := Low(Waarden) to High(Waarden) do 
WaardenCopy[I]:=Waarden[I]; 
for I := Low(WaardenCopy) to High(WaardenCopy) do // Sorteer waarden in waardencopy 
for J := Low(WaardenCopy) to I-1 do 
if WaardenCopy[J]>WaardenCopy[I] then 
begin 
WisselWaarde:=WaardenCopy[J]; 
WaardenCopy[J]:=WaardenCopy[I]; 
WaardenCopy[I]:=WisselWaarde; 
end; 
case Uiterste of // 
tuLaagste: 
for I := Low(WaardenCopy) to AantalUitersten-1 do 
Result[I]:=WaardenCopy[I]; 
tuHoogste: 
begin 
J:=Low(Result); 
for I := High(WaardenCopy) downto High(WaardenCopy)-AantalUitersten+1 do 
begin 
Result[J]:=WaardenCopy[I]; 
inc(J); 
end; 
end; 
end; 
end; 

function Gemiddelde(const Waarden: TIntArray): Double; 
var 
I: Integer; 
begin 
Result:=0; 
for I := Low(Waarden) to High(Waarden) do 
Result:=Result+Waarden[I]; 
Result:=Result/High(Waarden); 
end; 

procedure TForm1.Button1Click(Sender: TObject); 
var 
A, // Array met random integers 
HV, // Array met 100 hoogste waarden 
LV: TIntArray; // Array met 100 laagste waarden 
GH, // Double met hoogste gemiddelde 
GL: Double; // Double met laagste gemiddelde 
S: String; 
I: Integer; 
begin 
A:=VulArray(1000); 
HV:=VulUiterstenArray(A, 100, tuHoogste); 
LV:=VulUiterstenArray(A, 100, tuLaagste); 
GH:=Gemiddelde(HV); 
GL:=Gemiddelde(LV); 
S:='Waarden:'; 
for I:=Low(A) to High(A) do 
S:=S+IntToStr(A[I])+', '; 
Delete(S, Length(S)-1, 2); 
S:=S+#13#10+'Laagste:'; 
for I:=Low(LV) to High(LV) do 
S:=S+IntToStr(LV[I])+', '; 
Delete(S, Length(S)-1, 2); 
S:=S+#13#10+'Hoogste:'; 
for I:=Low(HV) to High(HV) do 
S:=S+IntToStr(HV[I])+', '; 
Delete(S, Length(S)-1, 2); 
S:=S+#13#10+'Gemiddelde (laag):'+FloatToStr(GL); 
S:=S+#13#10+'Gemiddelde (hoog):'+FloatToStr(GH); 
Memo1.Lines.Text:=S; 
end; 

end. 

Hopelijk kun je er iets mee en breng ik je niet in verwarring. Dit programma doet het volgende: 
1) Vult een array met random integers 
2) Sorteert deze array in een kopie hiervan van laag naar hoog. 
3) Pakt de eerste x waarden (laagste getallen). 
4) Pakt de laatste y waarden (hoogste getallen). 
5) Berekent gemiddelde over laagste waarden. 
6) Berekent gemiddelde over hoogste waarden. 
7) Displayt uitkomst in Memo1 

Veel suc6