Lazarus/Schleifen: Unterschied zwischen den Versionen

Aus ZUM-Unterrichten
main>Peterdauscher
Keine Bearbeitungszusammenfassung
K (Matthias Scharwies verschob die Seite Lazarus-Buch/Schleifen nach Lazarus/Schleifen: kürzere URL)
 
(35 dazwischenliegende Versionen von 4 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
{{Lazarus-Buch}}
== Zählschleifen ==
Mit Hilfe von Alternativen (<code>if-then-else</code>) konnten wir Programme so steuern, dass bestimmte Anweisungen nur unter ganz bestimmten Bedingungen ausgeführt wurden, andernfalls nicht. Allerdings wurde die gleiche Anweisung (bei ein und demselben Knopfdruck) immer nur ein einziges Mal ausgeführt.
 
Wir starten ein neues Lazarus-Projekt und betrachten ein mehrzeiliges Eingabe-Feld, ein so genanntes Memo-Feld (TMemo). Wir wollen, dass dem Memo-Feld <tt>Memo1</tt> beim Druck auf den Knopf <tt>Button1</tt> jeweils eine Zeile mit dem Wort "Hallo" hinzugefügt wird.
 
Dafür ändern wir die Prozedur <tt>TForm1.Button1Click(Sender: TObject); </tt> wie folgt. (Es ist nur die entscheidende Prozedur vermerkt, den Rest kennst Du mittlerweile).
 
<source  line start="33" highlight="3" lang="pascal">
procedure TForm1.Button1Click(Sender: TObject);
begin
  Memo1.Lines.Add('Hallo');
end;   
</source>


== Zählschleifen ==
Mit Hilfe von Alternativen (if-then-else) konnten wir Programme so steuern, dass bestimmte Anweisungen nur unter ganz bestimmten Bedingungen ausgeführt wurden, andernfalls nicht. Allerdings wurde die gleiche Anweisung (bei ein und demselben Knopfdruck) immer nur ein einziges Mal ausgeführt.


Bei vielen Dingen ist es jedoch sinnvoll, wenn Dinge mehrfach ausgeführt werden. Nicht umsonst heißt es: "Ein Computer ist unglaublich dumm, aber sehr sehr fleißig". So könnte eine sehr einfache Aufgabe an den Computer lauten, er solle die Zahlen von 1 bis 10 nacheinander in das Memo-Feld <tt>Memo1</tt> schreiben. Natürlich könnten wir den Befehl <tt>writeLnTo(Memo1,1)</tt> zehn mal untereinander kopieren und dann die Zahlen zwischen den Klammern verändern. Aber das wäre sehr sehr lästige -- und schlimmer noch -- langweilige Arbeit.
Bei vielen Dingen ist es jedoch sinnvoll, wenn Dinge mehrfach ausgeführt werden. Nicht umsonst heißt es: "Ein Computer ist unglaublich dumm, aber sehr sehr fleißig". So könnte eine sehr einfache Aufgabe an den Computer lauten, er solle das Wort "Hallo" 10 mal untereinander in das Memo-Feld <tt>Memo1</tt> schreiben.  


Natürlich könnten wir den Befehl <tt>Memo1.Lines.Add('Hallo');</tt> zehn mal untereinander kopieren. Aber das wäre sehr sehr lästige -- und schlimmer noch -- langweilige Arbeit.
Viel bequemer ist es dagegen, wenn wir dem Computer sagen:  
Viel bequemer ist es dagegen, wenn wir dem Computer sagen:  


"Es gibt eine Variable <tt>zaehler</tt>. Setze diese Variable zunächst auf 1 und zähle sie dann schrittweise auf 10 hoch. Nach jedem Zählschritt schreibe den Wert der Variable in das Memo-Feld." Genau dies tut das folgende Programm. (Es ist nur die entscheidende Prozedur vermerkt, den Rest kennst Du mittlerweile).
"Es gibt eine Variable <tt>zaehler</tt>. Setze diese Variable zunächst auf 1 und zähle sie dann schrittweise auf 10 hoch. Nach jedem Zählschritt schreibe das Wort "Hallo" in das Memo-Feld." Genau dies tut das folgende Programm.  
 
<source  line start="33" highlight="3-4" lang="pascal">
procedure TForm1.Button1Click(Sender: TObject);
begin
for zaehler:=1 to 10
do Memo1.Lines.Add('Hallo');
end;                     
</source>


Allerdings musst Du noch bei der Liste der Variablen die Variable <tt>zaehler</tt> als Integer-Variable deklarieren:
<tt>zaehler : integer;</tt>
Wenn Du nicht jedes Mal wieder zur Variablenliste springen willst, kannst Du die Variable auch direkt in der Prozedur vor dem <tt>begin</tt> deklarieren. Dann allerdings kennt Lazarus diese Variable tatsächlich nur innerhalb dieser Prozedur. Beim nächsten Beispiel ist dies so gemacht.


{{kasten_blau|<source  line start="30" highlight="5-6" lang="pascal">
Dieses Beispiel zeigt, wie bei jedem Zählschritt auch mehrere Anweisungen ausgeführt werden können: die muss man hier wieder mit <tt>begin</tt> und <tt>end</tt> zu einem Anweisungsblock gruppieren:
<source  line start="33" highlight="5-8" lang="pascal">
procedure TForm1.Button1Click(Sender: TObject);
procedure TForm1.Button1Click(Sender: TObject);
var zaehler : integer;
var zaehler : integer;
begin
begin
Clear(Memo1);
for zaehler:=1 to 10
for zaehler := 1 to 10
do begin
do WriteLnTo(Memo1,zaehler);
  Memo1.Lines.Add('Hallo');
end;                    
  Memo1.Lines.Add('==========')
</source>}}
  end;  
end;                    
</source>
 
Und ganz wichtig: Die Variable <tt>zaehler</tt> kann im Programm auch verwendet werden. Zum Beispiel, um die "Hallo-Welt"-Ausrufe durchzunummerieren. Da die Nummer und das "Hallo" durchaus in eine Zeile passen, kann man beide dem "+"-Zeichen verbinden und in ein- und dasselbe "Add" hineinschreiben:


Auch hier können bei jedem Zählschritt auch mehrere Anweisungen ausgeführt werden; die muss man hier wieder mit <tt>begin</tt> und <tt>end</tt> zu einem Anweisungsblock gruppieren:
<source  line start="33" highlight="7" lang="pascal">
{{kasten_blau|<source  line start="30" highlight="5-9" lang="pascal">
procedure TForm1.Button1Click(Sender: TObject);
procedure TForm1.Button1Click(Sender: TObject);
var zaehler : integer;
var zaehler : integer;
begin
begin
Clear(Memo1);
Memo1.Lines.Clear;
for zaehler := 1 to 10
for zaehler:=1 to 10
do begin
do begin
   WriteTo(Memo1,zaehler);
   Memo1.Lines.Add(IntToStr(zaehler)+' Hallo');
   WriteLnTo(Memo1,'. Runde)
   Memo1.Lines.Add('===============');
   end;
   end;
end;                    
end;  
</source>}}
</source>      
 
Außerdem sorgt bei diesem Beispiel die Zeile <tt>Memo1.Lines.Clear;</tt> in Zeile 36 dafür, dass das Feld vor dem Beschreiben gesäubert wird und das (vielleicht lästigte) <tt>Memo1</tt> verschwindet.


== Schleifen mit Eingangsbedingung (while-Schleifen)==
== Schleifen mit Eingangsbedingung (while-Schleifen)==
Nehmen wir an, ein (recht phantasieloser) Lehrer gäbe seinen Schüler die Stillarbeit, so viele aufeinanderfolgende Zahlen zu addieren und die Zwischenergebnisse zu notieren, bis die Summe den Wert 1000 erreicht. Schüler Fritz hat sein Netbook im Ranzen und will das Problem mit Lazarus lösen. Das Problem: Er kann jetzt natürlich auf gut Glück ungefähr raten, bis zu welcher Zahl er die Zahlen addieren muss und dies mit einer for-Schleife tun. Aber es muss doch auch eine andere Möglichkeit geben, nämlich, dass der Computer selbst merkt, wenn das Ergebnis erreicht ist. Tatsächlich gibt es diese Möglichkeit:
Nehmen wir an, ein (recht phantasieloser) Lehrer gäbe seinen Schüler die Stillarbeit, so viele aufeinanderfolgende Zahlen zu addieren und die Zwischenergebnisse zu notieren, bis die Summe den Wert 1000 erreicht. Schüler Fritz hat sein Netbook im Ranzen und will das Problem mit Lazarus lösen. Das Problem: Er kann jetzt natürlich auf gut Glück ungefähr raten, bis zu welcher Zahl er die Zahlen addieren muss und dies mit einer for-Schleife tun. Aber es muss doch auch eine andere Möglichkeit geben, nämlich, dass der Computer selbst merkt, wenn das Ergebnis erreicht ist. Tatsächlich gibt es diese Möglichkeit.


{{kasten_blau|<source  line start="30" highlight="6-15" lang="pascal">
<source  highlight="5,9" line start="33" lang="pascal">
procedure TForm1.Button1Click(Sender: TObject);
procedure TForm1.Button1Click(Sender: TObject);
var zaehler : integer;
var zaehler, summe : integer;
    summe : integer;
begin
begin
Clear(Memo1);
Memo1.Lines.Clear;
zaehler:=0;
zaehler:=0;
summe:=0;
summe:=0;
Zeile 50: Zeile 77:
   zaehler:=zaehler+1;
   zaehler:=zaehler+1;
   summe:=summe+zaehler;
   summe:=summe+zaehler;
   WriteTo(Memo1,zaehler);
   Memo1.Lines.Add(IntToStr(zaehler)+':'+IntToStr(summe));
  WriteTo(Memo1,':');
  WriteLnTo(Memo1,summe);
   end;
   end;
end;            
end;              
</source>}}
</source>


Man erkennt deutliche Unterschiede: Die Schleife, so heißt es in dem Programm, wird so lange wiederholt, solange die Summe noch einen Wert kleiner als 1000 hat. Das Setzen des Zählers auf 0 am Anfang und das Hochzählen in jedem einzelnen Schritt, muss der Programmierer hier selbst übernehmen (Zeilen 35 bzw. 39).
Man erkennt deutliche Unterschiede: Die Schleife, so heißt es in dem Programm, wird so lange wiederholt, solange die Summe noch einen Wert kleiner als 1000 hat. Das Setzen des Zählers auf 0 am Anfang und das Hochzählen in jedem einzelnen Schritt, muss der Programmierer hier selbst übernehmen (Zeilen 37 bzw. 41).


'''Wichtige Anmerkung''':
'''Wichtige Anmerkung''':
Angenommen, man würde in Zeile 36 den anfänglichen Wert der Variable <tt>summe</tt> auf 1000 setzen, so würde der Computer sozusagen gar nicht erst mit der Schleife anfangen, sondern alles zwischen <tt>while</tt> und dem <tt>end</tt> der Schleife überspringen. Denn die Schleife soll ja nur solange ausgeführt werden, solange die Bedingung <tt>summe<1000</tt> erfüllt ist. Und das wäre sie in diesem Fall ja von Anfang an nicht. Deshalb spricht man bei der while-Schleife auch von einer Schleife mit Eingangsbedingung.
Angenommen, man würde in Zeile 38 den anfänglichen Wert der Variable <tt>summe</tt> auf 1000 setzen, so würde der Computer sozusagen gar nicht erst mit der Schleife anfangen, sondern alles zwischen <tt>while</tt> und dem <tt>end</tt> der Schleife überspringen. Denn die Schleife soll ja nur solange ausgeführt werden, solange die Bedingung <tt>summe<1000</tt> erfüllt ist. Und das wäre sie in diesem Fall ja von Anfang an nicht. Deshalb spricht man bei der while-Schleife auch von einer Schleife mit Eingangsbedingung.


== Schleifen mit Abbruchbedingung (repeat-until-Schleifen) ==
== Schleifen mit Abbruchbedingung (repeat-until-Schleifen) ==
Zeile 66: Zeile 91:
Anders ist es bei Schleifen mit Abbruchsbedingung. Bei denen wird das Innere der Schleife mindestens einmal durchlaufen. Eine solche Schleife ist in Pascal die so genannte Repeat-Until-Schleife. Unser Problem mit dem Aufsummieren von Zahlen bis zur Summe 1000 könnte mit einer solchen Schleife so aussehen:
Anders ist es bei Schleifen mit Abbruchsbedingung. Bei denen wird das Innere der Schleife mindestens einmal durchlaufen. Eine solche Schleife ist in Pascal die so genannte Repeat-Until-Schleife. Unser Problem mit dem Aufsummieren von Zahlen bis zur Summe 1000 könnte mit einer solchen Schleife so aussehen:


{{kasten_blau|<source line start="30" highlight="6-14" lang="pascal">procedure TForm1.Button1Click(Sender: TObject);
<source highlight="6,10" line start="33" lang="pascal">procedure TForm1.Button1Click(Sender: TObject);
var zaehler : integer;
    summe : integer;
begin
begin
Clear(Memo1);
Memo1.Lines.Clear;
zaehler:=0;
zaehler:=0;
summe:=0;
summe:=0;
Zeile 76: Zeile 99:
   zaehler:=zaehler+1;
   zaehler:=zaehler+1;
   summe:=summe+zaehler;
   summe:=summe+zaehler;
   WriteTo(Memo1,zaehler);
   Memo1.Lines.Add(IntToStr(zaehler)+':'+IntToStr(summe));
  WriteTo(Memo1,':');
  WriteLnTo(Memo1,summe);
   until summe>1000;
   until summe>1000;
end;     
end;     
</source>}}
</source>


Das Programm verhält sich haargenau wie das Programm mit der While-Schleife. Solange man nicht die Summe vorher größer oder gleich 1000 wählt. Würde man das tun, würde zumindest ein Summations- und Schreibschritt ausgeführt und erst dann die Schleife abgebrochen.
Das Programm verhält sich haargenau wie das Programm mit der While-Schleife. Solange man nicht die Summe vorher größer oder gleich 1000 wählt. Würde man das tun, würde zumindest ein Summations- und Schreibschritt ausgeführt und erst dann die Schleife abgebrochen.


{{Aufgabe|1=
#'''Begrenztes Zählen'''<br>Ändere das einfache Zählprogramm mit for-Schleife so ab, dass man in einem Edit-Feld angeben kann, bis zu welcher Zahl der Computer zählen soll.
#'''Wirtschaft: Zins und Zinseszins'''<br>Karin bekommt 100 Euro geschenkt. Sie legt sie auf der Bank an mit einem Zinssatz von <nowiki>2.3%</nowiki> (Jahreszins). Ein Programm soll ihr sagen, nach wievielen Jahren sich die Summe verdoppelt hat (oder mehr).
#'''Physik: Radioaktiver Zerfall'''<br>Bei radioaktiven Stoffen spricht man von der Halbwertszeit, das ist die Zeit, nach der ein Stoff nur noch halb soviel strahlt. Schreibe ein Programm, das die Halbwertszeit (in Jahren) vom Benutzer erfragt und dann ausrechnet, nach wievielen Jahren die Strahlung auf ein Hundertstel zurückgegangen ist.
#'''Mathematik: Logarithmentafel'''<br>In grauer Vorzeit (bis zur Erfindung des Taschenrechners) hatte man sogenannte Logarithmentafeln, in denen die Werte der Logarithmusfunktion tabelliert waren, also eine Tabelle mit x und ln x als Spalten. Schreibe ein Programm, das eine solche Tafel ausdruckt (für x-Werte 0.01, 0.02 . . . 1.00).
#'''Mathematik: Fakultät'''<br>Die Fakultät einer Zahl n (geschrieben als n!) ist definiert als <math> n!= 1 \cdot 2 \cdot 3 \cdot \ldots \cdot n</math> <br /> Schreibe ein Programm, das nach Eingabe einer Zahl n die Fakultät ausrechnet. Was passiert bei großen Werten für n?
#'''Mathematik: Berechnung der Kreiszahl <math>\pi</math>'''<br>Der Mathematiker Leibniz fand eine Methode, die Zahl π näherungsweise zu berechnen.<br/> Es gilt: <math>\frac{\pi}{4}=1-\frac{1}{3}+\frac{1}{5}-\frac{1}{7}+\frac{1}{9}-\ldots </math><br/> Schreibe ein Programm, das diesen langen Ausdruck bis zum Summanden <math>\frac{1}{401}</math> ausrechnet. Vergleiche die Zahl mit dem Ergebnis Deines Taschenrechners.
#'''Spiele: Würfel-Möglichkeiten'''<br>Zwei Würfel werden geworfen. Schreibe ein Programm, dass alle Möglichkeiten ausgibt, wie die beiden Augenzahlen aussehen können (also etwa: (1,1), (1,2), (1,3), ... (6,6)).}}


==Aufgaben==
#Ändere das einfache Zählprogramm mit for-Schleife so ab, dass man in einem Edit-Feld angeben kann, bis zu welcher Zahl der Computer zählen soll.


{{Lazarus-Buch}}
{{Lazarus-Buch}}

Aktuelle Version vom 10. August 2019, 06:20 Uhr

Zählschleifen

Mit Hilfe von Alternativen (if-then-else) konnten wir Programme so steuern, dass bestimmte Anweisungen nur unter ganz bestimmten Bedingungen ausgeführt wurden, andernfalls nicht. Allerdings wurde die gleiche Anweisung (bei ein und demselben Knopfdruck) immer nur ein einziges Mal ausgeführt.

Wir starten ein neues Lazarus-Projekt und betrachten ein mehrzeiliges Eingabe-Feld, ein so genanntes Memo-Feld (TMemo). Wir wollen, dass dem Memo-Feld Memo1 beim Druck auf den Knopf Button1 jeweils eine Zeile mit dem Wort "Hallo" hinzugefügt wird.

Dafür ändern wir die Prozedur TForm1.Button1Click(Sender: TObject); wie folgt. (Es ist nur die entscheidende Prozedur vermerkt, den Rest kennst Du mittlerweile).

procedure TForm1.Button1Click(Sender: TObject);
begin
  Memo1.Lines.Add('Hallo');
end;


Bei vielen Dingen ist es jedoch sinnvoll, wenn Dinge mehrfach ausgeführt werden. Nicht umsonst heißt es: "Ein Computer ist unglaublich dumm, aber sehr sehr fleißig". So könnte eine sehr einfache Aufgabe an den Computer lauten, er solle das Wort "Hallo" 10 mal untereinander in das Memo-Feld Memo1 schreiben.

Natürlich könnten wir den Befehl Memo1.Lines.Add('Hallo'); zehn mal untereinander kopieren. Aber das wäre sehr sehr lästige -- und schlimmer noch -- langweilige Arbeit. Viel bequemer ist es dagegen, wenn wir dem Computer sagen:

"Es gibt eine Variable zaehler. Setze diese Variable zunächst auf 1 und zähle sie dann schrittweise auf 10 hoch. Nach jedem Zählschritt schreibe das Wort "Hallo" in das Memo-Feld." Genau dies tut das folgende Programm.

procedure TForm1.Button1Click(Sender: TObject);
begin
for zaehler:=1 to 10
do Memo1.Lines.Add('Hallo');
end;

Allerdings musst Du noch bei der Liste der Variablen die Variable zaehler als Integer-Variable deklarieren: zaehler : integer; Wenn Du nicht jedes Mal wieder zur Variablenliste springen willst, kannst Du die Variable auch direkt in der Prozedur vor dem begin deklarieren. Dann allerdings kennt Lazarus diese Variable tatsächlich nur innerhalb dieser Prozedur. Beim nächsten Beispiel ist dies so gemacht.

Dieses Beispiel zeigt, wie bei jedem Zählschritt auch mehrere Anweisungen ausgeführt werden können: die muss man hier wieder mit begin und end zu einem Anweisungsblock gruppieren:

procedure TForm1.Button1Click(Sender: TObject);
var zaehler : integer;
begin
for zaehler:=1 to 10
do begin
   Memo1.Lines.Add('Hallo');
   Memo1.Lines.Add('==========');   
   end; 
end;

Und ganz wichtig: Die Variable zaehler kann im Programm auch verwendet werden. Zum Beispiel, um die "Hallo-Welt"-Ausrufe durchzunummerieren. Da die Nummer und das "Hallo" durchaus in eine Zeile passen, kann man beide dem "+"-Zeichen verbinden und in ein- und dasselbe "Add" hineinschreiben:

procedure TForm1.Button1Click(Sender: TObject);
var zaehler : integer;
begin
Memo1.Lines.Clear;
for zaehler:=1 to 10
do begin
   Memo1.Lines.Add(IntToStr(zaehler)+' Hallo');
   Memo1.Lines.Add('===============');
   end;
end;

Außerdem sorgt bei diesem Beispiel die Zeile Memo1.Lines.Clear; in Zeile 36 dafür, dass das Feld vor dem Beschreiben gesäubert wird und das (vielleicht lästigte) Memo1 verschwindet.

Schleifen mit Eingangsbedingung (while-Schleifen)

Nehmen wir an, ein (recht phantasieloser) Lehrer gäbe seinen Schüler die Stillarbeit, so viele aufeinanderfolgende Zahlen zu addieren und die Zwischenergebnisse zu notieren, bis die Summe den Wert 1000 erreicht. Schüler Fritz hat sein Netbook im Ranzen und will das Problem mit Lazarus lösen. Das Problem: Er kann jetzt natürlich auf gut Glück ungefähr raten, bis zu welcher Zahl er die Zahlen addieren muss und dies mit einer for-Schleife tun. Aber es muss doch auch eine andere Möglichkeit geben, nämlich, dass der Computer selbst merkt, wenn das Ergebnis erreicht ist. Tatsächlich gibt es diese Möglichkeit.

procedure TForm1.Button1Click(Sender: TObject);
var zaehler, summe : integer;
begin
Memo1.Lines.Clear;
zaehler:=0;
summe:=0;
while summe<1000
do begin
   zaehler:=zaehler+1;
   summe:=summe+zaehler;
   Memo1.Lines.Add(IntToStr(zaehler)+':'+IntToStr(summe));
   end;
end;

Man erkennt deutliche Unterschiede: Die Schleife, so heißt es in dem Programm, wird so lange wiederholt, solange die Summe noch einen Wert kleiner als 1000 hat. Das Setzen des Zählers auf 0 am Anfang und das Hochzählen in jedem einzelnen Schritt, muss der Programmierer hier selbst übernehmen (Zeilen 37 bzw. 41).

Wichtige Anmerkung: Angenommen, man würde in Zeile 38 den anfänglichen Wert der Variable summe auf 1000 setzen, so würde der Computer sozusagen gar nicht erst mit der Schleife anfangen, sondern alles zwischen while und dem end der Schleife überspringen. Denn die Schleife soll ja nur solange ausgeführt werden, solange die Bedingung summe<1000 erfüllt ist. Und das wäre sie in diesem Fall ja von Anfang an nicht. Deshalb spricht man bei der while-Schleife auch von einer Schleife mit Eingangsbedingung.

Schleifen mit Abbruchbedingung (repeat-until-Schleifen)

Anders ist es bei Schleifen mit Abbruchsbedingung. Bei denen wird das Innere der Schleife mindestens einmal durchlaufen. Eine solche Schleife ist in Pascal die so genannte Repeat-Until-Schleife. Unser Problem mit dem Aufsummieren von Zahlen bis zur Summe 1000 könnte mit einer solchen Schleife so aussehen:

procedure TForm1.Button1Click(Sender: TObject);
begin
Memo1.Lines.Clear;
zaehler:=0;
summe:=0;
   repeat
   zaehler:=zaehler+1;
   summe:=summe+zaehler;
   Memo1.Lines.Add(IntToStr(zaehler)+':'+IntToStr(summe));
   until summe>1000;
end;

Das Programm verhält sich haargenau wie das Programm mit der While-Schleife. Solange man nicht die Summe vorher größer oder gleich 1000 wählt. Würde man das tun, würde zumindest ein Summations- und Schreibschritt ausgeführt und erst dann die Schleife abgebrochen.


Aufgabe
  1. Begrenztes Zählen
    Ändere das einfache Zählprogramm mit for-Schleife so ab, dass man in einem Edit-Feld angeben kann, bis zu welcher Zahl der Computer zählen soll.
  2. Wirtschaft: Zins und Zinseszins
    Karin bekommt 100 Euro geschenkt. Sie legt sie auf der Bank an mit einem Zinssatz von 2.3% (Jahreszins). Ein Programm soll ihr sagen, nach wievielen Jahren sich die Summe verdoppelt hat (oder mehr).
  3. Physik: Radioaktiver Zerfall
    Bei radioaktiven Stoffen spricht man von der Halbwertszeit, das ist die Zeit, nach der ein Stoff nur noch halb soviel strahlt. Schreibe ein Programm, das die Halbwertszeit (in Jahren) vom Benutzer erfragt und dann ausrechnet, nach wievielen Jahren die Strahlung auf ein Hundertstel zurückgegangen ist.
  4. Mathematik: Logarithmentafel
    In grauer Vorzeit (bis zur Erfindung des Taschenrechners) hatte man sogenannte Logarithmentafeln, in denen die Werte der Logarithmusfunktion tabelliert waren, also eine Tabelle mit x und ln x als Spalten. Schreibe ein Programm, das eine solche Tafel ausdruckt (für x-Werte 0.01, 0.02 . . . 1.00).
  5. Mathematik: Fakultät
    Die Fakultät einer Zahl n (geschrieben als n!) ist definiert als
    Schreibe ein Programm, das nach Eingabe einer Zahl n die Fakultät ausrechnet. Was passiert bei großen Werten für n?
  6. Mathematik: Berechnung der Kreiszahl
    Der Mathematiker Leibniz fand eine Methode, die Zahl π näherungsweise zu berechnen.
    Es gilt:
    Schreibe ein Programm, das diesen langen Ausdruck bis zum Summanden ausrechnet. Vergleiche die Zahl mit dem Ergebnis Deines Taschenrechners.
  7. Spiele: Würfel-Möglichkeiten
    Zwei Würfel werden geworfen. Schreibe ein Programm, dass alle Möglichkeiten ausgibt, wie die beiden Augenzahlen aussehen können (also etwa: (1,1), (1,2), (1,3), ... (6,6)).