Das Ziegenproblem

Hallo,

vielleicht kennt der Eine oder Andere die Show mit den 3 Toren, hinter einem ein Auto versteckt ist und hinter den anderen die Zonks (die Nieten).
Es läuft so ab:
Der Spieler wählt ein Tor aus, hinter dem er den Preis vermutet. Nun wird unabhänig davon, was sich hinter dem ausgewähltem Tor befindet, ein zufälliges Tor mit einem Zonk aufgemacht und scheidet damit aus.
Nun sind 2 Tore übrig. In einem steckt das Auto, im anderem ein Zonk. Der Spieler darf sich nun entscheiden, ob er seine Torwahl umwählen möchte oder nicht. Jetzt kommt der Punkt.
Aus einer Wahrscheinlichkeitsrechnung ist die Wahrscheinlichkeit größer das Auto zu gewinnen, wenn man umwählt.

Nun würde ich gerne eine Simulation programmieren, mit der man diese Wahrscheinlichkeit aus x Versuchen, ausrechnen kann. Jedoch bin ich mir nicht so im Klaren darüber, wie ich dies realisieren soll. Einen Ansatz habe ich begonnen.

Ich habe erstmals eine Struktur gemacht, die für ein Tor steht:

struct STore
{
	public bool Auto; // Wenn true, ist in diesem Tor das Auto
	public bool Ausgeschieden; // Wenn true, ist dieses Tor ausgeschieden worden, nachdem der Spieler seine erste Wahl machte
}

Nun möchte ich dreimal diese Struktur instanzieren, weil wir ja 3 Tore haben. Diese Tore packe ich am besten in ein Array.
Da aber ein Tor während des Spieles ausgeschieden wird, nehm ich lieber ein ArrayList, um das Tor dann bequem aus dem Array dann entfernen zu können. Hier erstmals der Code:

			Random rdm = new Random();
			ArrayList Tore = new ArrayList(3);
			ArrayList VTore;
			STore Tor1 = new STore();
			STore Tor2 = new STore();
			STore Tor3 = new STore();

			Tore.Add(Tor1);
			Tore.Add(Tor2);
			Tore.Add(Tor3);
			
			int TorMitAuto = rdm.Next(2); //Zufällig entscheiden, in welchem Tor das Auto ist
			Tore[TorMitAuto].Auto = true;

Ab hier krieg ich ein Compiler-Error, er sagt mir, dass "object" keine definition für Auto hat. Versteh ich nicht.
Kann mir da bitte jemand helfen?
Hätte vielleicht jemand auch eine Idee, wie man diese Simulation einfacher realisieren könnte? Würde mich wirklich freuen, dieses zu Ende zu bringen.

Besten Dank im vorraus und frohe Ostern!

also bei nur 1 Variablen würde ich 3 Einzelne erstellen und kein Array ist schneller und nicht so fehleranfällig.
dann würde ich auf einem Form 3 Buttens Platzieren Tor1 usw.
und 2 labals also
labe1 Warscheinlichkeit bei Ändern
labe2 Warscheinlickkeit bei lassen
aber warum errechnen am anfang ist die warscheinlichkeit 33 zu 66% danach
50 zu 50%

Ich will keine Buttons, das Spiel soll man nicht "spielen" können. Es soll lediglich x tausend mal ausführen und die Wahrscheinlichkeit errechnen. Die Wahrscheinlichkeit ist außerdem nicht 50% zu 50% am Ende!
Da muss wohl irgendwo ein Missverständnis sein.

Man muss folgende Schritte programmieren:

1. Computer muss aus Zufall das Auto hinter einem Tor verstecken.
2. Computer muss aus Zufall ein Tor wählen.
3. Computer muss aus Zufall ein Tor ausscheiden lassen, welches nicht das Auto ist.
4. Computer inkrementiert nun entweder je nachdem, ob es beim Umwählen das Auto gewonnen hat die "UmwählenErfolg" Variable oder wenn es falsch geliegen ist, die "NichtUmwählenErfolg" Variable.
5. Dieses wird x tausend mal wiederholt und eine Statistik daraus gemacht.

Wie würdest du diese Schritte programmieren?

Hallo S.H.-Teichhof,

am Anfang ist die Wahscheinlichkeit 1/3 und wenn man wechselt ist die Wahrscheinlichheit 2/3, auch wenn du es nicht glaubst. Schreib eine Simulation und du wirst es sehen 🙂

Hallo Kalleos,

zu eigentlichen Frage: In ArrayLists werden von statische Typ her Objects gespeichert. Wenn du auf Eigenschaften von STore zugreifen willst, braucht du also einen Cast:

((STore)Tore[TorMitAuto]).Auto = true;

Was die Schritte angeht: klingt ganz ok.

herbivore

Eine Schleife für die durchleufe eine array mit 3 bools dann eine der drei über zufallszahl mit true belegen die anderen beiden über ifs mit false danach 1 zufallszahl zwischen 0 und 2 generrieren und puffern dann eine zuffals zahl zwischen 0-2 generieren lassen und damit auf das arry zugreifen wenn == true neu generiren lassen wenn nicht index puffern wenn die gepufferte wahl == true ist erfolge plus eins wenn nicht ümwählerfolg plus eins dann zähler der schleife erhöhen und neu starten eigendlich sehr simpel

ps warum ist die schoße beim umwählen nicht 50 zu 50 es gibt doch eine richtige und eine falsche also 1 zu 1 oder

Hallo S.H.-Teichhof,

über die Frage warum die Wahrscheinlichkeit beim Wechseln 2/3 ist, sind ganze Bücher geschrieben worden (Gero von Randow, Das Ziegenproblem - Denken in Wahrscheinlichkeiten, rororo 1993, ISBN 3-499-19337-X). Es gibt die unterschiedlichsten Erklärungen dafür und nicht alle Erklärungen sind jedem einleuchtend. Da ich nicht weiß, welche der vielen Erklärungen dir einleuchtet, lass ich das lieber gleich. Schreib die Simulation (du sagts ja zu recht, dass das sehr simplel ist) und du wirst es sehen.

herbivore

Hallo herbivore,

Diesen Cast führte ich durch, doch dachte ich, dass er falsch wäre. Ich bekomme nämlich folgenden Compile-Error dann:

The left-hand side of an assignment must be a variable, property or indexer

Danke werd ich machen man lernt eben nie aus vorallem wenn man erst 17 ist 😁

Hallo Kalleos,

bist du dir sicher, den Cast richtig geklammert zu haben? Ich kann die Zeile, so wie ich sie geschrieben haben, fehlerlos übersetzen.

herbivore

PS: Ah, deine "Klasse" STore ist ein struct. Dann bekomm ich folgende Meldung:

error CS0445: Cannot modify the result of an unboxing conversion

Aber mit

STore torTmp = ((STore)Tore[0]);
torTmp.Auto = true;
Tore[0] = torTmp;

müsste es auf jeden Fall gehen.

Habs jetzt wen es jemanden interesiert hängt an und ich glaube ich verstehe langsamm auch warum die wascheinlichkeit bei 2 zu 3 und nicht bei 1 zu ein liegt

Hab mir gerade beim Melken die Sache nochmal genau durch den Kopf gehen lassen und bin zu dem schluss gekommen wenn es nicht um das genaue Wiederspiegel des ablaufes geht ist das die schnellste möglichkeit

			int zähler = 0;
			int wtreffer = 0;
			int puffer;
			Random r = new Random();
			while(zähler < x)
			{
				puffer   = r.Next(0,3);
				if(puffer != r.Next(0,3))
				{
					wtreffer++;
				}
				zähler++;
			}

denn eigenlich macht es nichts aus welche der beiden "Nieten " man wegnimmt am ende kommt einfach die Frage ob der Gewinn durch änderung erreichtwerden kann