Stäbchenziehen - Wahrscheinlichkeiten

Neue Frage »

Raufasertapete Auf diesen Beitrag antworten »
Stäbchenziehen - Wahrscheinlichkeiten
Hallo,

ich habe folgendes Problem:
Es gibt 6 Stäbchen, 1 kurzes und 5 gleich lange und es gibt 6 Menschen die nacheinander je 1 Stäbchen ziehen.

So, wie groß ist die Wahrscheinlichket der einzelnen Menschen einen kurzen zu ziehen?

Ich habe 3 verschiene Leute gefragt und 3 verschiedene Ergebnisse bekommen und bin inzwischen verwirrt ^^.

1. Sie ist bei allen gleich groß 1/6

2. Ausgehend vom letzten der eine 1/2 Wahrscheinlichkeit hat immer die hälfte davon, also
der 6. : 1/2
der 5. : 1/4
der 4. : 1/8
der 3. : 1/16
der 2. : 1/32
der 1. : 1/64
wobei ich davon am wenigsten halte, da alles summiert noch nicht mal 1 ergibt.

3. Ein selbstgeschriebenes Computerprogramm, was das Ziehen der Stäbchen 1mio mal simuliert, sagt:

1: 16,67 %
2: 13,84 %
3: 11,5 %
4: 9,768 %
5: 7,897 %
6: 40,325 %
wobei ich mir das Ergebnis mathematisch nicht erklären kann.

Vielleicht könnt ihr mir helfen.

Vielen Dank im Voraus
tmo Auf diesen Beitrag antworten »

Poste mal den Code des Algorithmus, mit dem du das simuliert hast. Denn dass bei sovielen Versuchen so große Abweichungen von der erwarteten Gleichverteilung auftreten, wundert mich.

In der Tat ist nämlich 1. richtig. Für alle Leute liegt die Wahrscheinlichkeit bei 1/6.
 
 
Raufasertapete Auf diesen Beitrag antworten »

Hi,

danke für die schnelle Hilfe, dass die Wahrscheinlichkeit 1/6 beträgt hatte ich mir schon gedacht, da die anderen absurd erschienen.

Den Algorithmus kenne ich nicht, da das Programm von nem Freund geschrieben wurde... hat sich vllt geirrt mit dem Algorithmus.

Grüße
Dunkit Auf diesen Beitrag antworten »

Servus!
Also so könnte in Java ein Programm aussehen, der EINMAL aus SECHS Stäbchen zieht.
Habe ich jetzt auf die Schnelle zusammengeschustert, ein Programm für das komplette Experiment liefere ich noch nach, muss jetzt weg Big Laugh

Zitat:

import java.util.*;
public class StaebchenZiehen {

int value, p0=0, p1=0, p2=0, p3=0, p4=0, p5=0;

public static void main(String[] args) {

int i;

StaebchenZiehen sz1 =new StaebchenZiehen();
Random random = new Random();

for (i=0;i<1000000;i++) {
sz1.value = random.nextInt(6);
switch (sz1.value) {
case 0: sz1.p0++; break;
case 1: sz1.p1++; break;
case 2: sz1.p2++; break;
case 3: sz1.p3++; break;
case 4: sz1.p4++; break;
case 5: sz1.p5++; break;
}
}
System.out.println(sz1.p0 + " " + sz1.p1 + " " + sz1.p2 + " " + sz1.p3
+ " " +sz1.p4 + " " +sz1.p5);
}
}


Eine Ausgabe ist zB
166828 166734 166359 166417 166919 166743
Mathewolf Auf diesen Beitrag antworten »

Es ist richtig, daß die Wahrscheinlichkeit für den ersten, der zieht, 1/6 ist. Jetzt gibt es zwei Möglichkeiten: 1. Er zieht ein kurzes, oder er zieht ein langes.
Schrei dafür mal die Wahrscheinlichkeiten hin.
Wie sieht das dann für den zweiten Zieher aus?
Dunkit Auf diesen Beitrag antworten »

Bevor Verwirrung entsteht: Die Lösung "für alle 1/6" ist die richtige, wie tmo schon sagte.

Für die Interessierten: Ich habe das Ganze mal komplett durchsimuliert, hier der code (für 1000000 Versuche):
code:
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:
import java.util.*;

public class StaebchenZiehen {

	int[] staebchen = new int[6];
	static int[] sieger = {0, 0, 0, 0, 0, 0};
		
	public static void main(String[] args) {
		int j, n = 1000000;
		for (j = 0; j<n; j++) {
			// Simulation einer Ziehung
			StaebchenZiehen ziehung = new StaebchenZiehen();
			int i, ergebnis;
			for (i=0;i<6;i++) {
				ergebnis = ziehung.ziehen();
				if (ergebnis == 1) {
					StaebchenZiehen.sieger[i]++;
					break;
				}
			}
		}

		// Ergebnis Ausgabe
		System.out.println("Absoultes Ergebnis: " + 
				StaebchenZiehen.sieger[0] + 
				" " + StaebchenZiehen.sieger[1] + 
				" " + StaebchenZiehen.sieger[2] + 
				" " + StaebchenZiehen.sieger[3] + 
				" " + StaebchenZiehen.sieger[4] + 
				" " + StaebchenZiehen.sieger[5]);
		System.out.println("Relatives Ergebnis: " + 
				(double) StaebchenZiehen.sieger[0] / n * 100 + "%" + 
				" " + (double)StaebchenZiehen.sieger[1] / n* 100 + "%"+ 
				" " + (double)StaebchenZiehen.sieger[2] / n* 100 + "%"+ 
				" " + (double)StaebchenZiehen.sieger[3] / n* 100 + "%"+ 
				" " + (double)StaebchenZiehen.sieger[4] / n* 100 + "%"+ 
				" " + (double)StaebchenZiehen.sieger[5]/ n* 100 + "%");
	}
	
	
	// Methode, die ein Stäbchen zieht
	public int ziehen() {
		Random random = new Random();
		int ergebnis;
		int i;
		
		for (i=0;i<1;) {
			int wahl = random.nextInt(6);		
			if (this.staebchen[wahl] != -1) {
				ergebnis = this.staebchen[wahl];
				this.staebchen[wahl] = -1;
				return ergebnis;
			}		
		}
				// Auffangen
		return -2;
	}
	
	//Konstruktor
	StaebchenZiehen() 
	{
		Random random = new Random();
		int i, kurzPos;
		
		kurzPos = random.nextInt(6);
		
		// baut ein array mit Nullen und einer 1
		for (i=0;i<6; i++) { 
			if (i == kurzPos) {
				staebchen[i] = 1;
			}
			else {
				staebchen[i] = 0;
			}
		}
	}

}

Ausgabe (zB): Die absoluten Zahlen geben an, welcher Spieler wie oft gewonnen hat (also das kurze gezogen), die relativen dann jeweils anteilig in Prozent...
Zitat:
Absoultes Ergebnis: 159477 178086 171369 174420 160847 155801

Relatives Ergebnis: 15.947700000000001% 17.8086% 17.1369% 17.442% 16.084699999999998% 15.5801%

Also recht nah an 16.67%, also 1/6.
Auch hier sind noch verhältnismäßig hohe abweichungen drin, ich denke aber das liegt an den Pseudozufallszahlen von Java... Meinungen von Experten sind gerne gesehen Augenzwinkern

Ich gebe zu, nicht schön kommentiert - das liegt daran dass es wohll eh keine interessiert.
Der Programmierstil ist wahrsch. auch net so doll, aber ich bin ja auch Java-Anfänger Big Laugh
AD Auf diesen Beitrag antworten »

Die -Regel lässt den Bereich zu, für Simulationsumfang ist das das Intervall .

Insofern liegen deine Ergebnisse wirklich verdächtig weit draußen... verwirrt
Dunkit Auf diesen Beitrag antworten »

ja, finde ich auch.... noch merkwürdiger: bei 1.000.000.000 Versuchen kommt das raus:
Absoultes Ergebnis: 159758878 177744449 169967346 175502661 161596877 155429789
Relatives Ergebnis: 15.975887799999999% 17.7744449% 16.9967346% 17.5502661% 16.1596877% 15.542978900000001%

Ich kann das iwie nur auf die Java-Zufallszahlen schieben, weil im Programm finde ich keinen Fehler... Und wenn im Programm n ernsthafter Fehler wäre, wäre es wohl noch weiter draussen... Kennt sich hier irgendwer aus mit Java?!

P.S.: Was ist die -Regel?
AD Auf diesen Beitrag antworten »

Gemäß zentralem Grenzwertsatz ist der Mittelwert asymptotisch normalverteilt mit . Den Rest führe ich jetzt nicht genauer aus, solltest du selbst können.
Dunkit Auf diesen Beitrag antworten »

Ähm ne, also in der Schule hatten wir Stochastik ca. 2 Wochen und an der Uni hab ichs auch noch nicht belegt...
Aber ich werde mich mal schlau machen ;-)
AD Auf diesen Beitrag antworten »

Ach so, alles klar. Augenzwinkern
42 Auf diesen Beitrag antworten »

Hallo,
hier mal eine etwas schlankere Version des Stäbeziehen in PHP:
php:
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:
<?php
mt_srand(crc32(microtime()));

//Ordne die Stäbe zufällig an
function staebeMischen() {
    $staebe = array(0,0,00,0,0);

    //Setze einen Stab auf Kurz
    $staebe[mt_rand(0,5)] = 1;
    return $staebe;
}

$spieler = array(0,0,00,0,0);
$max 100000;


for($i=0;$i<$max$i++) {
   $staebe staebeMischen();

   for($j=0;$j<count($spieler);$j++) {
       //Wähle einen Stab aus
       do {
          $rnd mt_rand(0,5);
      } while($staebe[$rnd] == -1);

      //Den Kurzen erwischt?
      if($staebe[$rnd] == 1) {
        $spieler[$j]++;
        break;
      } else {
          $staebe[$rnd] = -1;
      }

   }
}


echo "<pre>";
print_r($spieler);
?>


Als Ergebnis bei 100k Durchgängen:
[0] => 16651
[1] => 16728
[2] => 16748
[3] => 16559
[4] => 16648
[5] => 16666


Liegt also alles im Rahmen.


@Dunkit:
Dein Fehler liegt in der falschen Verwendung von Random Class von Java.
Mit new Random() wird immer ein neuer Zufallsgenerator initialisiert, dieser ist nur abhänig von der Systemzeit.
Da sich aber z.B. zwischen zwei Aufrufen von ziehen() die Systemzeit nicht verändert, wird der Zufallsgenerator mit der selben Systemzeit initialisiert und liefert dementsprechend die selben Zufallszahlen.

Lösung:
Mach einen globalen (static) Zufallsgenerator, von dem du dann drauf zugreifst, und erstellt nicht jedes mal wieder ein neues Random Objekt.
Dunkit Auf diesen Beitrag antworten »

jawoll, danke - wieder was gelernt ;-)
Zitat:
Es wurden 100000 Versuche in 0.063 Sekunden gemacht.
Absoultes Ergebnis: 16695 16500 16864 16699 16485 16757
Relatives Ergebnis: 16.695% 16.5% 16.864% 16.699% 16.485% 16.756999999999998%

Das sieht doch brauchbar aus ^^
Neue Frage »
Antworten »



Verwandte Themen

Die Beliebtesten »
Die Größten »
Die Neuesten »