Doppelte Zahlen beim Lotto Generator

[g-hun]

Hallo!

Ich habe ein kleines Problem:

Ich versuche in moment ein Lotto Generator zu Programmieren.
Ich habe nix weiteres außer if... then und repeat...until eingesetzt.
Aber irgendwie klappt das nicht und es kommen doppelte Zahlen raus.
Guckt euch das mal an:

Delphi-Quellcode:

....

var zahl:array[1..6] of integer;
    nr1,nr2:integer;
procedure TForm1.Button1Click(Sender: TObject);
begin

  randomize;
  zahl[1]:=random(49)+1;
  zahl[2]:=random(49)+1;
  zahl[3]:=random(49)+1;
  zahl[4]:=random(49)+1;
  zahl[5]:=random(49)+1;
  zahl[6]:=random(49)+1;

  panel1.caption:=inttostr(zahl[1]);
  panel2.caption:=inttostr(zahl[2]);
  panel3.caption:=inttostr(zahl[3]);
  panel4.caption:=inttostr(zahl[4]);
  panel5.caption:=inttostr(zahl[5]);
  panel6.caption:=inttostr(zahl[6]);



    if zahl[1] = zahl[2] or zahl[3] or zahl[4] or zahl[5] or zahl[6] then
      begin
      repeat
      zahl[1]:=random(49)+1;
      panel1.Caption:=inttostr(zahl[1]);
      until zahl[1] <> zahl[2] or zahl[3] or zahl[4] or zahl[5] or zahl[6];
      end;


       if zahl[2] = zahl[1] or zahl[3] or zahl[4] or zahl[5] or zahl[6] then
      begin
      repeat
      zahl[2]:=random(49)+1;
      panel2.Caption:=inttostr(zahl[2]);
      until zahl[2] <> zahl[1] or zahl[3] or zahl[4] or zahl[5] or zahl[6];
      end;

       if zahl[3] = zahl[2] or zahl[1] or zahl[4] or zahl[5] or zahl[6] then
      begin
      repeat
      zahl[3]:=random(49)+1;
      panel3.Caption:=inttostr(zahl[3]);
      until zahl[3] <> zahl[2] or zahl[1] or zahl[4] or zahl[5] or zahl[6];
      end;

       if zahl[4] = zahl[2] or zahl[3] or zahl[1] or zahl[5] or zahl[6] then
      begin
      repeat
      zahl[4]:=random(49)+1;
      panel4.Caption:=inttostr(zahl[4]);
      until zahl[4] <> zahl[2] or zahl[3] or zahl[1] or zahl[5] or zahl[6];
      end;

       if zahl[5] = zahl[2] or zahl[3] or zahl[4] or zahl[1] or zahl[6] then
      begin
      repeat
      zahl[5]:=random(49)+1;
      panel5.Caption:=inttostr(zahl[5]);
      until zahl[5] <> zahl[2] or zahl[3] or zahl[4] or zahl[1] or zahl[6];
      end;

       if zahl[6] = zahl[2] or zahl[3] or zahl[4] or zahl[5] or zahl[1] then
      begin
      repeat
      zahl[6]:=random(49)+1;
      panel6.Caption:=inttostr(zahl[6]);
      until zahl[6] <> zahl[2] or zahl[3] or zahl[4] or zahl[5] or zahl[1];
      end;

[Matze]

Hi,

der Code ist mies *g* Lotto da findest sicher was schöneres. Aber als Übung ok, keine Frage.

Dein Fehler liegt im until Abschnitt, es müsste so in der Art lauten:

Delphi-Quellcode:

until (zahl[1] <> zahl[2]) and (zahl[1] <> zahl[3]) and 
  (zahl[1] <> zahl[4]) and (zahl[1] <> zahl[5]) and (zahl[1] <> zahl[6]);

Nachtrag: Irgendwie müsste es doch and lauten. ^^

[3_of_8]

Wie soll das denn gehen? if zahl[1]=zahl[2] or zahl[3]...

Ich schlage vor du siehst dir nochmal ein paar Anfänger Tutorials an.

Delphi-Quellcode:

procedure GenerateLottoNumbers;
var isdouble: Boolean;
  I, J: Integer;
  zahl: array[1..6] of Integer;
begin;
randomize;
for I:=1 to 6 do
repeat
zahl[I]:=Random(49)+1;
for J:=1 to 6 do
begin
isdouble:=False;
if I<>J then isdouble:=isdouble or (zahl[I]=zahl[J]);
end;
until not isdouble;
for I:=1 to 6 do (findcomponent('Label'+inttostr(I))as TLabel).caption:=
   inttostr(zahl[I]);
end;

[Nikolas]

Hi Solche Blöcke wie

Delphi-Quellcode:

 zahl[1]:=random(49)+1;
zahl[2]:=random(49)+1;
zahl[3]:=random(49)+1;
zahl[4]:=random(49)+1;
zahl[5]:=random(49)+1;
zahl[6]:=random(49)+1;

sollten eher über eine Schleife gemacht werden, also

Delphi-Quellcode:

for i:=1 to 6 do
zahl[i]:= random(49)+1;

Wenn du nicht willst, dass Zahlen doppelt sind, kannst du auch von Anfang an nur die Zahlen benutzen, die noch nicht vorkamen. Du könntest dir z.B. ein Set anlegen, in dem die Zahlen stehen, die schon gezogen wurden, etwa so:

Delphi-Quellcode:

var
list: set of Byte;
begin
list:=[];
for i:=1 to 6 do
begin
  repeat 
  j:= random(49)+1;
  until not j in list;
zahl[i]:=j;
list:= list+[j]; // Das sollte man nicht vergessen... s.u.
end;

end;

Für die Ausgabe wird dir FindComponent helfen, damit ist die Ausgabe auch ein zweizeiler:

Delphi-Quellcode:

for i:=1 to 6 do
fincomponent('Panel'+inttostr(i)).caption:=inttostr(Zahl[i]); // Oder so ähnlich.

[himitsu]

Oder so, wenn er nicht unbeding in 'ner Schleife alles machen will.
Wozu erst setzten, dann prüfen und danach was neues suchen, wenn man gleich passend suchen kann ^^

Delphi-Quellcode:

zahl[1] := random(49) + 1;
repeat
  zahl[2] := random(49) + 1;
until zahl[2] <> zahl[1];
repeat
  zahl[3] := random(49) + 1;
until (zahl[3] <> zahl[1]) and (zahl[3] <> zahl[2]);
repeat
  zahl[4] := random(49) + 1;
until (zahl[4] <> zahl[1]) and (zahl[4] <> zahl[2]) and (zahl[4] <> zahl[3]);
repeat
  zahl[5] := random(49) + 1;
until (zahl[5] <> zahl[1]) and (zahl[5] <> zahl[2]) and (zahl[5] <> zahl[3])
  and (zahl[5] <> zahl[4]);
repeat
  zahl[6] := random(49) + 1;
until (zahl[6] <> zahl[1]) and (zahl[6] <> zahl[2]) and (zahl[6] <> zahl[3])
  and (zahl[6] <> zahl[4]) and (zahl[6] <> zahl[5]);

panel1.caption := IntToStr(zahl[1]); 
panel2.caption := IntToStr(zahl[2]); 
panel3.caption := IntToStr(zahl[3]); 
panel4.caption := IntToStr(zahl[4]); 
panel5.caption := IntToStr(zahl[5]); 
panel6.caption := IntToStr(zahl[6]);

[alcaeus]

Ok, und weil ich so langsam bin, korrigiere ich nur noch den Code von Toxman

Delphi-Quellcode:

procedure GenerateNumbers();
var
  TakenNumbers: set of Byte;
  i: Integer;
  Numbers: array[1..6] of Byte;
begin
  TakenNumbers := [];
  for i := 1 to 6 do
  begin
    repeat
      Number[i] := Random(49)+1;
    until (not (Number[i] in TakenNumbers));
    TakenNumbers := TakenNumbers + [Number[i]];
  end;
end;

Was das sein soll lasse ihc dich ueberlegen. Es kompiliert, ob es funktioniert darfst du testen und es evtl. korrigieren.

@3_of_8: Deine Einrueckung ist ja schrecklich...

Greetz
alcaeus

[Nikolas]

hm. ja, stimmt, das ist ein sinnvoller Einwand. Mir war die Idee wichtig, da hab ich auf Feinheiten wie die Grenze nicht geachtet, aber das neue Setzen der Liste hab ich einfach vergessen.

Zitat:

Oder so, wenn er nicht unbeding in 'ner Schleife alles machen will.

Naja, wenn er aber mal 8 oder 20 solcher Zahlen haben will, wird so eine Lösung recht schnell recht unübersichtlich. Mit einer Schleife dauert die Anpassung 10sec.

[g-hun]

...

[freak4fun]

Es wird nur geschaut, ob die Zahl gleich der Zahl zuvor war, nicht ob sie gleich allen anderen sit.

MfG
freak