Bergervei/Java-Würfeln

Wiki-Quelltext dieser Seite.

<language>Java</language>
== Zufallszahlen ==

Wir erzeugen zunächst einzelne Zufallszahlen:

<run id="4d3201f54e8a0">
System.out.println(Math.random()*100);
</run>

Dabei stellen wir fest: <tt>Math.random()*&lt;max&gt;</tt> gibt eine zufällige Gleitkommazahl <math>z</math> zurück mit <math>0 \le z < max</math>.<br />
Das Würfeln einer Augenzahl <math>z</math> mit <math>1 \le z \le 6</math> lässt sich demzufolge mit der nachfolgenden Funktion simulieren, die noch vervollständigt werden muss:

<code id="4d3201f54e6de">
public int WuerfelZahl() {
 return 0; // Implementation einer Wuerfelzahl
}
</code>

<code id="4d3201f54e750" hidden>
public boolean WuerfelTest(int n) {
 int[] zaehler = new int[6];
 boolean korrekt = true;
 for (int i = 0; i < 6; i++) zaehler[i] = 0;
 for (int i = 0; i < n; i++) {
  int z = WuerfelZahl();
  korrekt = korrekt && (z >= 1) && (z <= 6);
  if (korrekt) zaehler[z-1] = zaehler[z-1]+1;   
 }
 for (int i = 0; i < 6; i++) korrekt = korrekt && (zaehler[i]>0);
 return korrekt;
}
</code>

<check>
return WuerfelTest(100);
</check>

<run id="4d3201f54e905">
System.out.println(WuerfelZahl());
</run>

[[Bild:Wuerfel1.jpg|miniatur|Wurf mehrerer Würfel]]

== Würfeln mit mehreren Würfeln ==

Nun wollen wir das gleichzeitige Werfen mehrerer Würfel simulieren. Dabei soll uns nur interessieren, ''wie oft'' die Summe aller Augenzahlen auftreten.<br />
Um signifikante Aussagen zu erhalten, muss diese Simulation in großer Anzahl wiederholt werden können.

=== Lösungsidee ===

* Organisiere die Zählvariablen in einem eindimensionalen Feld (''Array'').
* Der Index jeder Zählvariablen entspricht genau der um 1 verringerten Summe aller geworfenen Augenzahlen.
* Wiederhole die Simulation in der gewünschten (großen) Anzahl.

=== Struktogramm ===

<blockquote>[[Bild:WuerfelStrukto2.GIF]]</blockquote>

=== Implementation ===

<code id="4d33575b4f655" hidden>
public Object BalkenDiagramm(Object canvas, Object turtle) {
 double Rand = 50;
 double MaxBreite = 600-2*Rand;
 double MaxHoehe = 400-2*Rand;

 private int[] MinMax(int[] liste) {
  int[] Ergebnis = {0, 0};
  for (int i = 0; i < liste.length; i++) {
   if (Ergebnis[0] > liste[i]) Ergebnis[0] = liste[i];
   if (Ergebnis[1] < liste[i]) Ergebnis[1] = liste[i];
  }
  return Ergebnis;
 }

 private void Balken(double hoehe, double breite) {
  turtle.forward(breite); turtle.left(90); 
  turtle.forward(hoehe); turtle.left(90);
  turtle.forward(breite); turtle.left(90);
  turtle.forward(hoehe); turtle.left(90);
  turtle.forward(breite); 
 }

 public void Darstellung(int[] liste) {
  double Breite = MaxBreite/liste.length; 
  ExtremWert = MinMax(liste);
  double Min = ExtremWert[0];
  double Max = ExtremWert[1];
  canvas.clear();
  turtle.hide();
  turtle.move(Rand, Rand+Max/(Max-Min)*MaxHoehe);
  turtle.right(90);
  for (int i = 0; i < liste.length; i++)
   Balken(liste[i]/(Max-Min)*MaxHoehe, Breite);
 }

 return this;
}
</code>

<code id="5144f4cf7e9ae">
public int[] Wuerfeln(int anzahl, int versuche) {
 int[] zaehler = new int[6*anzahl];
 // Implementation des Werfens mehrerer Wuerfel
 return zaehler;
}

public void Ausgabe(int anzahl, int[] zaehler) {
 int[] balken = new int[5*anzahl+1];
 int max = 0; int maxpos = anzahl;
 int j = 0;
 for (int i = anzahl; i <= 6*anzahl; i++) {
  balken[j] = zaehler[i-1];
  if (max < zaehler[i-1]) {
   max = zaehler[i-1]; maxpos = i;
  }
  System.out.println("Augenzahl " + i + ": " + zaehler[i-1]);
  j++;
 }
 System.out.println("Die Augenzahl " + maxpos + " ist mit " + max + " am häufigsten vertreten.");
 Object BalkenDiagramm1 = BalkenDiagramm(canvas1, turtle1);
 BalkenDiagramm1.Darstellung(balken);
}
</code>

<canvas w="600" h="400"></canvas>

<run id="4d3201f54e965">
int WuerfelAnzahl = 10;
Ausgabe(WuerfelAnzahl, Wuerfeln(WuerfelAnzahl, 10000));
</run>

=== Aufgaben ===
<ol>
<li>
Übertrage die Ergebnisse der Simulation mit 10 Würfeln in eine Tabellenkalkulation.
</li>
<li>
Untersuche mit geeigneten Methoden, welche Häufigkeitsverteilung der Augenzahlen vorliegen könnte.
</li>
</ol>