Gymnasium Löbau/Vertiefungsklasse 2013/Wiederholung: Datentypen und Programmstrukturen

Wiki-Quelltext dieser Seite.

<language>Javascript</language>
An einfachen Problemstellungen wollen wir ausgewählte Datentypen und Programmstrukturen in JavaScript wiederholen.

<code id="5b82ce93bff2e" hidden>
function runden(x, n) {
 return Math.round(x * Math.pow(10, n)) / Math.pow(10, n);
}

function intKorrekt(z, min, max) {
 var korrekt = false;
 var i = min;
 do {
  korrekt = (z == i);
  i++;
 }
 while (i <= max && !korrekt);
 return korrekt;
} 
</code>

== Fakultät einer natürlichen Zahl ==

Die Fakultät einer natürlichen Zahl berechnet sich aus:

<blockquote>$n! = 1 \cdot 2 \cdot 3 \cdot ... \cdot n$</blockquote>

Implementiere diese Bildungsvorschrift mit einer Funktion und teste diese mit (kleinen) Argumenten.

<code id="5b82646eb3149">
function fakultaet(n) {
 var produkt = 1;
 // -- weitere Anweisungen --
 return produkt;
}
</code>

<check execute="(fakultaet(2) == 2 && fakultaet(6) == 720)">true</check>

<run id="5b82646eb31d2">
fakultaet(6);
</run>

== Das Heron-Verfahren ==

Das Heron-Verfahren ist ein Näherungsverfahren zur Bestimmung der ''Quadratwurzel'' einer beliebigen positiven reellen Zahl $z$.
Aus einem beliebigen Startwert $x$ ergibt sich aus der nachfolgenden Gleichung mit $x_0$ ein erster Näherungswert für $\sqrt{z}$:

<blockquote>$x_0 = \frac{x + \frac{z}{x}}{2}$</blockquote>

Wird $x_0$ als neuer Startwert in diese Gleichung eingsetzt, erhält man einen besseren Näherungswert.<br />
Durch mehrfaches Anwenden dieses Verfahrens kann der Wert von $\sqrt{z}$ mit beliebiger Genauigkeit angenähert werden. <br />
Vervollständige dazu die entsprechende Funktion.

<code id="5b826f3a1ca84">
function heron(z, x) {
 var x0 = x;
 // -- weitere Anweisungen --
 return x0;
}
</code>

<check execute="(runden(Math.sqrt(2), 6) == runden(heron(2, 1), 6) && runden(Math.sqrt(13), 6) == runden(heron(13, 71), 6))">true</check>

<run id="5b826dc024ec9">
heron(2, 1);
</run>

== Die Fibonaccizahlen ==

<table border="0">
<tr>
<td valign="top">
Einer der bedeutendsten Mathematiker des Mittelalters, '''Leonardo Fibonacci di Pisa''' (* um 1180; † 1241), beschrieb die Fortpflanzung von Kaninchen mit der Zahlenfolge:

<blockquote>$1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...$</blockquote>

'''Definition:'''
<blockquote>
$\mbox{fibo}(n)=\begin{cases}1,\mbox{wenn}\hspace{0.3em}n=1\\1,\mbox{wenn}\hspace{0.3em}n=2\\\mbox{fibo}(n-1)+\mbox{fibo}(n-2),\mbox{sonst}\end{cases}$
</blockquote>

'''Beschreibung:'''

* Die ersten beiden Glieder der Zahlenfolge sind jeweils 1.
* Jedes weitere Glied ergibt sich aus der Summe seiner beiden Vorgänger.
<br/>
Eine allgemeine Formel zur Berechnung der n-ten Fibonaccizahl wurde unabhängig voneinander von den französischen Mathematikern '''Abraham de Moivre''' (* 26. Mai 1667; † 27. November 1754) erst im Jahr 1718 und '''Jacques Philippe Marie Binet''' (* 2. Februar 1786; † 12. Mai 1856) sogar erst im Jahr 1843 entdeckt.
</td>
<td valign="top">
[[Bild:Fibonacci1.jpg|miniatur|Berechnung der "Kaninchenaufgabe" mit der Fibonacci-Folge]]
</td>
</tr>
</table>

Ergänze die nachfolgende Funktion und teste sie mit kleinen Argumenten.

<code id="5b9f5d298bead">
function fibo(n) {
 var f1 = 1, f2 = 1;
 var f; 
 // -- weitere Anweisungen --
 return f2;
} 
</code>

<check execute="(fibo(1) == 1 && fibo(2) == 1 && fibo(6) == 8 && fibo(33) == 3524578)">true</check>

<run id="5b9f5d298bfc1">
fibo(6);
</run>

== Zufallszahlen ==

Mit den nachfolgenden Funktionen lassen sich beliebige Zufallszahlen ereugen:

 Math.random() ... erzeugt eine (rationale) Zufallszahl $z$ im Intervall $0 \le z < 1$
 Math.floor(z) ... rundet die Zahl $z$ auf die nächstniedrigere ganze Zahl ab

Experimentiere mit diesen Funktionen, so dass große ''ganze'' Zufallszahlen generiert werden.

<run id="5b82c1c29723c">
Math.floor(Math.random() * 10);
</run>

Vervollständige nun die nachfolgende Funktion, mit der das Werfen eines Würfels simuliert werden soll.

<code id="5b82c1c2971b4">
function wuerfelzahl() {
 var w;
 return w;
}
</code>

<code id="5b9760aaac5a7" hidden>
function wurfKorrekt(maxAnz) {
 var z = [], i = 1;
 var w;
 var korrekt = false;
 do {
  w = wuerfelzahl();
  korrekt = intKorrekt(w, 1, 6);
  if (korrekt) z[w - 1]++;
  i++;
 }
 while (korrekt && i < maxAnz);
 return (korrekt && z.length == 6);
}
</code>

<check execute="(wurfKorrekt(1000))">true</check>

<run id="5b82c1c2972a1">
wuerfelzahl();
</run>

== Zufallsexperimente ==

=== Werfen einer Münze ===

Simuliere mit der nachfolgenden Prozedur das Werfen einer Münze. Dabei soll ausgegeben werden, wie oft Kopf und Zahl gefallen sind.

<code id="5b82f3a3aadf9">
function muenzwurf(anz) {
 var kopf = 0, zahl = 0;
 // -- weitere Anweisungen --
 return "Kopf: " + kopf + " / " + "Zahl: " + zahl;
}
</code> 

<run id="5b82f3a3aae93">
muenzwurf(100);
</run>

=== Würfeln mit einem Würfel ===

Wie oft muss im Mittel ein Würfel geworfen werden, bis ''nacheinander'' zwei Sechsen gefallen sind?

<code id="5b82f8b67d4b6">
function wuerfeln1() {
 var w1 = 0, w2 = 0, z = 0;
 // -- weitere Anweisungen --
 return z;
}

function wuerfelexperiment1(anz) {
 var z = 0, mw = 0;
 // -- weitere Anweisungen --
 return mw;
}
</code> 

<run id="5b82f8b67d56b">
wuerfelexperiment1(100);
</run>

=== Würfeln mit zwei Würfeln ===

Wie oft müssen im Mittel zwei Würfel geworfen werden, bis beide Augenzahlen gleich sind?

<code id="5b82fc48d8245">
function wuerfeln2() {
 var w1 = 0, w2 = 0, z = 0;
 // -- weitere Anweisungen --
 return z;
}

function wuerfelexperiment2(anz) {
 var z = 0, mw = 0;
 // -- weitere Anweisungen --
 return mw;
}
</code> 

<run id="5b82fc48d82ec">
wuerfelexperiment2(100);
</run>

== Widerstandsnetzwerk ==

<code id="5b96384641b90" hidden>
function grenzwert(r) {
 return (Math.sqrt(5) + 1) / 2 * r;
}
</code>

Zunächst besteht eine einfache elektrische Grundschaltung aus 2 gleichgroßen Widerständen. Durch Anhängen weiterer dieser Grundschaltungen entsteht daraus ein komplexes Widerstandsnetzwerk:

<p>[[Bild:Widerstandsnetzwerk1.GIF]]</p><br />

Entwickle eine Funktion, die den Gesamtwiderstand zwischen den Anschlussklemmen <math>A</math> und <math>B</math> berechnet, wenn <math>n</math> Grundschaltungen zu diesem Widerstandsnetzwerk zusammengesetzt wurden. 

<code id="5b9760aaac634">
function widerstand(r, n) {
 var r_ges = 2 * r;
 // -- weitere Anweisungen --
 return r_ges;
}
</code>

<check execute="(runden(widerstand(123, 10), 3) == runden(grenzwert(123), 3) && runden(widerstand(11256, 10), 2) == runden(grenzwert(11256), 2))">true</check>

<run id="5b96384641d05">
widerstand(100, 10);
</run>