Hallo zusammen

Ich sollte in einem Pascal-i aus einem Array:

Code :

1	ARRAY[1..i]

das Maximum berechnen. Weiss jemand, wie das geht?

Gruss kartoffelfre

Versuchs mal mit:

Code :

1	High(Arrayname); //diese Funktion liefert dir die Anzahl der Elemente im Array  zurück

Gruß
Rudolf Grauberger

Hi,

in Delphi ginge das in einem Integer-Array mit MaxIntValue(MeinArray); aus der Unit "Math":

Code :

1	function MaxIntValue(const Data: array of Integer): Integer;

Dadurch erhältst Du bei

Code :

1	Ergebnis := MaxIntValue(MeinArray);

in "Ergebnis" den höchsten Wert, der im Array vorhanden ist.

Edit: Die Länge des Arrays ist bei MaxIntValue egal. Für vorzeichenbehaftete Zahlen nimmt man "MaxValue".

Ich danke euch schonmal für die Antworten, doch wie ich gerade selbst bemerkte, habe ich mich etwas unklar ausgedrückt...

Also...
Ich habe ein Array mit 20 zahlen definiert (zahl[1..20]). Diese habe ich dann in einem nächsten Schritt mit Zufallswerten füllen lassen.
Nun gibt man ein, wie viele Zahlen man "benötigt."
(der Reihe nach: also die ersten i Zahlen.)

Sprich: die zahlen: zahl[1..i]
Nun soll ich aus diesen Zufallswerten den höchsten Wert in einer Variablen speichern lassen.
Ich hoffe, nun ist es verständlich...

Gruss

Meinst du sowas? (Achtung, ist ungetestet)

Code delphi:

1 2 3 4 5 6 7 8

function Hausaufgabe(maxIndex:Integer; const data: array of Integer): Integer; var   i: Integer; begin;   Result := 0;   for i := 0 to maxIndex do     if data[i] > Result then Result := data[i]; end;

Hi,

also, ich habe das jetzt so verstanden: Du hast nach dem Füllen mit Zufallszahlen ein Array, das beispielsweise so aussieht (ich habe jetzt mal nur 6 Zahlen verwendet):

MeinArray[17, 25, 3, 109, 11, 5]

Im nächsten Schritt wird festgelegt, wieviele Zahlen aus dem Array weiterverwendet werden sollen, also z.B. 4 Stück. Im Beispiel wären das also die Zahlen 17, 25, 3 und 109, die noch zu betrachten wären. Nun sollst Du noch bestimmen, welche der 4 Zahlen die höchste ist. Ist das so richtig?

Wenn ja, dann halte Dich an CSANecromancers Code-Beispiel.

Wenn es lediglich darum geht, die höchste Ziffer aus dem kompletten Array herauszufinden, geht das kürzer mit der MaxIntValue-Funktion.

Result := MaxIntValue(MeinArray); würde dann die 109 liefern.

Zitat von darkframe

Hi,

also, ich habe das jetzt so verstanden: Du hast nach dem Füllen mit Zufallszahlen ein Array, das beispielsweise so aussieht (ich habe jetzt mal nur 6 Zahlen verwendet):

MeinArray[17, 25, 3, 109, 11, 5]

Im nächsten Schritt wird festgelegt, wieviele Zahlen aus dem Array weiterverwendet werden sollen, also z.B. 4 Stück. Im Beispiel wären das also die Zahlen 17, 25, 3 und 109, die noch zu betrachten wären. Nun sollst Du noch bestimmen, welche der 4 Zahlen die höchste ist. Ist das so richtig?

Wenn ja, dann halte Dich an CSANecromancers Code-Beispiel.

danke euch... Das ist genau das, was ich suche... Doch leider verstehe ich die Syntax in dem Code nicht ganz... (Habe mit Pascal erst am Mittwoch begonnen - ein Projekt für die Schule...)
Ich denke, am besten ist es, wenn ich euch das Problem und meinen bisherigen Quelltext einfach mal poste... Dann habt ihr einen Überblick über das ganze...

Gruss

Hier ist das Problem:
Ein Jäger soll Tauben schiessen. Er weiss wie viele Tauben an ihm vorbeifliegen werden und er weiss das Gewicht der vorbeigeflogenen Tauben. Nun soll er eine bestimmte Anzahl s Tauben durchfliegen lassen. Das grösste Gewicht merkt er sich und vergleicht mit den nächsten Tauben. Ist eine Taube grösser, nimmt er sie. Sonst vergleicht er mit der nächsten. Ist keine Taube grösser oder gleich gross, so nimmt er die letzte Taube.

Das soll ich nun in einem Pascal-Programm simulieren lassen, für variables s und Anzahl Tauben :=20.


Und hier der Quelltext:

Code :

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

PROGRAM Tauben; USES Crt; VAR tauben: ARRAY [1..20] OF Integer;     i, anzahl, maximum_vorbei, anzahl_durch, maximum_alle: Integer;     zaehler: LongInt;     wahrscheinlichkeit: {Gleitkommazahl}     wahrscheinlichkeit_prozent: {Gleitkommazahl}   BEGIN ClrScr;     Write ('Geben Sie die Anzahl Tauben an, die vorbeifliegen sollen: '); ReadLn (anzahl);   Write ('Geben Sie die Anzahl Durchläufe an: '); ReadLn (anzahl_durch);   zaehler := 0   FOR-Schleife:   Randomize;   i := 1; REPEAT tauben[i] := (Random(100)+1); Inc (i); UNTIL i > 20;     Definiere das Maximum der vorbeigeflogenen Tauben als maximum_vorbei. Definiere das Maximum aller Tauben als maximum_alle     i := maximum_vorbei + 1; WHILE tauben[i] < maximum_vorbei OR i < 20 DO     BEGINN         Inc(i)     END     If tauben[i] = maximum_alle DO     Inc(zaehler)   End FOR-Schleife   wahrscheinlichkeit := anzahl / zaehler wahrscheinlichkeit_prozent := wahrscheinlichkeit * 100   Write ('Die Wahrscheinlichkeit, die grösste Taube zu erwischen beträgt (in %): ') Write (wahrscheinlichkeit_prozent)     ReadKey; END.

Den roten Teil Sollte ich noch machen... Und für die For-Schleife hatte ich noch keine Zeit, kommt aber noch...

Ich hoffe ihr könnt mir helfen, respektive den Code anpassen

Gruss kartoffelfre

Sorry, aber irgendwie komme ich mit deiner Aufgabenstellung nicht so recht klar, bzw. ist mir die zu undeutlich formuliert.
Ok, da sind jetzt insgesamt n Tauben. Von diesen n Tauben sollen s Tauben an einem Jäger vorbei fliegen. Der Jäger weiss von den s vorbei fliegenden Tauben jeweils das Gewicht.
Und welche soll der Jäger jetzt abknallen?
Wenn er schon vorher die Gewichte der Tauben weiss, die an ihm vorbei fliegen werden, dann braucht er doch nur darauf zu warten, dass der dicke Brocken vorbei flattert und drauf halten. Oder verstehe ich das falsch?
Oder was soll der Jäger tatsächlich machen?

Tut mir leid, aber mit Sourcecode kann ich erst dienen, wenn ich verstanden habe, worum es überhaupt geht.

Zitat von CSANecromancer

Sorry, aber irgendwie komme ich mit deiner Aufgabenstellung nicht so recht klar, bzw. ist mir die zu undeutlich formuliert.
Ok, da sind jetzt insgesamt n Tauben. Von diesen n Tauben sollen s Tauben an einem Jäger vorbei fliegen. Der Jäger weiss von den s vorbei fliegenden Tauben jeweils das Gewicht.
Und welche soll der Jäger jetzt abknallen?

Genau... Von den vorbeigeflogenen weiss er das Gewicht. Jetzt hat er von den vorbeigeflogenen das Maximum. Jetzt kann er die s+1. Taube nehmen und sie mit dem Maximum vergleichen. Wenn diese nun grösser oder gleich dem Maximum ist, dann schiesst er diese. Wenn sie kleiner ist als das Maximum der vorbeigeflogenen, vergleicht er mit der s+2. Taube. Und so weiter bis zur n-1. Taube. Wenn diese nun immer noch kleiner ist, als das Maximum der vorbeigeflogenen Tauben, dann nimmt er die n-te Taube.
Ich weiss, das ganze ist ein wenig kompliziert und nicht sehr realitätsnah, doch ich hoffe du weisst jetzt, was ich meine...

Wenn er schon vorher die Gewichte der Tauben weiss, die an ihm vorbei fliegen werden, dann braucht er doch nur darauf zu warten, dass der dicke Brocken vorbei flattert und drauf halten. Oder verstehe ich das falsch?
Oder was soll der Jäger tatsächlich machen?

Tut mir leid, aber mit Sourcecode kann ich erst dienen, wenn ich verstanden habe, worum es überhaupt geht.

Nein, er weiss das Gewicht erst nach dem vorbeifliegen der s Tauben.

Ich danke dir für deine Bemühungen und hoffe, dass es jetzt ein wenig klarer erscheint.

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)


Gruss kartoffelfre

Zitat von kartoffelfre

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.

Zitat von kartoffelfre

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(n): Gesamtanzahl der verfügbaren Tauben
Gewichte(n): 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(n), deswegen brauchen sie nicht explizit initialisiert werden, sondern werden mitinitialisiert, wenn T(n) 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:

Code delphi:

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

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:

Code delphi:

1 2 3 4 5 6 7 8 9

// 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:

Code delphi:

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

// 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.