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><math>n! = 1 \cdot 2 \cdot 3 \cdot ... \cdot n</math></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 <math>z</math>.
Aus einem beliebigen Startwert <math>x</math> ergibt sich aus der nachfolgenden Gleichung mit <math>x_0</math> ein erster Näherungswert für <math>\sqrt{z}</math>:

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

Wird <math>x_0</math> als neuer Startwert in diese Gleichung eingsetzt, erhält man einen besseren Näherungswert.<br />
Durch mehrfaches Anwenden dieses Verfahrens kann der Wert von <math>\sqrt{z}</math> 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>

== Zufallszahlen ==

Mit den nachfolgenden Funktionen lassen sich beliebige Zufallszahlen ereugen:

 Math.random() ... erzeugt eine (rationale) Zufallszahl <math>z</math> im Intervall <math>0 \le z < 1</math>
 Math.floor(z) ... rundet die Zahl <math>z</math> 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="5b82ce93bffaa" hidden>
function wurfKorrekt(maxAnz) {
 var z = [];
 var w;
 var korrekt = false;
 for (var i = 1; i <= maxAnz; i++) {
  w = wuerfelzahl();
  korrekt = intKorrekt(w, 1, 6);
  if (korrekt) z[w - 1]++
 }
 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>
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>