Zufallszahlen erstellen

[LPIG]

Hey,

ich habe mit Hilfe von Random(32) einen Roulette Simulator in Delphi erstellt.
Die eigentliche Auswertung einer Zufallszahl geschieht folgendermaßen:

randomize;
x:=random(32);

Das Interessante, wesswegen ich es auch programmieren wollte ist, dass ich einen Knopf habe, der nach dem Prinzip spielt: Sobald ich verliere, verdoppel ich den Einsatz, wenn ich dann einmal gewinne gehe ich wieder auf den Mindesteinsatz, wobei der Mindesteinsatz 2 Euro ist und der Maximaleinsatz 1000 beträgt. Ich kann einstellen, wieoft er pro Klick drehen und nach dem Prinzip setzen soll.

Das Problem:
Wenn randomize bei Form.create steht bekomme ich bei 100000 Versuchen immer eine negative Gesamtbilanz, das heißt, ich mache Verlust. Wenn ich aber Randomize direkt vor dem Auswürfeln der random Zahl mache, so wie ich es oben stehen habe, dann wird die Gesamtbilanz in jedem Fall negativ.
Ich habe Randomize jetzt zweimal hingeschrieben, bin mir aber unsicher, was es nun bewirkt. Ich bekomme jetzt nämlich immer eine positive Gesamtbilanz und das macht mich schon ein wenig stuzig! :lol:
Bevor ich also ins Casino gehe und mein Geld verzocke:
Wie bekomme ich eine wirklich zufällige Zahlenreihenfolge hin?

Bedanke mich schon im Vorraus! :wink:

lg
LPIG

[Popov]

Random hat immer die gleichen Zufallsazahlen. Jedes mal das gleiche. Randomize holt einen Wett (ich glaube aus der Uhrzeit) und bringt etwas durcheinander.

[Medium]

Zur Frage: Mit einem Stück Hardware, dass den Alpha-Zerfall einer Strahlenquelle misst und in eine Zahl verwurstet.

Zum Problem: Random() erzeugt durchaus ganz okay verteilte Zufallszahlen, jedoch ist wahrscheinlich die Anzahl der Drehs einfach zu gering. Du wirst genau das gleiche Problem auch bei echtem Zufall haben: Für eine 0-Bilanz (nennt man auch bias-Freiheit) müsstest du theoretisch unendlich oft Drehen (und deine Obergrenze entfernen). Da Random() imho eine Periodenlänge von ca. 2^32 hat, müsstest du also nach spätestens rund 4 Mrd. Mal drehen grob bei +/- 0 raus kommen.

Deinem Prinzip fehlt übrigens noch eine Abbruchbedingung: Bei wie viel Gewinn soll aufgehört werden? Das ist bei dieser Strategie nämlich der wichtige Punkt. Spielt man, sobald man mal einen guten Gewinn hat, einfach weiter, so wird man ihn statistisch gesehen auch wieder verzocken. Und durch die Grenze von 1000 limitierst du die Verlust-Auffang-Absicht hinter der Verdopplung nach Verlust auf 9 Mal drehen ohne Gewinn (was 512 sind, da es beim 10. Mal schon 1024 wären). Die Strategie ist folglich nur mit unendlich Kapital verlustfrei spielbar, und auch nur, wenn man es unendlich lange macht. Man verlagert damit also das Glück vom treffen der Zahl auf einen guten Zeitpunkt zum Aufhören, und die Bedingung, dass man von Anfang an steinreich sein muss. Glaub mal, es gäbe sonst keine Casinos mehr.

Ich würde sagen, du hast mit deinem Random einfach viel Pech gehabt, und im Mittel solltest du mit der Strategie mit Limit definitiv Verlust fahren, wenn man nicht bei Gewinn X abbricht. Ob man diesen Gewinnpunkt mit Limit überhaupt erreicht ist dann wieder Glück, und die Wahrscheinlichkeit dürfte sehr genau der entsprechen, mit der man auch bei "normalem" Spielen zu tun hat.

Interessant ist vor allem auch deine Auszahlung bei einer Gewinnrunde. Wenn es einfach 1:1 ist, aber du setzt jeweils eine Zahl aus 32, dann muss man ja fast Verlust fahren! Fazit: Lass die radioaktiven Stoffe weg, und feile besser nochmal an der Strategie ;)

[Popov]

Hier ein Beispiel wie gut oder schlecht Random Zufallswerte produziert. Theoretisch müsste alles schwarz sein, ist aber knapp dran:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  x, y, i, z: Integer;
begin
  z := Width * Height;
  for i := 0 to z do
  begin
    x := Random(Width);
    y := Random(Height);
    Canvas.Pixels[x, y] := clBlack;
  end;
end;

[Medium]

Naja, theoretisch dürfte nicht alles schwarz sein ;) - dann wäre es eine bijektive Funktion. Insofern schon fast zu gut gleichverteilt, aber das ist wohl auch Absicht: Man möchte ja nach möglichst geringer Samplezahl schon möglichst gleichverteilt sein. Bei "echtem" Zufall ist das Universum meist weniger gnädig glaub ich.

[Furtbichler]

Um es anders auszudrücken: Nehmen wir an, eine gute Zufallsfunktion sollte 'alles schwarz machen', weil die Zahlen perfekt verteilt sind. Gleichzeitig soll eine gute Zufallsfunktion gleichverteilte und 'nicht vorhersehbare' Zufallszahlen erzeugen.

So, wie Du dir das vorstellst ('alles schwarz') wäre das bei den letzten paar Pixeln so, das man genau wüsste, welche Zahlen als nächstes kommen (die weißen). Dann wäre aber o.g. Definition des Zufallszahlengenerators nicht erfüllt. Beweis durch Widerspruch: Die Behauptung 'alles schwarz => guter Generator' ist falsch.

[Jonas Shinaniganz]

Die Aufgabe ist als Programmier-Übung geeignet... Allerdings kann ich dir jetzt schon sagen: Was du da machst ist klassischer Martingale.
http://de.wikipedia.org/wiki/Martingalespiel

Aus der Warscheinlichkeitsrechnung: der Erwartungswert bleibt für den Spieler stets negativ.

Du gewinnst eine Einzelne Runde zwar zu: t ≈99,9713 % ABER um einen einzigen "beknackten" Euro zu gewinnen, setzt du teilweise schnell 2048€ oder falls du das Spiel auch verlierst, immernoch um den "Anfangseuro" zurückzugewinnen 4096€ und dann knapp 10.000€ um den Euro erneut "zu versuchen" zu gewinnen.

Die langen Farbfolgen im Roulette die mit unbarmherziger Warscheinlichkeit auftreten werden haben schon alle Zocker, die Ihren Einsatz erhöhen um den Verlust wieder wett zu machen, ruiniert. Das Casino freut sich über Leute die nach "Strategie" spielen. Egal welche "Strategie".

Grüße

[Popov]

Zitat:

Zitat von Furtbichler (Beitrag 1190260)

Die Behauptung 'alles schwarz => guter Generator' ist falsch.

Ich denke der Satz ist missverstanden worden. "Theoretisch müsste alles schwarz sein" bezog sich darauf, dass genau so viele Durchläufe stattgefunden haben wie es Pixel gibt. Nicht drauf ob der Generator jeden der Pixel erwischt hat.

[LPIG]

Vieelen Dank für eure ganzen Antworten! :)
Ich habe bisher noch so gut wie keine Erfahrung mit Programmiersprachen, deshalb verstehe ich leider nicht alles, was ihr sagt. :?

Die Idee war eigentlich, dass man wie im Casino einen Mindest/Maximal-Einsatz festlegen kann und dann 10.000 oder mehr Versuche durchlaufen lassen kann, was dann für die Gewinnerwartung aufschlussreich wäre. Wenn mich meine Logik nicht komplett anschwindelt, dann spielt es in dem Fall auch keine Rolle, ob er diese Versuche in einem durchlaufen lässt ohne jemals abzubrechen.
Was aber unlogisch ist (was ja bei einem Computer nicht sein kann) :

Ohne Randomize:
Bei 10.000 Versuchen bekomme ich einen leichten Gewinn

Randomize bei TForm1.FormCreate
Ebenfalls ca. gleichen leichten Gewinn.

Randomize vor Random(32);
Selbst bei 100.000 Versuchen bin ich bekomme ich unverhältnissmäßig viel Verlust. Ich bin dann meistens schon nach 100 Versuchen bei -2800 oder mehr, was ja tatsächlich kaum sein kann.

Ich würde gerne verstehen, woran das liegt. Im Endeffekt spielt es auch keine Rolle, ob die Zahlen tatsächlich "zufällig" sind, solange ich bei 100.000 Veruschen in Etwas +/- 1000 x 50.000 ungerade bzw. gerade Zahlen dabei habe (Die Null habe ich auch mit berücksichtigt, aber spielt jetzt ja keine Rolle, es ist mir eigentlich egal ob ich Gewinn oder Verlust mache, ich möchte das es korrekt funktioniert. :thumb:).



Rechnerisch sieh Roulette doch folgendermaßen aus:
16/33, dass man gewinnt, 16/33, dass man verliert. 1/33, dass die Null kommt und man 1/2 Chance darauf hat, dass man den Einsatz zurück bekommt.
Das sind im Endeffekt doch 33/66:33/66, oder irre ich? Von daher hat man ja eine Gewinnerwartung von +/- 0, wenn man ohne System spielt. Mit dem System würden sich einige Verluste abfangen lassen, wodurch es logisch wäre, dass ich bei 10.000 Berechnungen einen positiven Schnitt bekomme.
Die Casionos gewinnen also, sobald man dem System untreu wird oder bei anderen Spielvarianten. Vllt. irre ich mich ja aber auch, was ich momentan für ganz wahrscheinlich halte... :roll:

Vielen Dank für eure guten und hilfreichen Erläuterungen bis zu diesem Punkt schonmal. :thumb:

lg
LPIG

[BUG]

Zitat:

Zitat von Jonas Shinaniganz (Beitrag 1190273)

Das Casino freut sich über Leute die nach "Strategie" spielen. Egal welche "Strategie".

Abgesehen vom Kartenzählen :twisted:
EDIT: Ach verdammt ...

[Furtbichler]

Zitat:

Zitat von Popov (Beitrag 1190278)

Zitat:

Zitat von Furtbichler (Beitrag 1190260)

Die Behauptung 'alles schwarz => guter Generator' ist falsch.

Ich denke der Satz ist missverstanden worden. "Theoretisch müsste alles schwarz sein" bezog sich darauf, dass genau so viele Durchläufe stattgefunden haben wie es Pixel gibt. Nicht drauf ob der Generator jeden der Pixel erwischt hat.

Ja. Genau dann wäre es sehr unwahrscheinlich, wenn alles schwarz wäre.
Wenn nämlich "genau so viele Durchläufe stattgefunden haben wie es Pixel gibt" und dann "theoretisch" "alles schwarz" sein müsste, dann hätte "der Generator jeden der Pixel erwischt".
Ach egal.

[shmia]

Die Roulette-Strategie des Verdoppelns bis man gewinnt ist "Quark".
10 Euro gesetzt -> verloren
20 Euro -> verloren
40 Euro -> verloren
80 Euro -> verloren
160 Euro -> gewonnen!!
Verlust: 10+20+40+80=150 Euro Gewinn:160 Euro
Nettogewinn: 10 Euro (also der 1. Einsatz)

Wenn man also max. den 1. Einsatz gewinnen kann, muss man diesen erhöhen denkt sich der "schlaue" Roulettespieler:
1000 -> gewonnen (Hurra)
1000 -> gewonnen (Glücksträhne, schon 2000 im Plus)
1000 -> verloren
2000 -> verloren
4000 -> verloren
8000 -> verloren
16000 ?? Ohoooh - das Geld reicht nicht mehr und schon 13000 verpulvert.
Und jetzt kommen auch noch zwei Rausschmeiser und sagen es wäre jetzt besser wenn man geht.

[LPIG]

Zitat:

Zitat von shmia (Beitrag 1190406)

Die Roulette-Strategie des Verdoppelns bis man gewinnt ist "Quark".
10 Euro gesetzt -> verloren
20 Euro -> verloren
40 Euro -> verloren
80 Euro -> verloren
160 Euro -> gewonnen!!
Verlust: 10+20+40+80=150 Euro Gewinn:160 Euro
Nettogewinn: 10 Euro (also der 1. Einsatz)

Wenn man also max. den 1. Einsatz gewinnen kann, muss man diesen erhöhen denkt sich der "schlaue" Roulettespieler:
1000 -> gewonnen (Hurra)
1000 -> gewonnen (Glücksträhne, schon 2000 im Plus)
1000 -> verloren
2000 -> verloren
4000 -> verloren
8000 -> verloren
16000 ?? Ohoooh - das Geld reicht nicht mehr und schon 13000 verpulvert.
Und jetzt kommen auch noch zwei Rausschmeiser und sagen es wäre jetzt besser wenn man geht.

Das mag ja stimmen, ich möchte das taktische Roulette hier auf keinen Fall verfechten, mir geht es eigentlich nur um die Lösung für mein Problem mit Delphi. (;

lg
LPIG

[shmia]

Zitat:

Zitat von LPIG (Beitrag 1190417)

mir geht es eigentlich nur um die Lösung für mein Problem mit Delphi.

Du hast bislang aber noch keinen Sourcecode gezeigt sondern nur bezüglich randomize herumtheoretisiert.

Delphi-Quellcode:

// liefert den Nettogewinn oder Verlust für eine Spielserie
function PlayRoulette(einsatz, maxeinsatz:Currency):Currency;
var
   win : Boolean;
begin
   Result := 0;

   repeat
      win := random(33) < 16;
      if win then
      begin
         Result := Result + einsatz;
         Exit;
      end;
      Result := Result - einsatz;
      einsatz := einsatz * 2; // verdoppeln...
   until win or (einsatz > maxeinsatz);  // bis zum Gewinn oder bis das Limit überschritten ist
end;

[LPIG]

Hast du auch wieder Recht, hier der Quellcode:

Delphi-Quellcode:

var
  Form1: TForm1;
  x,a,b,c:integer;
  Einsatz : integer;
  Gewinn : integer;
  Zaehler : integer;
  Check:Integer;
  fortschritt:integer;
  //Tabelle : Array[0..10, 0..20] of integer;
  //Anzahl:Integer;
  //Menge:Integer;
implementation

{$R *.DFM}

procedure TForm1.Button1Click(Sender: TObject);
begin
//randomize;
x:=random(32);
lbzufallszahl.caption := inttostr(x);
//rbGerade.checked := true;
c:=c+1;


if x Mod 2 = 0 then   //##################GERADE#####################
begin
  lbAuswertung.caption := 'Es handelt sich um eine GERADE Zahl!';

If rbGerade.checked = true then  //Gewonnen
   begin
   Gewinn := Gewinn + Einsatz;
   lbAuswertung.caption := 'Es handelt sich um eine GERADE Zahl! Sie haben '+inttostr(Einsatz)+' Euro gewonnen';
   end;

If rbUngerade.checked = true then   //Verlooooren
   begin
   lbAuswertung.caption := 'Es handelt sich um eine GERADE Zahl! Sie haben '+inttostr(Einsatz)+' Euro verloren';
   Gewinn := Gewinn - Einsatz;
   end;
end;

If x Mod 2 > 0  then        // ###################UNGERADE################
begin
     lbAuswertung.Caption := 'Es handelt sich um eine UNGERADE Zahl!';

If rbGerade.checked = true then    //Verloooren
   begin
   lbAuswertung.caption := 'Es handelt sich um eine UNGERADE Zahl! Sie haben '+inttostr(Einsatz)+' Euro verloren';
   Gewinn := Gewinn - Einsatz;
   end;

If rbUngerade.checked = true then   //Gewonnen
   begin
   lbAuswertung.caption := 'Es handelt sich um eine UNGERADE Zahl! Sie haben '+inttostr(Einsatz)+' Euro gewonnen';
   Gewinn := Gewinn + Einsatz;
   end;
end;


if x = 0 then    // ##################BANK######################
   begin
   lbAuswertung.caption := 'Die Bank hat gewonnen!';
   Gewinn := Gewinn-Einsatz;  // Es spielt keine Rolle, man hat immer verloren!
   end;
lbGewinn.caption := inttostr(gewinn);
lbVersuche.caption := inttostr(c);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
randomize;
//Anzahl:=0;
//Menge := 0;
Check:=1;
c:=0;
Einsatz := 2;
Gewinn := 0;
end;

procedure TForm1.edEinsatzChange(Sender: TObject);
begin
If edEinsatz.text = '' then
begin
edEinsatz.text := '2';
end;

Einsatz := strtoint(edEinsatz.text);

end;

procedure TForm1.btComputerClick(Sender: TObject);
var
h : integer;

begin
Fortschritt:=strtoint(edVersuche.text);// Damit die Fortschrittsanzeige funktioniert. Die Zahl brauch ich bestimmmt noch.
for check:=1 to strtoint(edVersuche.text) do
begin
Zaehler := strtoint(edVersuche.text);
rbGerade.checked := true;
a := Gewinn;
Button1Click(Sender);  //Wie spielen auf Gerade
ProgressBar1.max := Fortschritt;
ProgressBar1.position := check;

If Gewinn < a then    // Wir haben verloren
   begin
   Einsatz := Einsatz*2;
   b := 2;
   {Anzahl := Anzahl+1;
   if Anzahl > 4 then
   begin
   Tabelle[Anzahl,Menge] := Anzahl;
   end; }
   end;

If (Gewinn > a) and (b = 2) then   //Wir haben gewonnen und davor verloren
   begin
   b:=1;
   Einsatz:=2;
   end;

If Einsatz > 1000 then         //Das Limit ist erreicht
   begin
   Einsatz := Einsatz DIV 2 ;
   end;

edEinsatz.text := inttostr(Einsatz);
if h>=1 then
begin
h:=h-1;
btComputerClick(Sender);
end;
end;
end;


procedure TForm1.btZurueckClick(Sender: TObject);
begin
c:=0;
lbversuche.caption := '';
end;
procedure TForm1.edVersucheChange(Sender: TObject);
begin
If edVersuche.text = '' then
begin
edVersuche.text := '1';
end;
end;

procedure TForm1.btBilanzbackClick(Sender: TObject);
begin
gewinn:=0;
lbgewinn.caption:='';
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
close;
end;

end.

Ist bestimmt etwas umständlicher und so, aber wie gesagt, ich bin blutiger Anfänger! (;

lg
LPIG

[nuclearping]

Zitat:

Zitat von LPIG (Beitrag 1190424)

Ist bestimmt etwas umständlicher und so, aber wie gesagt, ich bin blutiger Anfänger! (;

Ich verstehe nicht, warum "Anfänger" scheinbar immer gleichbedeutend mit "keine Einrückung" ist.

Oder was sollen solche Sachen? Wer soll das lesen, ohne einen Knoten im Hirn zu bekommen? :stupid:

Delphi-Quellcode:

edEinsatz.text := inttostr(Einsatz);
if h>=1 then
begin
h:=h-1;
btComputerClick(Sender);
end;
end;
end;


procedure TForm1.btZurueckClick(Sender: TObject);
begin
c:=0;
lbversuche.caption := '';
end;
procedure TForm1.edVersucheChange(Sender: TObject);
begin
If edVersuche.text = '' then
begin
edVersuche.text := '1';
end;
end;

procedure TForm1.btBilanzbackClick(Sender: TObject);
begin
gewinn:=0;
lbgewinn.caption:='';
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
close;
end;

[p80286]

Zitat:

Zitat von LPIG (Beitrag 1190238)

Ich habe Randomize jetzt zweimal hingeschrieben, bin mir aber unsicher, was es nun bewirkt.

aber vorher warst Du Dir sicher?:twisted:

Zitat:

Zitat von LPIG (Beitrag 1190238)

Wie bekomme ich eine wirklich zufällige Zahlenreihenfolge hin?

Einmal

Delphi-Quellcode:

Randomize

um den Generator zu initialisieren und dann

Delphi-Quellcode:

Random(32)

.

So sollte es funktionieren
Ein Beispiel
und der Eintrag aus der OH:

Zitat:

Randomize initialisiert den integrierten Zufallszahlengenerator mit einem zufälligen Wert (der aus der Systemzeit abgeleitet wird). Der Zufallszahlengenerator sollte initialisiert werden, indem die Prozedur Randomize aufgerufen oder der Variablen RandSeed ein Wert zugewiesen wird.

Kombinieren Sie in einer Schleife nicht den Aufruf von Randomize mit Aufrufen der Funktion Random . Normalerweise wird Randomize vor den Aufrufen von Random nur einmal aufgerufen.

Und wenn Du wissen willst ob da wirklich alles mit rechten Dingen zugegangen ist, dann laß Deinen Generator mal über 1000 Runden laufen, dann solltest Du eine ungefähr gleiche Häufigkeit aller Zahlen haben.
Wikipedia zur Wahrscheinlichkeit

Gruß
K-H

[shmia]

Deine Auswertung ist falsch.
Zuerst muss geprüft werden ob die Bank gewonnen hat.
Erst danach darf man prüfen, ob die Zahl gerade oder ungerade war:

Delphi-Quellcode:

x:=random(33);  // liefert 0 .. 32

if x=0 then
begin
  // Bank gewinnt
end
else if Odd(x) then
begin
  // ungerade Zahl
end
else 
begin
  // gerade Zahl
end;

Man beachte, dass bei der Abfrage immer

Delphi-Quellcode:

else

verwendet wird.

Lnagfristig macht dieses kleine Ungleichgewicht zu Gunsten der Bank einen grossen Unterschied!!

[Medium]

Da würde es dann programmiertechnisch nogar noch interessant die Sperrregel umzusetzen - unmittelbarer Einzug der einfachen Chancen bei 0 wird imho nur in den USA gemacht :)

[Jonas Shinaniganz]

Also nochmal kurz zu deinem Satz:

Zitat:

Rechnerisch sieh Roulette doch folgendermaßen aus:
16/33, dass man gewinnt, 16/33, dass man verliert. 1/33, dass die Null kommt und man 1/2 Chance darauf hat, dass man den Einsatz zurück bekommt.
Das sind im Endeffekt doch 33/66:33/66, oder irre ich? Von daher hat man ja eine Gewinnerwartung von +/- 0, wenn man ohne System spielt. Mit dem System würden sich einige Verluste abfangen lassen, wodurch es logisch wäre, dass ich bei 10.000 Berechnungen einen positiven Schnitt bekomme.
Die Casionos gewinnen also, sobald man dem System untreu wird oder bei anderen Spielvarianten. Vllt. irre ich mich ja aber auch, was ich momentan für ganz wahrscheinlich halte...

...

Martingale Strategie –
vorprogrammierter Totalverlust

Es kommt nicht darauf an, wie hoch die Warscheinlichkeit beim Glücksspiel für den Gewinn einer Runde ist......
Was du rechnest ist total daneben. Dann gibt es noch die Zahll Null, die weder rot noch schwarz ist, bei der du immer verlierst.

Es gibt also 37 Zahlen und bei 19 davon verlierst du.

Die Wahrscheinlichkeit 1 Spiel zu verlieren beträgt: ca 51% = (19 / 37)
Die Wahrscheinlichkeit 10 Spiele in Folge zu verlieren: 0,001275025...% = (19 / 37) ^ 10

Es ist also herrlich unwarscheinlich 10 Spiele in Folge zu verlieren. Weil man ja ein Martingale über 10 Spiele zu 1 - (19 / 37) ^ 10 sprich 0,99872497479...% gewinnt.

Leider bringt dir diese hohe Gewinnrate nichts, weil es um den Erwartungswert geht. Du vernachlässigst, dass du dein Einsatz exponentiel erhöhst um weiterspielen zu könnten.

Angenommen du spielst dein Martingale "nach dem System so gut wie möglich", das heißt: Möglichst geringen Starteinsatz, damit du möglichst oft verdoppeln kannst. In der Realität haben Casions einen maximal zugelassenen Betrag pro Feld. Angenommen dieser liegt bei 2000€, dann kannst du bei einem Starteinsatz von 1€ genau 10 mal verdoppeln (1024€, die nächste Verdopplung wäre unzulässig), bis du gegen dein System verstoßen musst, weil die Regeln kein Verdoppeln mehr erlauben.


Mathematisch bedeutet das:
(Gewinnwarscheinlihckeit * Einsatz) - (Verlustwarscheinlichkeit * Verlust) = Erwartungswert

0,99872497479...% * 1€ Einsatz - 0,001275025...% * 1024€ Verlust = 99,9023% - 1 = -0,30690062521 €

Das sind ca 31% von deinem Starteinsatz, die du pro Serie verlierst.

Also setz dich gemütlich an den Roulette Tisch und verzocke pro 12 Spiele brav deine 30 Cent und alle sind Glücklich.

Da gibt es allerdings einige Spiele die du länger Spielen kannst mit deinem Geld...

Das Spiel stellt sich dann so dar, dass du oft sehr kleine Gewinne einfährst und dann schlagartig alles verlierst.

Wenn das Casino noch besser für dein "System" ist kannst du vielleicht schon bei 10 Cent starten und vielleicht 16 mal verdoppeln... Aber wie du dir ausrechnen kannst, bleibt dein zu erwartender Gewinn stets negativ.

Ich hoffe du schreibst jetzt nicht nochmal so einen Unsinn...

Falls du jedoch nach deinen eigenen Kalkulationen zu einem anderen Ergebniss kommen solltest, sags mir auf jeden Fall, ich stelle dann den Casinotisch und mache dir die Bank.

Grüße

Edit: In dem Zusammenhang könnte man auch kurz noch den http://de.wikipedia.org/wiki/Bankvorteil erwähnen.

[LPIG]

Hallo,


Die Auswertung war tatsächlich fehlerhaft. Wurde zusammen mit dem Einrücken verbessert. :wink:


Hier das verbesserte Programm:

Delphi-Quellcode:

var
  Form1: TForm1;
  x,a,b,c:integer;
  Einsatz : integer;
  Gewinn : integer;
  Zaehler : integer;
  Check:Integer;
  fortschritt:integer;
  i:integer;
  //Tabelle : Array[0..10, 0..20] of integer;
  //Anzahl:Integer;
  //Menge:Integer;
implementation

{$R *.DFM}

procedure TForm1.Button1Click(Sender: TObject);
begin
x:=random(37);
lbzufallszahl.caption := inttostr(x);
//rbGerade.checked := true;
c:=c+1;

if x = 0 then    // ##################BANK######################
   begin
   lbAuswertung.caption := 'Die Bank hat gewonnen!';
   i:=Random(2);
   if i = 0 then
   begin
        Gewinn := Gewinn-Einsatz;
   end
   else
   if i = 1 then
    begin
        Gewinn := Gewinn + Einsatz;
     end;

   end
else

if x Mod 2 = 0 then   //##################GERADE#####################
begin
  lbAuswertung.caption := 'Es handelt sich um eine GERADE Zahl!';

If rbGerade.checked = true then  //Gewonnen
   begin
        Gewinn := Gewinn + Einsatz;
        lbAuswertung.caption := 'Es handelt sich um eine GERADE Zahl! Sie haben '+inttostr(Einsatz)+' Euro gewonnen';
   end;

If rbUngerade.checked = true then   //Verlooooren
   begin
         lbAuswertung.caption := 'Es handelt sich um eine GERADE Zahl! Sie haben '+inttostr(Einsatz)+' Euro verloren';
          Gewinn := Gewinn - Einsatz;
   end;
end
else

If x Mod 2 > 0  then        // ###################UNGERADE################
begin
     lbAuswertung.Caption := 'Es handelt sich um eine UNGERADE Zahl!';

If rbGerade.checked = true then    //Verloooren
   begin
        lbAuswertung.caption := 'Es handelt sich um eine UNGERADE Zahl! Sie haben '+inttostr(Einsatz)+' Euro verloren';
        Gewinn := Gewinn - Einsatz;
   end;

If rbUngerade.checked = true then   //Gewonnen
   begin
        lbAuswertung.caption := 'Es handelt sich um eine UNGERADE Zahl! Sie haben '+inttostr(Einsatz)+' Euro gewonnen';
        Gewinn := Gewinn + Einsatz;
   end;
end;
lbGewinn.caption := inttostr(gewinn);
lbVersuche.caption := inttostr(c);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
randomize;
//Anzahl:=0;
//Menge := 0;
Check:=1;
c:=0;
Einsatz := 2;
Gewinn := 0;
end;

procedure TForm1.edEinsatzChange(Sender: TObject);
begin
If edEinsatz.text = '' then
begin
edEinsatz.text := '2';
end;

Einsatz := strtoint(edEinsatz.text);

end;

procedure TForm1.btComputerClick(Sender: TObject);
var
h : integer;

begin
Fortschritt:=strtoint(edVersuche.text);// Damit die Fortschrittsanzeige funktioniert. Die Zahl brauch ich bestimmmt noch.
for check:=1 to strtoint(edVersuche.text) do
begin
Zaehler := strtoint(edVersuche.text);
rbGerade.checked := true;
a := Gewinn;
Button1Click(Sender);
ProgressBar1.max := Fortschritt;
ProgressBar1.position := check;

If Gewinn < a then    // Wir haben verloren
   begin
   Einsatz := Einsatz*2;
   b := 2;
   {Anzahl := Anzahl+1;
   if Anzahl > 4 then
   begin
   Tabelle[Anzahl,Menge] := Anzahl;
   end; }
   end;

If (Gewinn > a) and (b = 2) then   //Wir haben gewonnen und davor verloren
   begin
   b:=1;
   Einsatz:=2;
   end;

If Einsatz > 1000 then         //Das Limit ist erreicht
   begin
   Einsatz := Einsatz DIV 2 ;
   end;

edEinsatz.text := inttostr(Einsatz);
               if h>=1 then
               begin
                    h:=h-1;
                    btComputerClick(Sender);
               end;
end;
end;


procedure TForm1.btZurueckClick(Sender: TObject);
begin
c:=0;
lbversuche.caption := '';
end;


procedure TForm1.edVersucheChange(Sender: TObject);
          begin
               If edVersuche.text = '' then
          begin
          edVersuche.text := '1';
end;
end;

    procedure TForm1.btBilanzbackClick(Sender: TObject);
    begin
         gewinn:=0;
         lbgewinn.caption:='';
    end;

procedure TForm1.Button2Click(Sender: TObject);
begin
     close;
end;

end.

Falls ihr noch weitere Fehler findet, immer nur her damit. (:
Ansonsten sollte das Programm jetzt ein Roulette Spiel simulieren, indem der Minimaleinsatz bei 2 Euro liegt und der Maximaleinsatz bei 1000, wodurch es möglich ist, den Einsatz 9x zu verdoppeln. Bei einer 0 wird erneut gedreht und die Chance steht 50:50, dass man den Einsatz zurück erhält.

Das bringt mich erneut zu meinem "Unsinn":

Zitat:

Die Wahrscheinlichkeit 1 Spiel zu verlieren beträgt: ca 51% = (19 / 37)
Die Wahrscheinlichkeit 10 Spiele in Folge zu verlieren: 0,001275025...% = (19 / 37) ^ 10

Bei den Bedingungen nach denen wir oben gehen, merkst du glaube ich selbst, wer da Unsinn geschrieben hat. Außerdem habe ich schon mindestens einmal geschrieben, dass ich die Theorie weder verteidigen möchte noch denke, dass es ein Casino gibt, in dem sowas klappen würde. Desweiteren war meine Brechnung als Frage formuliert, weil ich mir wie gesagt nicht sicher war.

Die Wahrscheinlichkeit 1 Spiel zu verlireten beträgt: exakt 50%
Die Wahrscheinlichkeit 9 Spiele zu verlieren beträgt: (1 / 2)^9 = 0,001953125%

(0,998046875 * 2) - (0,001953125% * 1022) = 1,97613281

Falls ich mich nicht irre haben wir also nach den obrigen Bedingungen eine positive Gewinnerwartung. Das es kein Casino gibt, in dem man nach genau den Bedingungen spielen kann, mag stimmen.


Bei 32.000 Durchläufen mit meinem Programm bekomme ich auch eine positive Zahl raus.
Vielen Dank für die vielen Verbesserungen und Anregungen. :thumb:

lg
LPIG

Edit:
bei 10.000.000 Versuchen bekomme ich -80.000 Euro, irgendwo muss ich was falsch gemacht haben.

[OmaH]

Ich möchte doch meinen Senf noch dazugeben. Ihr vergesst nähmlich das Zufall, Wahrscheinlichkeit und Computerprogramme 3 paar Schuhe sind. Ein C.P. kann Wahrscheinlichkeiten aber nie den Zufall brerchnen. Unser biologischer Computer kann mit der Ausage "eine zerdrückte 3" ohne weiteres was anfangen sogar damit rechnen. Ein Computer kann dies nicht. Random: Bei delphi wird der Inhalt einer Speicherstelle im Processor ausgelesen. Davon aus wird zu dem gewünschten Bereich hoch oder zurück gerechnet.Bei Randomitze wird mit der Systemzeit die Speicherstelle ausgesucht. Mit RandomSeed kann das mit der Hand gemacht werden. Dann kommen gleiche Reihen? Zahlen heraus. Probiert mal IF Random(100)< 50 aus Ihr werdet euch wundern. Um ein noch Zufälligeres Ergebnis zu bekommen ruft Random mit der höstmöglichen Integerzahl auf welche das Gerät verarbeiten kann. Dann werden die Rotienen von Delphi nicht benutzt. Bei gerade und ungerade auswertung nähert sich das Ergebnis immer näher an 100% an, erreicht es aber fast nie. Für Spiele empfehle ich, wie bei Spielautomaten einen gesteuerten Zufall zu benutzen. Das ist gerechter.
gruß Helga

[Medium]

Zitat:

Zitat von OmaH (Beitrag 1191118)

Senf

Ist es leider.

Zitat:

Zitat von OmaH (Beitrag 1191118)

Ein C.P. [...]kann Wahrscheinlichkeiten aber nie den Zufall brerchnen.

Er kann Zufall simulieren, und genau dafür sind RNGs da, und darum geht's hier ja :)

Zitat:

Zitat von OmaH (Beitrag 1191118)

Random: Bei delphi wird der Inhalt einer Speicherstelle im Processor ausgelesen.

Nein, es wird der Seed als Startwert für eine Funktion genommen, der eine sog. Reihe bildet. Die Reihenglieder der verwendeten Funktion sind dann statistisch gleichverteilt, und erwecken einen recht guten Eindruck von Zufall. Aber da liest keiner eine "Speicherstelle im Prozessor", was auch immer das sein soll.

Zitat:

Zitat von OmaH (Beitrag 1191118)

Davon aus wird zu dem gewünschten Bereich hoch oder zurück gerechnet.

??

Zitat:

Zitat von OmaH (Beitrag 1191118)

Bei Randomitze wird mit der Systemzeit die Speicherstelle ausgesucht.

Bei Randomize wird der Datums/Zeitwert als Integer gecasted und als Seed genommen.

Zitat:

Zitat von OmaH (Beitrag 1191118)

Dann kommen gleiche Reihen? Zahlen heraus.

Gleicher Seed, gleiche Reihe, ja.

Zitat:

Zitat von OmaH (Beitrag 1191118)

Probiert mal IF Random(100)< 50 aus Ihr werdet euch wundern.

Warum?

Zitat:

Zitat von OmaH (Beitrag 1191118)

Um ein noch Zufälligeres Ergebnis zu bekommen ruft Random mit der höstmöglichen Integerzahl auf welche das Gerät verarbeiten kann. Dann werden die Rotienen von Delphi nicht benutzt.

Jetzt wird's ganz witzig. Hä? NOCH zufälliger? Ich denke ein Computer kann keinen Zufall. Und warum sollte dann nicht die Delphi-Funktion genommen werden?

Zitat:

Zitat von OmaH (Beitrag 1191118)

Bei gerade und ungerade auswertung nähert sich das Ergebnis immer näher an 100% an, erreicht es aber fast nie.

Was zum Henker sind jetzt gerade und ungerade auswertungen? Was nähert sich 100% an, 100% wovon?

Zitat:

Zitat von OmaH (Beitrag 1191118)

Für Spiele empfehle ich, wie bei Spielautomaten einen gesteuerten Zufall zu benutzen. Das ist gerechter.

Und was ist gesteuerter Zufall!?


Selten so viel Komisches Zeug gelesen, tut mir leid. Hier ist leider praktisch alles verkehrt.