Lektion 5 - Do-while-Schleife, Modellierung, Quadratwurzelberechnung, Pi-Berechnung

Lektion
do‐while‐Schleife
Modellierung
Quadratwurzelberechnung
Pi‐Berechnung
© Prof. Dr. Steffen Heinzl
Wir wollen ein Ratespiel entwickeln!
Der Computer denkt sich eine Zahl
zwischen 1 und 100 aus.
Der Spieler rät, bis er die Zahl
erraten hat, und erhält nach jedem
Versuch einen Hinweis, ob die geratene
Zahl größer oder kleiner ist.
Der Computer denkt sich eine Zahl
zwischen 1 und 100 aus.
Math.random
liefert eine Fließkommazahl
x mit 0 <= x < 1
int zufallszahl = (int) (Math.random() * 100 + 1);
Der Spieler rät bis er die Zahl
erraten hat…
Schleife mit Eingabe
Scanner scanner = new Scanner(System.in);
WIEDERHOLE BIS ERRATEN
int eingabe = scanner.nextInt();
… und erhält nach jedem Versuch einen
Hinweis, ob die geratene Zahl größer
oder kleiner ist.
if‐Abfrage Ausgabe
WIEDERHOLE BIS ERRATEN Jetzt benötigen wir
int eingabe = scanner.nextInt(); noch die Schleife…
if (zufallszahl == eingabe)
System.out.println("Volltreffer!");
else if (zufallszahl > eingabe)
System.out.println("Die gesuchte Zahl ist größer!");
else if (zufallszahl < eingabe)
System.out.println("Die gesuchte Zahl ist kleiner!");
 Eine do‐while‐Schleife wiederholt den Schleifenrumpf, solange die
Laufbedingung erfüllt ist.
 Die Laufbedingung wird am Ende der Schleife überprüft (fußgesteuert).
 Der Schleifenrumpf wird daher mindestens einmal ausgeführt.
 Die do‐while‐Schleife hat folgende Form:
 Eine do‐while‐Schleife wiederholt den Schleifenrumpf, solange die
Laufbedingung erfüllt ist.
 Die Laufbedingung wird am Ende der Schleife überprüft (fußgesteuert).
 Der Schleifenrumpf wird daher mindestens einmal ausgeführt.
 Die do‐while‐Schleife hat folgende Form:
do
{
<Anweisungen> Schleifenrumpf
}
while(<bool‘scher Ausdruck>);
Laufbedingung
do‐while‐Schleife ‐ Beispiel
do
{
}
while (NOCH NICHT ERRATEN);
do
{
}
while (zufallszahl != eingabe);
do
{
int eingabe = scanner.nextInt(); eingabe ist sichtbar
}
while (zufallszahl != eingabe); eingabe ist nicht sichtbar
int eingabe;
do
{
eingabe = scanner.nextInt();
}
int eingabe; eingabe ist sichtbar
do
{
}
break
int eingabe;
do
{
{
System.out.println("Volltreffer!"); mit break lässt sich eine Schleife vorzeitig
break; verlassen
}
Die System.out.println("Die gesuchte Zahl ist kleiner!");
Ausführung }
wird dahinter while (true); Die Laufbedingung wird dadurch einfacher.
fortgesetzt. Der Programmfluss kann ‐ vor allem© Prof. Dr. Steffen Heinzl
bei häufiger
Verwendung ‐ unübersichtlicher werden.
Wir erweitern unser Spiel dahingehend,
dass der Spieler nur 10 Rateversuche hat.
int anzahlVersuche = 0;
int eingabe;
do
{
anzahlVersuche++;
}
while (zufallszahl != eingabe && anzahlVersuche < 10);
if (zufallszahl == eingabe) System.out.println("Sie haben gewonnen.");
else System.out.println("Sie haben verloren.");
int eingabe;
do Was können wir noch
{
vereinfachen?
anzahlVersuche++;
Hinweis: DRY
}
int eingabe;
do
{
Doppelter Code
anzahlVersuche++;
}
boolean getroffen = false;
int eingabe;
do
{
eingabe = scanner.nextInt(); Wir arbeiten mit einer
anzahlVersuche++;
if (zufallszahl == eingabe) sogenannten Flag zur
{ Markierung.
getroffen = true;
}
}
while (!getroffen && anzahlVersuche < 10);
if (getroffen) System.out.println("Sie haben gewonnen.");
else System.out.println("Sie haben verloren."); © Prof. Dr. Steffen Heinzl
Wir wollen programmatisch herausfinden,
gegen welchen Wert die folgende Reihe
voraussichtlich konvergiert.
1
3
Dazu schreiben wir die ersten Glieder auf:
1 1 1 1 1 1
⋯
3 3 3 3 3 3
1 1 1 1 1 1
⋯
3 3 3 3 3 3
Wir müssen die Glieder nacheinander
aufsummieren.
 wir brauchen eine Schleife
Der Exponent im Nenner
bzw. der Nenner
bzw. der Summand
ändert sich in jedem Durchlauf.
1 1 1 1 1 1
⋯
3 3 3 3 3 3
Berechnung des ersten Summanden:
summand = 1.0/Math.pow(3, 0);
Berechnung des zweiten Summanden:
Berechnung des dritten Summanden:
Berechnung des (k+1)‐ten Summanden:
summand = 1.0/Math.pow(3, k);
Summe
a + b
Summand Summand
double summe = 0;
double summand;
k muss in jedem
Durchlauf erhöht werden
WIEDERHOLE
summe = summe + summand;
do‐while‐Schleife, weil mindestens
eine Berechnung stattfindet
Welche Laufbedingung kommt in Frage?
double summe = 0;  unendlich?
double summand;  bis k oder 3k an die Zahlengrenze stößt?
 bis die Wertänderung unter ein
int k = 0; bestimmtes EPSILON fällt?
do
{
k++;
}
while( );
System.out.println(summe);
double summe = 0;
double summand;
int k = 0;
do
{
k++;
}
wenn weniger als 0.0000000001 zur
while(summand > 1E‐10); Gesamtsumme dazukommt: Abbruch
System.out.println(summe);
Äquivalenz do‐while und while
 Sei b eine bool‘sche Variable, die einen bool‘schen Ausdruck gespeichert habe.
while(b) { do {
<Anweisungen> <Anweisungen>
} }
while(b);
if(b) {
do { <Anweisungen>
<Anweisungen> while(b)
} {
while(b); <Anweisungen>
} }
continue
 Mit der Anweisung continue ist es möglich, den aktuellen Schleifendurchlauf
abzubrechen und mit dem nächsten zu beginnen.
/*Addiere alle Zahlen von 1 bis 10, lasse aber dabei alle durch 5
teilbaren Zahlen aus*/
int j = 0;
int sum = 0;
while(j < 10)
{
j++;
if (j % 5 == 0) continue;
sum = sum + j;
}
System.out.println(sum);
Endlosschleifen
 Folgende Schleifen laufen endlos, es sei denn sie werden durch break oder durch
eine Fehlermeldung (Exception, Error) verlassen:
for (;;) while(true) do

{ { {
<Anweisungen> <Anweisungen> <Anweisungen>
} } }
while(true);
Modellierung von Kontrollstrukturen
 Mit Kontrollstrukturen (Schleifen, Verzweigungen) kann der Programmfluss
gesteuert werden.
 Zur Modellierung des Programmflusses gibt es verschiedene Möglichkeiten:
 Pseudocode
WIEDERHOLE bis eingabe == ‐1
summe = summe + eingabe;
gesteuert werden.
 Struktogramme/Nassi‐Shneiderman‐Diagramme
source: http://upload.wikimedia.org/wikipedia/commons/3/33/NassiShneiderman.png
gesteuert werden.
 Flussdiagramme/Programmablaufpläne
 Aktivitätsdiagramme
 …
Modellierung des Ratespiels
mit einem Aktivitätsdiagramm
Der Computer denkt sich eine
Zahl zwischen 1 und 100 aus.
Der Spieler rät, bis er die
Zahl erraten hat, und erhält
nach jedem Versuch einen
Hinweis, ob die geratene Zahl
größer oder kleiner ist.
Quadratwurzelbestimmung
Quadratwurzel bestimmen
𝑥 𝑦 , wobei 𝑥, 𝑦 ∈ℝ \ 0
⇔ 𝑥 𝑦 ·𝑦 , da 𝑥, 𝑦 0
𝑥
⇔ 𝑦
𝑦
Setzt man nun einen Näherungswert 𝑦 für 𝑦 mit 𝑦 𝑦 ein, gilt:
𝑦 ·𝑦 𝑦
Aus 𝑦 𝑦 ⇒ 𝑦 𝑦
𝑦 𝑦
1
D. h. 𝑦 𝑦 ⇒ 𝑦
𝑦 𝑦 𝑥
𝑦
𝑦 bezeichnet den i‐ten
Näherungswert
⇔ 𝑥 𝑦 ·𝑦 , da 𝑥, 𝑦 0
𝑥
⇔ 𝑦
𝑦
𝑦 ·𝑦 𝑦
𝑦 𝑦 𝑥
𝑦
𝑦
1 2
D. h. 𝑦 𝑦 ⇒ 𝑦
⇒𝑦 liegt näher an 𝑦
𝑦 𝑦 𝑦 𝑥
𝑦
Näherungswert
⇔ 𝑥 𝑦 ·𝑦 , da 𝑥, 𝑦 0
𝑥
⇔ 𝑦
𝑦
𝑦 ·𝑦 𝑦
𝑦 𝑦 𝑥
𝑦
𝑦
1 2
D. h. 𝑦 𝑦 ⇒ 𝑦
⇒𝑦 liegt näher an 𝑦
𝑦 𝑦 𝑦 𝑥
𝑦
Analog gilt: 𝑦 𝑦 ⇒ 𝑦 Näherungswert
 Wann breche ich die Berechnung ab?
 Bei einer bestimmten Genauigkeit, z. B.
𝑥
𝑦 10
𝑦
Zum Nachlesen: Quadratwurzel (I)
Zum Nachlesen: Quadratwurzel (II)
Quadratwurzel: Beispiel
𝑥
𝑦
𝑦
𝑦
2
Näherungweise Berechnung von 2
x  2, wähle y0  1
x
 y0 2  1
y 3
y1  0 1   1,5
2 2 2
x 2
 y1  1,5 4  3 17
y 1,5 17
y2  1  3 2 6   1, 416
2 2 2 2 12
𝑥
𝑦
𝑦
𝑦
2
x  2, wähle y0  1
x
 y0 2  1
y 3
y1  0 1   1,5
2 2 2
x 2
 y1  1,5 4  3 17
y 1,5 17
y2  1  3 2 6   1, 416
2 2 2 2 12
𝑥
𝑦
𝑦
𝑦
2
x  2, wähle y0  1
x
 y0 2  1
y 3
y1  0 1   1,5
2 2 2
x 2
 y1  1,5 4  3 17
y 1,5 17
y2  1  3 2 6   1, 416
2 2 2 2 12
𝑥
𝑦
𝑦
𝑦
2
x  2, wähle y0  1
x
 y0 2  1
y 3
y1  0 1   1,5
2 2 2
x 2
 y1  1,5 4  3 17
y 1,5 17
y2  1  3 2 6   1, 416
2 2 2 2 12
𝑥
𝑦
𝑦
𝑦
2
x  2, wähle y0  1
x
 y0 2  1
y 3
y1  0 1   1,5
2 2 2
x 2
 y1  1,5 4  3 17
y 1,5 17
y2  1  3 2 6   1, 416
2 2 2 2 12
𝑥
𝑦
𝑦
𝑦
2
x  2, wähle y0  1
x
 y0 2  1
y 3
y1  0 1   1,5
2 2 2
x 2
 y1  1,5 4  3 17
y 1,5 17
y2  1  3 2 6   1, 416
2 2 2 2 12
𝑥
𝑦
𝑦
𝑦
2
x  2, wähle y0  1
x
 y0 2  1
y 3
y1  0 1   1,5
2 2 2
x 2
 y1  1,5 4  3 17
y 1,5 17
y2  1  3 2 6   1, 416
2 2 2 2 12
𝑥
𝑦
𝑦
𝑦
2
x  2, wähle y0  1
x
 y0 2  1
y 3
y1  0 1   1,5
2 2 2
x 2
 y1  1,5 4  3 17
y 1,5 17
y2  1  3 2 6   1, 416
2 2 2 2 12
𝑥
𝑦
𝑦
𝑦
2
x  2, wähle y0  1
x
 y0 2  1
y 3
y1  0 1   1,5
2 2 2
x 2
 y1  1,5 4  3 17
y 1,5 17
y2  1  3 2 6   1, 416
2 2 2 2 12
𝑥
𝑦
𝑦
𝑦
2
x  2, wähle y0  1
x
 y0 2  1
y 3
y1  0 1   1,5
2 2 2
x 2
 y1  1,5 4  3 17
y 1,5 17
y2  1  3 2 6   1, 416
2 2 2 2 12
𝑥
𝑦
𝑦
𝑦
2
x  2, wähle y0  1
x
 y0 2  1
y 3
y1  0 1   1,5
2 2 2
x 2
 y1  1,5 4  3 17
y 1,5 17
y2  1  3 2 6   1, 416
2 2 2 2 12
PI‐Berechnung
‐Beispiel:
Kreisfläche: r2
Kreisumfang: 2r
Aber wie kommt man auf den Wert für ?
Kreisfläche Rechtecknäherung (I)
Betrachten wir für eine erste Näherung
den Einheitskreis mit r = 1.

 1 1
4
 4
Kreisfläche Rechtecknäherung (II)
Eine weitere Näherung mit zwei Rechtecken.
1
Fläche linkes Rechteck = 1 
2
Kreisfläche Rechtecknäherung (II)
Für das rechte Rechteck muss zunächst
dessen Höhe x berechnet werden.
2
1 3
x 2     12  x 2 
2 4
3
x
4
1 3 1
Fläche rechtes Rechteck 𝑥 · ·
2 4 2
Kreisfläche Rechtecknäherung (III)
Fläche Fläche
linkes rechtes
Rechteck Rechteck
 1 1 1 3 1
  x     0,93301
4 2 2 2 4 2
  3, 73205 © Prof. Dr. Steffen Heinzl
Aufgabe
 Rechtecknäherung
Hinweis für das Übungsblatt:
Berechnen Sie den Flächeninhalt zu obenstehender Zeichnung
(auf Papier)!

Lektion 5 - Do-while-Schleife, Modellierung, Quadratwurzelberechnung, Pi-Berechnung

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Lektion 5 - Do-while-Schleife, Modellierung, Quadratwurzelberechnung, Pi-Berechnung

Hochgeladen von

Copyright:

Verfügbare Formate

Lektion

for (;;) while(true) do

Das könnte Ihnen auch gefallen