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="4dd936db0680a" hidden>
function wuerfeltest(n: integer): boolean;
 var zaehler: array [0..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="4d3356de5e220" 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:=600-2*rand;
  maxhoehe:=400-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="512fe165d3e52">
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);
  for i:=0 to length(arr)-1 do arr[i]:=0;
  for j:=1 to versuche do
  begin
   summe:=0;
   for i:=1 to anzahl do summe:=summe+random(6)+1;
   arr[summe-1]:=arr[summe-1]+1;
  end;
 end;

procedure ausgabe(arr: array of integer; anzahl: integer);
 var i, j    : integer;
     blk     : array of integer;
     pos, max: integer;
 begin
  setarraylength(blk, 5*anzahl+1);
  j:=0;
  pos:=anzahl; max:=0;
  for i:=anzahl to 6*anzahl do
  begin   
   writeln('Augenzahl '+i+': '+arr[i-1]);
   if arr[i-1]>max then
   begin
    pos:=i; max:=arr[i-1];
   end;
   blk[j]:=arr[i-1]; j:=j+1;
  end;
  writeln('Die Augenzahl '+pos+' ist mit der Anzahl '+max+' am häufigsten vertreten.');
  balkendiagramm(blk, 1);
 end;
</code>

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

<run id="512fe165d3f18">
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 Augenzahlen vorliegen könnte.
</li>
</ol>