Maximum berechnen

[CSANecromancer]

Ich weiss, das ganze ist ein wenig kompliziert und nicht sehr realitätsnah, doch ich hoffe du weisst jetzt, was ich meine...

Jau, jetzt denke ich, dass ich weiss, was du meinst.

Achja: Das Programm sollte am Schluss als Simulationsprogramm dienen und man sollte dann einen Wert für s kriegen so, dass Man mit der höchsten Wahrscheinlichkeit die grösste aller Tauben erwischt. (Für n=20)

Ich fasse dann mal zusammen, was wir an "Objekten" haben:
J: Jäger
T: Gesamtanzahl der verfügbaren Tauben
Gewichte: Gewichte aller Tauben
T(s): Anzahl der Tauben, die der Jäger vorbeifliegen lässt und die sich der Jäger nur mit verträumten Augen anschaut.
Gewichte(s): Gewichte der vorbeifliegenden Tauben, die der Jäger in Ruhe lässt.
Maximum(s): Das Gewicht der fettesten Taube von T(s).
T(n-s): Anzahl der restlichen Tauben, die nach T(s) am Jäger vorbei fliegen und von diesem u.U. aufs Korn genommen werden.
Gewicht(n-s): Gewichte der Tauben auf der Abschußliste.

T(s) und T(n-s) sind nur Untermengen von T, deswegen brauchen sie nicht explizit initialisiert werden, sondern werden mitinitialisiert, wenn T vorbereitet wird.

beute: Das, was der Jäger bei einer Pirsch tatsächlich erlegt hat.
durchlaeufe: Die Anzahl, wie oft der Jäger auf Pirsch gehen soll.

Die Namen der restlichen Variablen sollten aussagekräftig genug sein.

Dann lege ich mal mit deinem Sourcecode los:

PROGRAM Tauben;
USES Crt;
VAR Gewicht: array [1..20] of Integer;
    i, j, n, s, Maximum_n, Maximum_s, beute, durchlaeufe: Integer;
    Maximum_n_wurde_erwischt: Integer;
    Erfolgschance: double;
    
BEGIN
ClrScr;

// Gesamtzahl der Tauben. Wird hier noch einmal in n abgelegt, damit der 
// Sourcecode gemäß der verwendeten Begriff leichter zu lesen ist. Die 
// 4 Byte Luxus gönne ich mir dann schon.
n := 20;

Write ('Geben Sie die Anzahl Tauben an, die vorbeifliegen sollen: ');
ReadLn (s);

Write ('Geben Sie die Anzahl Durchläufe an: ');
ReadLn (durchlaeufe);

// Tauben füttern
Randomize;

for i := 1 to n
  Gewicht[i] := (Random(100)+1);

Maximum_n_wurde_erwischt := 0;

Ok, jetzt könnte man natürlich das MaxIntValue verwenden, aber wenn du gerade frisch dabei bist, dich mit Delphi/Pascal herumzuschlagen, dann denke ich, ist es etwas sinnvoller, wenn du noch die "basics" ausschreibst, anstatt die fertigen Funktionen zu verwenden, ohne genau zu wissen, was du da eigentlich benutzt:

// Die fetteste aller Tauben ermitteln
Maximum_n := 0;
for i := 1 to n do
  if Gewicht[i] > Maximum_n then Maximum_n := Gewicht[i];

// Und die fetteste der vorbeifliegenden Tauben ermitteln
Maximum_s := 0;
for i := 1 to s do
  if Gewicht[i] > Maximum_s then Maximum_s := Gewicht[i];

So. An dieser Stelle jetzt sind die s Tauben am Jäger vorbei geflogen. Einfach so. Aber er weiss, wieviel die fetteste von ihnen gewogen hat, denn im Programm ist Maximum_s bekannt. Jetzt greift er die Flinte und legt los:

// Die ganz grosse Schleife. So oft muss der Jäger auf die Pirsch.
for j := 1 to durchlaeufe do
begin

  // Bislang hat der Jäger ja noch nichts geschossen
  beute := 0;

  // Nach s alle anderen Tauben vorbeifliegen lassen
  i := (s+1);
  while i <= n do
  begin
    // Wenn die aktuelle Taube die bislang fetteste Beute darstellt, 
    // dann abknallen
    if Gewicht[i] >= Maximum_s then
    begin
      beute := Gewicht[i]

      // Was mir nicht klar ist: Soll der Jäger nur einmal schiessen? 
      // Wenn ja, dann muss jetzt
      // i := n + 1; 
      // kommen. Wenn das fehlt, dann knallt der Jäger alles ab, 
      // was flattert, solange es fetter ist, als alles, was an s 
      // Tauben an ihm vorbeigeflogen ist.
      // Oder sitzt der Jäger jetzt da und wartet auf noch fettere 
      // Beute als die, die er schon hat?
      // Dann muss noch ein
      // Maximum_s := beute; 
      // folgen.
      // Ich gehe mal davon aus, dass er nur eine einzige Taube 
      // umnieten soll, und das auch nur, so lange sie fetter ist, 
      // als alles, was er bei T(s) gesehen hat. Ein Schuß, danach 
      // ist Schicht im Schacht:
      
      // Es wurde Beute gemacht, die Arbeitsschleife kann 
      // verlassen werden.
      i := n + 1;
    end;
  end;

  // Ok, alle Tauben sind jetzt am Jäger vorbei geflogen. Er 
  // schaut in seinen Beutel:
  // Hat er schon was geschossen?
  if beute = 0 then

    // Jetzt verbiegen wir etwas das Zeit-Raum-Kontinuum: 
    // Alle Tauben sind schon vorbei, keine war fetter als das, was 
    // bei T(s) am Jäger vorbeigeflogen ist, er hat nichts im Beutel, 
    // also drehen wir ein bißchen die Zeit zurück und sagen dem 
    // Jäger, dass er in diesem Falle die letzte Taube abknallen soll:
    beute := Gewicht[n];
  
  // Und jetzt noch was für die Wahrscheinlichkeit.
  if beute := Maximum_n then
    Inc(Maximum_n_erwischt);

// Das Ende der Pirsch. Der Jäger ist durchlaeufe mal auf 
// Jagd gegangen.
end;

erfolgschance := ((double)durchlaeufe / (double)Maximum_n_erwischt) * 100;

Write ('Die Wahrscheinlichkeit, die grösste Taube zu erwischen beträgt (in %): ');
Write (erfolgschance);
ReadKey;

END.

Ich hoffe, ich habe keine zu groben Fehler reingehauen, denn derzeit kann ich das Programm nicht prüfen (habe heute Abgabetermin in der Arbeit). Aber ich denke, es wird dir ein bißchen weiterhelfen.