Bergervei/Pascal-Würfeln

Wiki-Quelltext dieser Seite.

<language>Pascal</language>
== Zufallszahlen ==

Wir erzeugen zunächst einzelne Zufallszahlen:

<run id="4d320f41d2db4">
writeln(random(100));
</run>

Dabei stellen wir fest: <tt>random(&lt;max&gt;)</tt> gibt eine Zufallszahl <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="4d320f41d2b42">
function wuerfelzahl: integer;
 begin
  result:=0; // Implementation einer Wuerfelzahl
 end;
</code>

<code id="4d320f41d2c0e" hidden>
function wuerfeltest(n: integer): boolean;
 var zaehler: array [1..6] of integer;
     korrekt: boolean;
     z, i   : integer;
 begin
  korrekt:=true;
  for i:=1 to 6 do zaehler[i]:=0;
  for i:=1 to n do
  begin
   z:=wuerfelzahl;
   korrekt:=korrekt and (z>=1) and (z<=6);
   if korrekt then zaehler[z]:=zaehler[z]+1;   
  end;
  for i:=1 to 6 do
   korrekt:=korrekt and (zaehler[i]>0);
  result:=korrekt;
 end;
</code>

<check>
result:=wuerfeltest(100);
</check>

<run id="4d320f41d2e38">
writeln(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="4d320f41d2c78" hidden>
procedure balkendiagramm(arr: array of integer; canvas: integer);
 var rand, maxbreite, maxhoehe, breite, hoehe: real;
     minimum, maximum, z0: real;
     i: integer; 
 begin
  selectcanvas(canvas);
  canvas_clear();
  rand:=50;
  maxbreite:=400-2*rand;
  maxhoehe:=300-2*rand;
  breite:=maxbreite/length(arr); 

  minimum:=0; maximum:=0;
  for i:=0 to length(arr)-1 do
  begin
   if arr[i]<minimum then minimum:=arr[i];
   if arr[i]>maximum then maximum:=arr[i];
  end;

  z0 := maximum/(maximum-minimum)*maxhoehe+rand;
  for i:=0 to length(arr)-1 do 
  begin
   hoehe:=-maxhoehe/(maximum-minimum)*arr[i]; 
   canvas_rect(round(rand+i*breite),round(z0),round(breite),round(hoehe));
  end;
 end;
</code>

<code id="4d320f41d2d1b">
var zaehler      : array of integer;
var wuerfelanzahl: integer;

procedure wuerfeln(var arr: array of integer; anzahl, versuche: integer);
 var i, j, summe: integer;
 begin
  setarraylength(arr, 6*anzahl);
  // Implementation des Werfens mehrerer Wuerfel
 end;

procedure ausgabe(arr: array of integer; anzahl: integer);
 var i, j: integer;
     blk : array of integer;
 begin
  setarraylength(blk, 5*anzahl+1);
  j:=0;
  for i:=anzahl to 6*anzahl do
  begin
   blk[j]:=arr[i-1];
   writeln('Augenzahl '+i+': '+arr[i-1]);
   j:=j+1;
  end;
  balkendiagramm(blk, 1);
 end;
</code>

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

<run id="4d320f41d2e99">
wuerfelanzahl:=10;
wuerfeln(zaehler, wuerfelanzahl, 10000);
ausgabe(zaehler, wuerfelanzahl);
</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 Auganzahlen vorliegen könnte.
</li>
</ol>