Autor Beitrag
der cherusker
Hält's aus hier
Beiträge: 5



BeitragVerfasst: Mo 03.03.08 18:44 
zuerst möchte ich gleich sagen, dass ich schon einige lösungen zum thema "LOTTO: 6 aus 49" gesucht und gefunden habe. mir geht es darum viele verschiedene lösungen für dieses problem zu finden !

1.) die mit abstand anspruchloseste ist die variante, 6 zahlen zu ziehen, sie zu vergleichen und bei dopplung 6 neue zu ziehen:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
var a,b,c,d,e,f :integer;
begin

edit1.Text:='';
randomize;

repeat
a:=random(49)+1;
b:=random(49)+1;
c:=random(49)+1;
d:=random(49)+1;
e:=random(49)+1;
f:=random(49)+1;

until
(a<>b) and (a<>c) and (a<>d) and (a<>e) and (a<>f) and (b<>c) and (b<>d) and
(b<>e) and (b<>f) and (c<>d) and (c<>e) and (c<>f) and (d<>e) and (d<>f) and (e<>f);

edit1.Text:=edit1.text+'  '+inttostr(a)+'  '+inttostr(b)+'  '+inttostr(c)
                      +'  '+inttostr(d)+'  '+inttostr(e)+'  '+inttostr(f);
end;


2.) deshalb hier eine "normale" lösung:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
var i,a :integer;
begin
edit1.Text:='';
randomize;
 for i:=1 to 49 do
  begin
  kugel[i]:=i;
  end;

 for a:=1 to 6 do
  begin
  repeat
  i:= random (49)+1
  until kugel[i]<>0;
  kugel2[i]:=kugel[i];
  kugel[i]:=0;
  edit1.Text:=edit1.Text+'  '+floattostr(kugel2[i]);
  end;
end;


3.) des weiteren gäbe es noch die lösung mit der doppelten "for-schleife" (die bei mir noch nicht klappt):
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
var i, j :integer;
begin
edit1.Text:='';
randomize;
{zahl[i]:=i;
zahl[j]:=j;}


for i:=1 to 6 do
 begin
 for j:=1 to 6 do
 begin
  if i <> j then
   if zahl[i] = zahl[j] then
   repeat
   zahl[i] := random (49) + 1
   until zahl[i] <> zahl[j];
  end;
 end;
edit1.Text:=edit1.Text+'  '+floattostr(zahl[i]);

end;


4.) und jetzt noch eine eigenkreation:
ausblenden Delphi-Quelltext
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:
var i, n, m, x :integer;
begin

randomize;
edit1.Text:='';
x:=0;

for i:=1 to 49 do
 begin
 kugel[i]:=i;
 end;

while x<1000 do
 begin
 inc(x);
 i:= random(49)+1;
 n:=i;
 i:= random(49)+1;
 m:=i;
 kugel[i]:=n;
 kugel[n]:=m;
 end;

for i:=1 to 6 do
 begin
 edit1.Text:=edit1.Text+'  '+floattostr(kugel[i]);
 end;

end;


meine fragen beziehen sich auf nr 3 + 4. könntet ihr mir bitte sagen
1. wo bei nr 3 der fehler liegt ?
und 2. was ich bei nr 4 falsch gemacht habe - zum besseren verständinss erkläre ich vielleicht meinen ansatz: zuerst werden die zahlen 1-49 per array auf die plätze 1-49 platziert. dann sollen sie gemischt werde, indem immer 2 zahlen getauscht werden, bis sie durcheinander sind. dummerweise entstehen dabei plötzlich doppelte zahlen, da, wenn eine zahl zweimal getauscht wird sie nicht korrekt getauscht wird ... :-(

im voraus schonmal vielen dank für eure tipps !!!
bflegel
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 193
Erhaltene Danke: 1

Win XP, Win 7, BS2000
D5
BeitragVerfasst: Mo 03.03.08 18:58 
Hallo,

beim ersten Überfliegen von Nummer 3 ist mir aufgefallen, dass Du auf zahl[i] zugreifst, zahl[] aber noch nicht definiert und initialisiert hast.

Bei Punkt 4:

Wäre da folgendes nicht besser?

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
 begin
 inc(x);
 n:= random(49)+1;
 m:= random(49)+1;
 i := kugel[n];             //
 kugel[n] := kugel[m];       // somit tauscht Du immer 2 Kugeln gegenseitig aus 
 kugel[m] := i;             //
 end;


bye
bflegel

_________________
I know all the jokes about my name


Zuletzt bearbeitet von bflegel am Mo 03.03.08 19:07, insgesamt 1-mal bearbeitet
der cherusker Threadstarter
Hält's aus hier
Beiträge: 5



BeitragVerfasst: Mo 03.03.08 19:07 
mein fehler ... übergeordnet hatte ich für alle 4 noch folgende variablen angegeben:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
var
  wert: array[1..6] of real;
  kugel: array[1..49] of real;
  kugel2: array[1..49] of real;
  zahl: array[1..6] of real;
bflegel
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 193
Erhaltene Danke: 1

Win XP, Win 7, BS2000
D5
BeitragVerfasst: Mo 03.03.08 19:11 
ok, Du hast die Arrays erstellt, aber noch nicht mit Zahlen gefüllt. Daher dürften dort irgendwelche Zahlen drinstehen, aber nicht unbedingt 1 bis 49.

bye
bflegel

_________________
I know all the jokes about my name
der cherusker Threadstarter
Hält's aus hier
Beiträge: 5



BeitragVerfasst: Mo 03.03.08 19:18 
wenn du dich auf nr 4 beziehst, sind zahlen drin - denn wenn ich das "verschieben" ausklammere {} , kommen die zahlen 1-6 ...
bflegel
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 193
Erhaltene Danke: 1

Win XP, Win 7, BS2000
D5
BeitragVerfasst: Mo 03.03.08 19:23 
Ne, ich meinte Nummer 3. Du vergleichst Zahl[i] mit Zahl[j], aber die sind doch noch gar nicht belegt?!? Bin ich jetzt auf dem Holzweg? Der Code verwirrt mich etwas :wink:

_________________
I know all the jokes about my name
der cherusker Threadstarter
Hält's aus hier
Beiträge: 5



BeitragVerfasst: Mo 03.03.08 19:27 
hmmm - das klingt irgendwie logisch ;-) da hab ich wohl schneller geschrieben, als gedacht ... also müüste wohl noch ne schleife dafor, in der 6 zahlen generiert werden ...
der cherusker Threadstarter
Hält's aus hier
Beiträge: 5



BeitragVerfasst: Di 04.03.08 22:25 
zu nummer 4: das problem ist, das das programm zwar 2 zahlen vertauscht, es aber irgendwie nicht richtig speichert ich gebe euch mal ein beispiel:

zum einfacheren verständnis gibt es nicht 49, sondern nur 8 lottozahlen ;-), also 1,2,3,4,5,6,7,8
vertaucht nun das programm zwei zahlen, zb. 2 und 5 so erhalten wir die reihe 1,5,3,4,2,6,7,8
wird jetzt jedoch zb. 2 und 6 vertauscht, kommt leider folgende reihe heraus: 1,6,3,4,2,2,7,8
irgendwie ist nicht alles, sondern nur oberflächlich gespeichert, dass die zahlen getauscht worden sind ...
Logikmensch
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 390

Win XP
Delphi 2007 Prof., XE2, XE5
BeitragVerfasst: Mi 05.03.08 05:50 
Hallo!

Ich will kein Spaßkiller sein, aber ich habe in diesem Beitrag bereits beschrieben, wie man es einfacher machen kann, um sehr einfach eindeutige Zahlen aus einem beliebigen Bereich herauszubekommen.

_________________
Es gibt keine Probleme - nur Lösungen!
oldmax
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 380


D3 Prof, D4 Prof
BeitragVerfasst: Mi 05.03.08 06:59 
Hi
Wie Logikmensch schon andeutete, es geht einfacher und anspruchsloser, aber hier wird ein Problem angesprochen. Um 2 Zahlen zu tauschen, muss eine Hilfsvariable genommen werden. z. B. setzt du zwei Zeiger auf die Arrayzellen. Dann nimmst du den Wert aus der Zelle, auf den der 1. Zeiger zeigt und speicherst ihn in eine Variable Temp. Anschließend nimst du den Wert aus der Zelle, auf den der zweite Zeiger zeigt und speicherst ihn in der Zellemit dem 1. Zeiger. dann kommt der Wert aus Temp in die 2.Zelle.
Ist nix neues, aber da ist oft der Fehler. Daher mach eine Function mit einem 2-zelligen Record zur Übergabe und Rückgabewert.

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
 Type 

   .....
   
   RZweiZahl   = Record
     Zelle1   : Integer;
     Zelle2   : Integer;
  end;
Function.TMyForm. Tausche(ZweiZahl : RZweizahl):RZweizahl;
Var  Temp: Integer;
Begin
  temp:=ZweiZahl.Zelle1;
  ZweiZahl.Zelle1:=ZweiZahl.Zelle2;
  ZweiZahl.Zelle1:=Temp;
  Result:=Zweizahl;
End;


und in der Aufrufprocedure
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
Var   ZweiZahl  : RZweizahl;// Zweizahl muß auch hier lokal deklariert werden
      Zeiger1   : Integer;
      Zeiger2   : Integer;
      ....
begin
  ...
  Zweizahl.Zahl1:=ZahlenArray[Zeiger1]; 
  Zweizahl.Zahl2:=ZahlenArray[Zeiger2];
  ZweiZahl:=Tausche(ZweiZahl);
  ZahlenArray[Zeiger1]:=Zweizahl.Zahl1;
  ZahlenArray[Zeiger2]:=Zweizahl.Zahl2;
  ....
end;

Warum ich dies schreibe:
Funktionen, die einmal funktionieren tun es in der Regel immer, daher kann man vergessen, wie getauscht wird. Auch wenn es etwas übertrieben aussieht, aber je mehr man sich angewöhnt, auch kleine Functions zu programmieren, je besser ist auch der Durchblick im Programm.
Gruß oldmax

_________________
Zier dich nich so, ich krieg dich schon....
Thaya
Hält's aus hier
Beiträge: 7

Win XP , Vista
ganz bisschen D7
BeitragVerfasst: Mi 05.03.08 15:45 
Hier mal kleiner Vorschlag von mir. Ist recht simpel aber funktioniert. Ausgabe der Zahlen folgt in einem Memo


ausblenden Delphi-Quelltext
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:
  var
    Count, tmp, i, zahlok, j : Integer;
    zahl : array[0..5] of Integer;
begin
  // --- 6 zufällige Zahlen ohne doppelte --------------------------------------
  for i := 0 to 5 do // 0..5 = 6 Zahlen
    repeat
      zahl[i] := random(49)+1; // zufällige Zahl im Bereich von 1..49
      zahlok := 1; // Unterstellung : Zahl ist ok
      for j := 0 to i-1 do // Zahlen vor der aktuellen Zahl untersuchen
        if zahl[i] = zahl[j] then // Zahl doppelt?
          zahlok := 0; // Ja, neue Zahl ausdenken
    until zahlok = 1; // Die Zahl war ok, nächste Zahl
  // --- Sortieren -------------------------------------------------------------
  repeat
    Count := 0; // Bisher keine Zahl getauscht
    for i := 0 to 4 do // alle Zahlen paarweise vergleichen
      if (zahl[i] > zahl[i +1]) then begin // Zahlen in falscher Reihenfolge?
        tmp := zahl[i +1]; // Ja, tauschen
        zahl[i +1] := zahl[i];
        zahl[i] := tmp;
        count := count +1; // Tauschvorgang zählen
      end;
  until (count = 0); // Solange, bis nicht mehr getauscht
  // --- Zahlen ausgeben -------------------------------------------------------
  memo1.Clear;
  for i := 0 to 5 do
    memo1.Lines.Add(IntToStr(zahl[i]));
end;

_________________
Veni vidi vici (Julius Caesar 100 v.Chr. --- 44 v. Chr)


Zuletzt bearbeitet von Thaya am Do 06.03.08 17:20, insgesamt 1-mal bearbeitet
alzaimar
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 2889
Erhaltene Danke: 13

W2000, XP
D6E, BDS2006A, DevExpress
BeitragVerfasst: Mi 05.03.08 16:01 
Ich hab auch noch einen. Zunächst muß aber zum 1000.ten Mal festgehalten werden, das das 'Problem' der Lottoziehung schon abschließend gelöst wurde, und zwar wie der Logikensch schon als ca. 513ter bemerkte, aber egal.

Meine Implementierung zieht aus einem Topf mit zunächst 49 Kugeln nacheinander 6 Kugeln. Die Anzeige erfolgt unsortiert, eben genau wie in Fernsehn, hö. :mrgreen:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
Procedure LottoWieInFernsehn;
Var
  Topf : TStringList;
  i,z : Integer;

Begin
  Topf := TStringlist.Create;
  Try
    For i:=1 to 49 do Topf.Add(IntToStr(i)); // Der Notar hat sich von der GGültigkeit der Kugeln überzeugt.
    For i:=1 to 6 do Begin
      z := Random (Topf.Count);              // wir wählen einfach zufällig eine der verbliebenen Kugeln ...
      Memo1.Lines.add(Topf[z]+' wurde gezogen');                         // zeigen sie in einem Memofeld ...
      Topf.Delete (z);                  // und löschen die Kugel aus dem Topf, da wir sie ja rausgezogen ham
    End;                     // Irgendwie logisch, das diese Kugel / Zahl nun nicht mehr gezogen werden kann.
    
    z := Random (Topf.Count);                                                    // Und die Zusatzzahl lautet
    Memo1.lines.add(Topf[z]+' ist die Zusatzzahl');
  Finally
    Topf.Free;
  End;
End;


Wenn man die Zahlen sortiert ausgegeben haben will, dann schmeißt man die eben vorher in eine zweite TStringList, sortiert dann und danach gehts -ab- ins Memofeld oder sonstewohin.

Alle Lösungen, die blind würfeln und dann nachschauen, ob sie zufällig eine neue Zahl gewürfelt haben, sind ... na ja.

_________________
Na denn, dann. Bis dann, denn.
icho2099
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 101
Erhaltene Danke: 12

WIN XP, WIN 7, WIN 10
Delphi 6 Prof, Delphi 2005, FPC
BeitragVerfasst: Mi 05.03.08 21:27 
und die ca. 514te Lottgeschichte
... nicht würfeln bis man ne neue Kugel hat, sondern würfeln bis man ne kugel hat...
Programm im Anhang

ausblenden volle Höhe Delphi-Quelltext
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:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    SG1: TStringGrid;
    BtnInit: TButton;
    BtnMix: TButton;
    BtnZiehen: TButton;
    TMix: TTimer;
    EDK1: TEdit;
    EDK2: TEdit;
    EDK3: TEdit;
    EDK4: TEdit;
    EDK5: TEdit;
    EDK6: TEdit;
    procedure TMixTimer(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure BtnInitClick(Sender: TObject);
    procedure BtnMixClick(Sender: TObject);
    procedure BtnZiehenClick(Sender: TObject);
    procedure SG1DrawCell(Sender: TObject; ACol, ARow: Integer;
      Rect: TRect; State: TGridDrawState);
  private
    { Private-Deklarationen }


    ARKugeln   : Array[1..49] of Integer;
    ZK         : Integer;

    Procedure InitKugeln;
    Procedure Mischen;
    Procedure Ziehen;
    Procedure ShowKugeln;
  public
    { Public-Deklarationen }

  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}
procedure TForm1.FormCreate(Sender: TObject);
begin
  Randomize;
  InitKugeln;
end;

Procedure TForm1.InitKugeln;
Var i        : Integer;
begin
  ZK := 0;
  EDK1.Text := ''; EDK2.Text := '';
  EDK3.Text := ''; EDK4.Text := '';
  EDK5.Text := ''; EDK6.Text := '';

  For i := 1 to 49 do ARKugeln[i] := i;
end;

Procedure TForm1.ShowKugeln;
Var i    : Integer;
begin
  For i := 1 to 49 do begin
    SG1.Cells[(i-1) MOD 7,(i-1) DIV 7] := IntToStr(ARKugeln[i]);
  end;
  Application.ProcessMessages;
end;

Procedure TForm1.Mischen;
Var i    : Integer;
    p,q  : Integer;
    park : Integer;
begin
  For i := 1 to 1 do begin
    p    := Random(49)+1;
    q    := Random(49)+1;
    park := ARKugeln[p];
    ARKugeln[p] := ARKugeln[q];
    ARKugeln[q] := park;
    ShowKugeln;
  end;
end;

Procedure TForm1.Ziehen;
Var gezogen    : Integer;
    p          : Integer;
begin
  (* Mischen anhalten *)
  TMix.Enabled := False;
  (* noch was zu ziehen ? *)
  If ZK < 6 then begin
    Inc(ZK);
    (* Kugel per Zufall auswählen *)
    Repeat
      p := Random(49) + 1;
      gezogen := ARKugeln[p];
    Until gezogen > 0;
    (* gezogene Kugel rausnehmen *)
    ARKugeln[p] := 0;
    ShowKugeln;
    (* gezogene Kugel anzeigen *)
    Case ZK of
    1 : EDK1.Text := IntToStr(gezogen);
    2 : EDK2.Text := IntToStr(gezogen);
    3 : EDK3.Text := IntToStr(gezogen);
    4 : EDK4.Text := IntToStr(gezogen);
    5 : EDK5.Text := IntToStr(gezogen);
    6 : EDK6.Text := IntToStr(gezogen);
    end;
    If ZK < 6 then begin TMix.Enabled := True; end else
    begin
      TMix.Enabled := False;
      BtnZiehen.Enabled := False;
      BtnMix.Enabled    := False;
      BtnInit.Enabled   := True;
      BtnInit.SetFocus;
    end;
  end;
end;


procedure TForm1.TMixTimer(Sender: TObject);
begin
  Mischen;
end;


procedure TForm1.BtnInitClick(Sender: TObject);
begin
  InitKugeln;
  ShowKugeln;
  BtnMix.Enabled := True;
  BtnMix.SetFocus;
end;

procedure TForm1.BtnMixClick(Sender: TObject);
begin
  TMix.Enabled      := True;
  BtnInit.Enabled   := False;
  BtnMix.Enabled    := False;
  BtnZiehen.Enabled := True;
  BtnZiehen.SetFocus;
end;

procedure TForm1.BtnZiehenClick(Sender: TObject);
begin
  Ziehen;
end;

procedure TForm1.SG1DrawCell(Sender: TObject;
                             ACol, ARow: Integer;
                             Rect: TRect;
                             State: TGridDrawState);
Var i      : Integer;
    w      : Integer;
    Canvas : TCanvas;
    R      : TRect;
    s      : String;
    xm     : Integer;
    ym     : Integer;
    txw    : Integer;
    txh    : Integer;
begin
  (**)
  i := (ARow * 7) + ACol +1;
  w := ARKugeln[i];
  R := Rect;
  R.Left := R.Left + 4; R.Right  := R.Right - 4;
  R.Top  := R.Top  + 4; R.Bottom := R.Bottom -4;
  xm := R.Left + ((R.Right-R.Left) DIV 2);
  ym := R.Top  + ((R.Bottom-R.Top) DIV 2);
  Canvas := (Sender AS TStringGrid).Canvas;
  If w = 0 then Canvas.Brush.Color := clBlack else Canvas.Brush.Color := clLime;
  Canvas.Ellipse(R);
  (* Nummern auf den Kugeln *)
  s := IntToStr(w);
  txw := Canvas.TextWidth(s);
  txh := Canvas.TextHeight(s);

  R.Left   := xm - (txw DIV 2);
  R.Right  := xm + (txw DIV 2);
  R.Top    := ym - (txh DIV 2);
  R.Bottom := ym + (txh DIV 2);
  Canvas.Font.Color := clBlack;
  Canvas.TextRect(R,R.Left,R.Top,s);
end;

end.
Einloggen, um Attachments anzusehen!
Logikmensch
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 390

Win XP
Delphi 2007 Prof., XE2, XE5
BeitragVerfasst: Mi 12.03.08 13:33 
Zitat:
Ich hab auch noch einen. Zunächst muß aber zum 1000.ten Mal festgehalten werden, das das 'Problem' der Lottoziehung schon abschließend gelöst wurde, und zwar wie der Logikensch schon als ca. 513ter bemerkte, aber egal.


Ach, weißt Du, ich bin es gewöhnt, dass manche nicht den ganzen Thread durchlesen oder dass ich ignoriert werde. ;-)

Zitat:
Meine Implementierung zieht aus einem Topf mit zunächst 49 Kugeln nacheinander 6 Kugeln. Die Anzeige erfolgt unsortiert, eben genau wie in Fernsehn, hö.


Dieses Beispiel gefällt auch mir, muss ich sagen. Obwohl sich der Ordnungsbeamte nicht von dem Ordnungsgemäßen Zustand des Ziehungsformulars und der 49 Zahlen in Deinem Topf überzeugt hat. ;-)

Man sollte eben doch nichts dem Zufall überlassen. ;-)

_________________
Es gibt keine Probleme - nur Lösungen!
alzaimar
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 2889
Erhaltene Danke: 13

W2000, XP
D6E, BDS2006A, DevExpress
BeitragVerfasst: Mi 12.03.08 17:10 
user profile iconLogikmensch hat folgendes geschrieben:

Dieses Beispiel gefällt auch mir, muss ich sagen. Obwohl sich der Ordnungsbeamte nicht von dem Ordnungsgemäßen Zustand des Ziehungsformulars und der 49 Zahlen in Deinem Topf überzeugt hat. ;-)

Man sollte eben doch nichts dem Zufall überlassen. ;-)

Stimmt nicht! Meine Routine denkt an Alles!
ausblenden Delphi-Quelltext
1:
For i:=1 to 49 do Topf.Add(IntToStr(i)); // Der Notar hat sich von der Gültigkeit der Kugeln überzeugt.					

_________________
Na denn, dann. Bis dann, denn.