Wert aus Array entfernen

[Walgo]

Guten Abend,
[drei Leerzeilen entfernt, Luckie]
ich mache momentan Delphi in Informatik und habe nebenher angefangen ein-zwei eigene Programme zu schreiben.
[drei Leerzeilen entfernt, Luckie]
Darunter war auch die Idee ein "Lotto-Programm" zu schreiben - also 6 aus 49 Möglichkeiten.
[drei Leerzeilen entfernt, Luckie]
Ich habe einen Array "werte" von 0 bis 48 mit den Werten 1-49 Gefüllt.
[drei Leerzeile entfernt, Luckie]
Nun soll nach jeder Ziehung die gezogene Zahl aus diesem Array entfernt werden, damit sie nicht wieder gezogen werden kann.
[drei Leerzeilen entfernt, Luckie]
Ich habe in dieser For Schleife die Zufallszahlenberechnung und das Entfernen des Wertes geschrieben.

Die Fehlerausgabe spricht von einer "Exception der Klasse EAccessViolation" - so wie ich das Verstanden habe bedeutet das "Übergabe eines ungültigen Wertes"

[drei Leerzeielen entfernt, Luckie]
zw = speichert die gezogene Zahl der "jeweiligen Runde".
Zufall= integer array [0..5], in ihm sollen alle gezogenen Zahlen gespeichert werden
p = ist die Schleifenvariable für die While-Schleife

Delphi-Quellcode:

 for i := 0 to 5 do
        begin

            zw:= RandomFrom (werte);
            zufall[i]:= zw;
            p:=0;
           while (p+zw) <> high(werte) do
             begin

               werte[zw+p-1]:=werte[zw+p];
               p:=p+1;
             end;

          SetLength(werte,length(werte)-1);

        end;

[drei Leerzeielen entfernt, Luckie]
Also die For-Schleife liefert 6 Wiederholungen - für 6 Zahlen.
[eine Leerzeielen entfernt, Luckie]
Die While-schleife soll die Array-Werte verschieben, hier ist ein Beispiel, wie ich mir das gedacht habe:
[eine Leerzeielen entfernt, Luckie]

Code:

zw= 6
->
while (0+6) <> 48 do werte(5):=werte(6)
p:=p+1
(die zweite While runde sollte dann so aussehen:
while ( 1+6) <> 48 do werte(6):=werte(7) usw.)

Aber bei dieser Zeile scheint er ein Problem zu bekommen:

Code:

werte[zw+p-1]:=werte[zw+p];

[drei Leerzeielen entfernt, Luckie] Hat jemand von euch eine Idee wo der Fehler liegt, bzw. hat jemand eine Idee wie ich die gezogene Zahl aus dem Array am besten löschen kann?

[drei Leerzeielen entfernt, Luckie]
Würde mich wirklich sehr freuen :D
[drei Leerzeielen entfernt, Luckie]
mfg walgo

[edit=Luckie]Jetzt weiß ich auch, wo meine Leerzeilen geblieben sind. ;) Mfg, Luckie[/edit]

[Nuclear-Ping]

"Access Violation" bedeutet Zugriff auf einen ungültigen Speicherbereich.

Nimm statt einem Array lieber eine TList oder TStringList. Da hast du Methoden wie Add, Delete, usw.

Oder du nimmst ein zweites Array her, was du als "Zwischenspeicher" für die neuen Werte nutzt.

[pilic]

Nimm ein Array of Boolean. Und dann kannst du mit einer while- oder repeat-until-Schleife überprüfen, ob die Zahl noch verfügbar ist oder ob einer neue generiert werden muss.

[marabu]

Herzlich willkommen in der Delphi-PRAXiS, Walgo.

Sobald du eine Zahl aus dem Array mit n Zahlen "gezogen" hast, setzt du die letzte Zahl aus dem Array an diese Stelle und merkst dir, dass du nur noch auf die ersten n-1 Zahlen zugreifen darfst. Entfernen ist nicht nötig, wenn du Random(n-i) als Index für die nächste Zahl, i für die Anzahl der bereits gezogenen Zahlen und n für die Anzahl der Zahlen im Ziehungsvorrat verwendest.

Clever von dir, dass du nebenbei ein Lotto-Programm schreibst. Das ist sonst immer das erste, was im Inofrmatik-Unterricht der Schulen gemacht wird...

Freundliche Grüße vom marabu

[DeddyH]

Du könntest statt eines Arrays auch eine Menge (set of byte) nehmen. Aus einer Menge kann man auch Elemente löschen.

[Macci]

Eine einfache, aber sehr unsaubere Methode wäre diese hier:

Du nimmst einen String (var ziehung:String), der zu Anfang leer ist.
Dann änderst du nach jeder erfolgreichen Ziehung den String wie folgt:

Delphi-Quellcode:

ziehung := ziehung + ',' + IntToStr(gezogene_zahl) + ',';

Jetzt musst du nur noch vor jeder Ziehung schauen, ob die zu ziehene Zahl im String drin ist, und wenn ja, neu ziehen.

Delphi-Quellcode:

 neu_ziehen:
gezogene_zahl := Random(49) + 1;
if pos(','+IntToStr(gezogene_zahl)+',' , ziehung) > 0 then goto neu_ziehen;

PS: Vergiss nicht am Anfang den Aufruf von Randomize

[DeddyH]

Also, ich würde das nach wie vor über eine Menge lösen (lbZiehung ist eine ListBox):

Delphi-Quellcode:

procedure TFrmLotto.FormCreate(Sender: TObject);
begin
  Randomize;
end;

procedure TFrmLotto.btnZiehungClick(Sender: TObject);
var Kugeln: set of byte;
    i, Zufall: byte;
begin
  lbZiehung.Items.BeginUpdate;
  try
    lbZiehung.Items.Clear;
    Kugeln := [1..49];
    for i := 0 to 5 do
      begin
        Zufall := Random(49) + 1;
        while not (Zufall in Kugeln) do
          Zufall := Random(49) + 1;
        Exclude(Kugeln, Zufall);
        lbZiehung.Items.Add(IntToStr(Zufall));
      end;
  finally
    lbZiehung.Items.EndUpdate;
  end;
end;

Allerdings ist die ListBox unsortiert, aber ein bisschen Arbeit soll ja auch noch bleiben, gell? :zwinker:

[edit] Und hier die Version mit einer Fußschleife:

Delphi-Quellcode:

procedure TFrmLotto.FormCreate(Sender: TObject);
begin
  Randomize;
end;

procedure TFrmLotto.btnZiehungClick(Sender: TObject);
var Kugeln: set of byte;
    i, Zufall: byte;
begin
  lbZiehung.Items.BeginUpdate;
  try
    lbZiehung.Items.Clear;
    Kugeln := [1..49];
    for i := 0 to 5 do
      begin
        repeat
          Zufall := Random(49) + 1;
        until Zufall in Kugeln;
        Exclude(Kugeln, Zufall);
        lbZiehung.Items.Add(IntToStr(Zufall));
      end;
  finally
    lbZiehung.Items.EndUpdate;
  end;
end;

@Appolonius: Zur Strafe schreibst Du die nächsten 3 Programme in vi, damit Du weißt, was ich hier durchmache (ich kämpfe hier mehr mit der IDE, als meinen Gedankengang zu Ende zu bringen [/edit]

[Apollonius]

Wann hast du denn Repeat-Until aus deinem Wortschatz gestrichen?

[DeddyH]

Jo, stimmt, das spart eine Zeile. War ja auch nur schnell dahingetippt.

[Walgo]

Guten Morgen :P

Vielen vielen Dank für die zahlreichen Antworten!
(und Entschuldigung für die ganzen Leerzeilen in meinem Post ^^)

Ich werde mir die alternativen zu der Array Version mal genauer ansehen, die scheinen für diesen Fall hier ja um einiges besser geeignet zu sein.

Letzte Frage noch, hat jemand denn eine Idee wo genau der Wurm bei meiner Array Version ist?
Also warum er genau diese Zeile nicht mitmacht?

Code:

werte[zw+p-1]:=werte[zw+p];

nochmal vielen vielen Dank für die Hilfe und das herzliche Willkommen !!!

gruß walgo

[marabu]

Moin,

du möchtest nach der Ziehung einer Zufallszahl die nachfolgenden Zahlen im Vektor werte aufrücken lassen. Die Zuweisungen innerhalb deiner WHILE-Schleife sind in Ordnung, aber die Bedingung im Schleifenkopf stimmt nicht, da musst du noch dran feilen: Zuerst solltest du dir die Position der aktuellen Zufallszahl merken, dann alle nachfolgenden Werte um eins nach vorne verschieben. Wenn du dir die Zufallszahl nicht merkst, dann brauchst du eine Schleife über den ganzen Vektor, in der zuerst die Stelle anhand des Wertes gesucht und ab dort jeder Wert verschoben wird.

In meinem Beitrag #4 habe ich dir einen Ansatz beschrieben, bei dem du auf das mehrfache Verschieben und die Verkürzung des Vorratsvektors und die damit einhergehende Neuzordnung des Speicherbereiches verzichten kannst:

Delphi-Quellcode:

function Ziehung(const Anzahl, Gesamt: Integer): {Types.}TIntegerDynArray;
var
  i, iRandom: integer; 
  Vorrat: TIntegerDynArray;  
begin
  SetLength(Vorrat, Gesamt); // Vorrat dimensionieren
  for i := Low(Vorrat) to High(Vorrat) do 
    Vorrat[i] := Succ(i); // Vektor initialisieren
  SetLength(Result, Anzahl); // Ergebnis dimensionieren
  for i := Low(Result) to High(Result) do
  begin // Soviele Zahlen übernehmen wie nötig
    iRandom := Random(Gesamt - i); // Zufällige Position auswählen
    Result[i] := Vorrat[iRandom]; // Zahl an dieser Position übernehmen
    Vorrat[iRandom] := Vorrat[High(Vorrat) - i]; // Letzte Zahl an diese Position verschieben
  end;
  BubbleSort(Result); // Aufsteigende Sortierung
end;

Freundliche Grüße

[Walgo]

Alles klar,
ich glaube jetzt hab ichs ^^,
danke für die schnelle Antwort :P

gruß walgo

[Walgo]

Also ich bin schonmal einen Schritt weitergekommen.
Ich wollte aber nochmal bei Arrays bleiben - zumindest für heute ^^

marabu - das Problem bei deiner Prozedur ist, dass die Funktion
"RandomFrom()" nur einen Array annimt, etwas wie "(Gesamt - i)" funktioniert leider nicht :-(
So sieht mein "Werte"-Array aus:

Code:

 SetLength(werte,49);
 for i:= 0  to 48 do werte[i]:=i+1;

Nach meiner Vorstellung hat er jetzt die Indexzahlen 0-48, denen die Werte 1-49 zugeteilt sind.

Code:

for i := 0 to 5 do

        begin
            zw:= RandomFrom (werte);           //"berechnen" zuer Zufallszahl
            zufall[i]:= zw;                    //speichern in zw..
            werte[zw-1]:=length(werte);        //ersetzten der gezogenen Zahl (Bsp. 35 -> ich  
                                                 brauche den Index 34) durch die letzte Zahl, also 
                                                 falls es die erste Zahl ist - 49 (Index 48)
            SetLength(werte,length(werte)-1);  // Löschen der letzten Zahl, damit diese nicht 2mal
                                                  im Array vorkommt
        end;

Blöderweise produziert er immernoch einen Fehler, jedoch sehr merkwürdig, beim ersten Starten funktioniert es IMMER, erst, wenn ich mehrere Male die Geschichte laufen lasse produziert er irgentwann eine Exception!!

Ich hab echt keinen Plan warum der immer meckert, vor allem, warum es manchmal klappt und manchmal nicht, kennt das jemand von euch?

grüße walgo

[marabu]

Zitat:

Zitat von Walgo

... marabu - das Problem bei deiner Prozedur ist, dass die Funktion
"RandomFrom()" nur einen Array annimt, etwas wie "(Gesamt - i)" funktioniert leider nicht ...

Deshalb habe ich Random() verwendet und nicht RandomFrom(). Ich will ja den Index und nicht den Wert.

Zitat:

Zitat von Walgo

... Nach meiner Vorstellung hat er jetzt die Indexzahlen 0-48, denen die Werte 1-49 zugeteilt sind. ...

Das ist korrekt.

Zitat:

Zitat von Walgo

... Blöderweise produziert er immernoch einen Fehler, jedoch sehr merkwürdig, beim ersten Starten funktioniert es IMMER, erst, wenn ich mehrere Male die Geschichte laufen lasse produziert er irgentwann eine Exception!!...

Du musst ganz klar unterscheiden zwischen der Position und dem Wert der Zufallszahl. RandomFrom() liefert dir einen Wert und kurz darauf verwendest du den Wert als Basis für einen Index. Das muss früher oder später schief gehen.

[Walgo]

Juhu, ich habs geschafft :P

Bin jetzt endlich fertig, falls es interessieren sollte hier nochmal der entgültige Code:

Code:

for i := 0 to 5 do
  begin
  zw2:= 49 - i;          //Jede "runde" gibt es eine Möglichkeit weniger, deshalb "-i"
  zw:= Random (zw2);     //hier wird nicht der wert, sondern nur der Index
                         //(des "Werte-Arrays") einer Zahl gezogen
  zufall[i]:= werte[zw]; // Aus dem "Werte-Array" wird jetzt die zu dem Index 
                         //gehörende Zahl "herausgeholt"

   werte[zw]:=49-i;      //der gezogene Wert wird durch den "letzten Wert, 
                         //der diese Runde gezogen werden konnte" ersetzt, 
                         //nächste Runde wird i um eins
                         //erhöht und die hier doppelt besetzte Zahl 
                         //ist wieder nur einmal da!
   end;

Vielen Dank nochmal für die tolle Hilfe!

Grüße Walgo