Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Algorithmische Grundstrukturen IFB 2002 Klaus Becker.

Ähnliche Präsentationen


Präsentation zum Thema: "Algorithmische Grundstrukturen IFB 2002 Klaus Becker."—  Präsentation transkript:

1 Algorithmische Grundstrukturen IFB 2002 Klaus Becker

2 KB Algorithmische Grundstrukturen 2 Teil 1 Algorithmisches Problemlösen

3 KB Algorithmische Grundstrukturen 3 Problem Eine Lokomotive soll die auf Gleis A (oben) befindlichen Wagen in umgekehrter Reihenfolge auf Gleis B (unten) abstellen. AZ ZZ B ? Problem: AZ ZZ Barriere Ausgangszustand Zielzustand B ZZ

4 KB Algorithmische Grundstrukturen 4 Problemspezifikation AZ ZZ Problem: Problemspezifikation: vollständige und eindeutige Beschreibung des Ausgangs- und Zielzustandes Problemspezifikation: vollständige und eindeutige Beschreibung des Ausgangs- und Zielzustandes

5 KB Algorithmische Grundstrukturen 5 Problemlösen mit einem Prozessor AZ ZZ Prozessor: legt die zulässigen Operationen fest Lokomotive: fahren; ankoppeln; abkoppeln; Weiche stellen;..

6 KB Algorithmische Grundstrukturen 6 Algorithmus AZ ZZ Algorithmus: Problemlösebeschreibung Algorithmus: endliche Folge von eindeutig ausführbaren Anweisungen zur Lösung des Problems Algorithmus: endliche Folge von eindeutig ausführbaren Anweisungen zur Lösung des Problems

7 KB Algorithmische Grundstrukturen 7 Korrektheit AZ ZZ Spezifikation: Korrektheit bzgl. einer Spezifikation: Algorithmus überführt tatsächlich den AZ in den ZZ (für alle möglichen AZ-Konstellationen) Korrektheit bzgl. einer Spezifikation: Algorithmus überführt tatsächlich den AZ in den ZZ (für alle möglichen AZ-Konstellationen)

8 KB Algorithmische Grundstrukturen 8 Effizienz AZ ZZ Spezifikation: Effizienz: Algorithmus löst das Problem mit möglichst geringen Aufwand Effizienz: Algorithmus löst das Problem mit möglichst geringen Aufwand

9 KB Algorithmische Grundstrukturen 9 Ziele Wie sind Algorithmen zur Lösung von Problemen aufgebaut? Grundbausteine von Algorithmen Wie formuliert man Algorithmen, so dass sie vom Computer ausgeführt werden können? Grundelemente von Programmiersprachen Einschränkungen - imperative Algorithmen - Pascal als Programmiersprache

10 KB Algorithmische Grundstrukturen 10 Teil 2 Variablenkonzept

11 KB Algorithmische Grundstrukturen 11 Mäusepopulation Wir betrachten die Entwicklung einer Mäusepopulation. Die Population wird unterteilt in junge Mäuse, erwachsene Mäuse und alte Mäuse. Wir gehen von den folgenden Annahmen aus: - In einem Simulationsschritt wird die Hälfte der jungen Mäuse erwachsen. - In einem Simulationsschritt erzeugt jede erwachsene Maus (im Durchschnitt) 4 junge Mäuse. Nur ein Drittel der erwachsenen Mäuse wird in einem Simulationsschritt alt. - In einem Simulationsschritt erzeugt jede alte Maus (im Durchschnitt) 2 junge Mäuse. Alle alten Mäuse sterben innerhalb dieses Simulationsschrittes. Wir betrachten die Entwicklung einer Mäusepopulation. Die Population wird unterteilt in junge Mäuse, erwachsene Mäuse und alte Mäuse. Wir gehen von den folgenden Annahmen aus: - In einem Simulationsschritt wird die Hälfte der jungen Mäuse erwachsen. - In einem Simulationsschritt erzeugt jede erwachsene Maus (im Durchschnitt) 4 junge Mäuse. Nur ein Drittel der erwachsenen Mäuse wird in einem Simulationsschritt alt. - In einem Simulationsschritt erzeugt jede alte Maus (im Durchschnitt) 2 junge Mäuse. Alle alten Mäuse sterben innerhalb dieses Simulationsschrittes.

12 KB Algorithmische Grundstrukturen 12 Entwicklung der Mäusepopulation SchrittAnzahl der Anzahl derAnzahl der jungen Mäuseerw. Mäusealten Mäuse = 4*9 + 2*123 = 6:23 = 9:3 218 = 4*3 + 2*3 30 = 60:21 = 3: = 4*30 + 2*1 9 = 18:210 = 30:3 456 = 4*9 + 2*10 61 = 122:23 = 9: = 4*61 + 2*3 28 = 56:220,3.. = 61:3... Ziel: Automatisierung der Berechnung Berechnungsmodell

13 KB Algorithmische Grundstrukturen 13 Berechnungsmodell Register (Speicherplatz) Variable (Name des Registers) Schritt: jung: erwachsen: alt: integer-Register real-Register Berechnungsmodell: Variablen-basierte Registermaschine

14 KB Algorithmische Grundstrukturen 14 Variablendeklaration Schritt: integer... jung: real... erwachsen: real... alt: real... Register (Speicherplatz) Datentyp (legt zulässigen Registerinhalte fest) Variable (Name des Registers) Eine Variablendeklaration legt die zu benutzenden Register fest. Schritt: jung: erwachsen: alt:

15 KB Algorithmische Grundstrukturen 15 Variablenwert Schritt: jung: erwachsen: alt: {Schritt: [0]; jung: [6.0]; erwachsen: [9.0]; alt: [...]} Kurzschreibweise für Variablenzustände: Variablenzustand: Gesamtheit der Variablenwerte Der Variablenwert stellt den Registerinhalt dar.

16 KB Algorithmische Grundstrukturen 16 Wertzuweisung alt := 12.0 vorher Wertzuweisung {Schritt: [0]; jung: [6.0]; erwachsen: [...]; alt: [...]} nachher{Schritt: [0]; jung: [6.0]; erwachsen: [...]; alt: [12.0]} erwachsen := jung / 2 vorher Wertzuweisung {Schritt: [0]; jung: [6.0]; erwachsen: [...]; alt: [12.0]} nachher{Schritt: [0]; jung: [6.0]; erwachsen: [3.0]; alt: [12.0]} Schritt := Schritt +1 vorher Wertzuweisung {Schritt: [0]; jung: [6.0]; erwachsen: [3.0]; alt: [12.0]} nachher{Schritt: [1]; jung: [6.0]; erwachsen: [3.0]; alt: [12.0]} Mit Wertzuweisungen werden Variablenwerte verändert.

17 KB Algorithmische Grundstrukturen 17 Wertzuweisung Semantik:Syntax: := Schritt := Schritt +1 Beachte: Variable und Term müssen typkonform sein. Der Wert des Terms wird bzgl. des aktuellen Variablenzustands ermittelt und der Variablen als neuer Wert zugewiesen. (Überschreiben des Registers) { Schritt: [3];...} 4 { Schritt: [4];...} Beispiel: Schritt := Schritt +1

18 KB Algorithmische Grundstrukturen 18 Problemspezifikation AZ: Die eingeführten Variablen beschreiben die Anfangspopulation. {Schritt: [0]; jung: [6.0]; erwachsen: [9.0]; alt: [12.0]} EZ: Die Variablen beschreiben die Population nach einem Simulationsschritt.. {Schritt: [1]; jung: [60.0]; erwachsen: [3.0]; alt: [3.0]} Erweiterung: Die Anfangspopulation soll vom Benutzer vorgegeben werden. Die neue Population nach einem Simulationsschritt soll dem Benutzer angezeigt werden.

19 KB Algorithmische Grundstrukturen 19 Lösungsvorschlag 1 Variablenzustand - Trace-Tabelle Schrittjungerw.alt Wertzuweisung Schritt := Schritt + 1 jung := erwachsen*4 + alt*2 erwachsen := jung / 2 alt := erwachsen / 3 beachte: Der Algorithmus ist nicht korrekt!

20 KB Algorithmische Grundstrukturen 20 Lösungsvorschlag 2 Variablenzustand - Trace-Tabelle Schrittjungerw.althilf Wertzuweisung Schritt := Schritt + 1 hilf := erwachsen*4 + alt*2 alt := erwachsen / 3 erwachsen := jung / 2 jung := hilf beachte: Reihenfolge der Wertzuweisungen

21 KB Algorithmische Grundstrukturen 21 Algorithmus Eingabe: jung, erwachsen, alt Schritt := 0 Schritt := Schritt + 1 hilf := erwachsen*4 + alt*2 alt := erwachsen / 3 erwachsen := jung / 2 jung := hilf Ausgabe: Schritt, jung, erwachsen, alt EVA-Prinzip: Eingabe - Verarbeitung - Ausgabe E V A

22 KB Algorithmische Grundstrukturen 22 Pascal-Programm PROGRAM Maeuse1; VAR Schritt : integer; jung, erwachsen, alt : real; hilf : real; BEGIN { Eingaben und Initialisierungen }... { Berechnungen } Schritt := Schritt+1; hilf := erwachsen*4 + alt*2; alt := erwachsen/3; erwachsen := jung/2; jung := hilf; { Ausgaben }... END.

23 KB Algorithmische Grundstrukturen 23 Programmstruktur PROGRAM Maeuse1; VAR ; BEGIN... { Kommentar } ;... END. Deklarationsteil - erzeugt die Register Anweisungsteil - verändert die Registerinhalte Programmkopf

24 KB Algorithmische Grundstrukturen 24 Basisanweisungen BEGIN { Eingaben und Initialisierungen } writeln('Geben Sie die Anfangspopulation ein.'); write('Anzahl der jungen Mäuse : '); readln(jung); write('Anzahl der erwachsenen Mäuse : '); readln(erwachsen); write('Anzahl der alten Mäuse : '); readln(alt); Schritt := 0; { Berechnungen } Schritt := Schritt+1;... { Ausgaben } writeln('Anzahl der Schritte: ', Schritt); writeln('Anzahl der jungen Mäuse : ', jung:6:2); writeln('Anzahl der erwachsenen Mäuse : ', erwachsen:6:2); writeln('Anzahl der alten Mäuse : ', alt:6:2); END. Eingabeanweisung: read(ln) Wertzuweisung: := Ausgabeanweisung: write(ln) Eingabeanweisung: read(ln) Wertzuweisung: := Ausgabeanweisung: write(ln)

25 KB Algorithmische Grundstrukturen 25 Anweisungen - eine Übersicht Anweisung BasisanweisungKontrollanweisung Wertzuweisung Eingabeanweisung Ausgabeanweisung... Wertzuweisung Eingabeanweisung Ausgabeanweisung...

26 KB Algorithmische Grundstrukturen 26 Teil 3 Kontrollstrukturen

27 KB Algorithmische Grundstrukturen 27 Sequenzbildung {Eingabe und Initialisierung} Eingabe: jung, erwachsen, alt Schritt := 0 {Verarbeitung} Schritt := Schritt + 1 hilf := erwachsen*4 + alt*2 alt := erwachsen / 3 erwachsen := jung / 2 jung := hilf {Ausgabe} Ausgabe: Schritt, jung, erwachsen, alt

28 KB Algorithmische Grundstrukturen 28 Sequenz BEGIN ; ; ;... END PASCAL Anweisung1 Anweisung2 Anweisung3... Struktogramm Anweisung1 PAP Anweisung2 Anweisung3...

29 KB Algorithmische Grundstrukturen 29 Problemspezifikation Ziel: Die Entwicklung der Mäusepopulation soll über 20 Schritte verfolgt werden. Spezifikation Eingaben: Die Werte der Anfangspopulation werden eingegeben. Z B.: jung: 6.0; erwachsen: 9.0; alt: 12.0 Ausgaben: Die Populationswerte nach 20 Simulationsschritten werden ausgegeben.

30 KB Algorithmische Grundstrukturen 30 Wiederholung Variablenzustand Schrittjungerw.althilf Anweisung {Eingaben / Initialisierung} Schritt := Schritt + 1 hilf := erwachsen*4 + alt*2 alt := erwachsen / 3 erwachsen := jung / 2 jung := hilf Schritt := Schritt + 1 hilf := erwachsen*4 + alt*2 alt := erwachsen / 3 erwachsen := jung / 2 jung := hilf...

31 KB Algorithmische Grundstrukturen 31 Ausgabe: jung, erwachsen, alt, gesamt Wiederholung Eingabe: jung, erwachsen, alt gesamt := jung + erwachsen + alt Schritt := 0 Schritt := Schritt +1 hilf := erwachsen*4 + alt*2 alt := erwachsen / 3 erwachsen := jung / 2 jung := hilf gesamt := jung + erwachsen + alt SOLANGE Schritt < 20

32 KB Algorithmische Grundstrukturen 32 Wiederholung Eingabe:...; gesamt :=...; Schritt := 0 Schritt := Schritt +1 hilf := erwachsen*4 + alt*2 alt := erwachsen / 3 erwachsen := jung / 2 jung := hilf gesamt := jung + erwachsen + alt Schritt < 20 wahr falsch Ausgabe: jung, erwachsen, alt, gesamt

33 KB Algorithmische Grundstrukturen 33 Mäusepopulation Schritt < 100 Die Entwicklung der Mäusepopulation wird wie folgt abgeändert: Sind weniger als 1000 Mäuse in der Population, so verhalten sich die Mäuse wie bisher. Ab 1000 Mäuse wird das Futter knapp. Alte Mäuse erzeugen dann keine jungen Mäuse mehr und jede erwachsene Maus erzeugt (im Durchschnitt) nur noch 1.5 junge Mäuse. Spezifikation: wie oben Die Entwicklung der Mäusepopulation wird wie folgt abgeändert: Sind weniger als 1000 Mäuse in der Population, so verhalten sich die Mäuse wie bisher. Ab 1000 Mäuse wird das Futter knapp. Alte Mäuse erzeugen dann keine jungen Mäuse mehr und jede erwachsene Maus erzeugt (im Durchschnitt) nur noch 1.5 junge Mäuse. Spezifikation: wie oben

34 KB Algorithmische Grundstrukturen 34 gesamt := jung + erwachsen + alt Schritt := Schritt +1 Fallunterscheidung Eingabe: jung, erwachsen, alt gesamt := jung + erwachsen + alt Schritt := 0 hilf := erwachsen*4 + alt*2 alt := erwachsen / 3 erwachsen := jung / 2 jung := hilf SOLANGE Schritt < 20 hilf := erwachsen*1.5 alt := erwachsen / 3 erwachsen := jung / 2 jung := hilf gesamt < 1000 wahrfalsch

35 KB Algorithmische Grundstrukturen 35 Fallunterscheidung Schritt := 0;... ; gesamt := jung + erwachsen + alt hilf := erwachsen*4 + alt*2 alt := erwachsen / 3 erwachsen := jung / 2 jung := hilf Schritt < 20 hilf := erwachsen*1.5 alt := erwachsen / 3 erwachsen := jung / 2 jung := hilf gesamt < 1000 gesamt := jung + erwachsen + alt wahrfalsch wahr falsch... Schritt := Schritt + 1

36 KB Algorithmische Grundstrukturen 36 Pascal-Programm... BEGIN {Eingaben und Initialisierung};... WHILE Schritt < 20 DO BEGIN Schritt := Schritt+1; IF gesamt < 1000 THEN BEGIN hilf := erwachsen*4 + alt*2;... END ELSE BEGIN hilf := erwachsen*1.5;... END; gesamt := jung + erwachsen + alt; END; {Ausgaben}... END.

37 KB Algorithmische Grundstrukturen 37 Kontrollstrukturen Kontrollstrukturen dienen dazu, den genauen Ablauf von Aktionen festzulegen. Ablaufmuster: - sequentieller Ablauf - wiederholter Ablauf - bedingter Ablauf - paralleler Ablauf - ereignisgesteuerter Ablauf Kontrollstrukturen: - Sequenz - Wiederholung - Fallunterscheidung / Auswahl

38 KB Algorithmische Grundstrukturen 38 Anweisungen - eine Übersicht Anweisung BasisanweisungKontrollanweisung Wertzuweisung Eingabeanweisung Ausgabeanweisung... Wertzuweisung Eingabeanweisung Ausgabeanweisung... Sequenzanweisung Wiederholungs- anweisung Fallunterscheidungs- anweisung Sequenzanweisung Wiederholungs- anweisung Fallunterscheidungs- anweisung...

39 KB Algorithmische Grundstrukturen 39 Schachtelung von Anweisungen BEGIN readln(jung);... WHILE Schritt < 20 DO BEGIN Schritt := Schritt+1; IF gesamt < 1000 THEN BEGIN hilf := erwachsen*4 + alt*2;... END ELSE BEGIN hilf := erwachsen*1.5;... END; gesamt := jung + erwachsen + alt; END; writeln('Anzahl der Schritte: ', Schritt);... END.

40 KB Algorithmische Grundstrukturen 40 Übungen - Aufgabe 1 AZ ZZ Formulieren Sie (umgangssprachlich) einen Algorithmus zur Lösung des Rangierproblems. Die Lokomotive kann folgende Operationen ausführen: vorwärts / rückwärts fahren; ankoppeln; abkoppeln; Weiche umstellen. Der Algorithmus soll für eine beliebige Anzahl von Waggons korrekt sein.

41 KB Algorithmische Grundstrukturen 41 Übungen - Aufgabe 2 AZ: { A: [a]; B: [b]; C: [c] } EZ: { A: [c]; B: [a]; C: [b] } Abstraktes Rangierproblem: Gegeben sind drei Variablen A, B und C. Die Werte der Variablen sollen wie folgt ausgetauscht werden: a b c A: B: C:

42 KB Algorithmische Grundstrukturen 42 Übungen - Aufgabe 3 B := A A := B Vertauschungsproblem: Die Werte der Variablen A und B sollen ausgetauscht werden: AZ: { A: [a]; B: [b] } EZ: { A: [b]; B: [a] } Beurteile die folgenden Algorithmen hinsichtlich Korrektheit und Aufwand. H := A A := B B := H C := A D := B A := D B := C A := A - B B := A + B A := B - A

43 KB Algorithmische Grundstrukturen 43 Übungen - Aufgabe 4 Mäusepopulation: Der Algorithmus / das Programm zur Beschreibung der Entwicklung der Mäusepopulation soll wie folgt abgeändert werden: A) Der jeweilige Populationszustand (Anzahl der jungen, erwachsenen und alten Mäuse) soll nach jedem Schritt ausgegeben werden. B) Nach jedem Schritt sollen die prozentualen Anteile der jungen, erwachsenen und alten Mäuse an der momentanen Gesamtpopulation berechnet und ausgegeben werden.

44 KB Algorithmische Grundstrukturen 44 Übungen - Aufgabe 5 Trace-Tabelle: Erstellen Sie eine Trace-Tabelle für die Eingaben A 10 und B 24. Was leistet der folgende Algorithmus? BEGIN Readln(A); Readln(B); REPEAT WHILE A > B DO A := A – B; WHILE B > A DO B := B – A; UNTIL A = B Writeln(A); END

45 KB Algorithmische Grundstrukturen 45 Übungen - Aufgabe 6 Problem: Eine Folge positiver Zahlen soll eingelesen und ihr Minimum bestimmt und ausgegeben werden. Das Ende der Folge wird durch die Eingabe der Zahl 0 erkannt. Bsp.: Eingabefolge: 5, 3, 6, 7, 0 Ausgabe: 3 Eingabefolge: 0 Ausgabe: 0 Ist der folgende Algorithmus korrekt? Ändern Sie ihn gegebenenfalls geeignet ab. Eingabe: z min := z SOLANGE z > 0 Eingabe: z WENN z < min DANN min := z Ausgabe: min

46 KB Algorithmische Grundstrukturen 46 Übungen - Aufgabe 7 Mit Hilfe eines Programms soll die Kapitalentwicklung bei einer Verzinsung mit einem festen Zinssatz von p = 3% berechnet werden. Problemspezifikation 1: Eingaben : Anfangskapital, Anzahl der Jahre Ausgabe : erreichtes Endkapital Problemspezifikation 2: Eingaben : Anfangskapital, Endkapital Ausgabe : Anzahl der benötigten Jahre Erstellen Sie entsprechende Algorithmen / Programme.

47 KB Algorithmische Grundstrukturen 47 Übungen - Aufgabe 8 Für Fortgeschrittene: Ziel ist es, das Spiel 17 und 4 zu simulieren. Das Spiel soll wie folgt funktionieren: In jedem Spielzug wird eine Karte mit einer Zahl aus dem Bereich [1;...;11] bestimmt und auf einen Kartenstapel gelegt. Der Spieler kann nach jedem Spielzug entscheiden, ob er aufhört oder weiter spielt. Ist die Summe der Zahlen der Karten des Stapels größer als 21, so hat der Spieler verloren. Hört der Spieler bei einer Stapelsumme kleiner oder gleich 21 auf, so wird die nächste Karte gezogen. Ist die neue Stapelsumme immer noch kleiner oder gleich 21, so hat der Spieler verloren, andernfalls gewonnen. Erstellen Sie einen passenden Algorithmus.

48 KB Algorithmische Grundstrukturen 48 Aufgabe 1 - Lösungsvorschlag Solange noch mindestens ein Waggon auf Gleis A steht: vorwärts fahren; ankoppeln; rückwärts fahren; Weiche umstellen; vorwärts fahren; abkoppeln; rückwärts fahren; Weiche umstellen.

49 KB Algorithmische Grundstrukturen 49 Aufgabe 2 - Lösungsvorschlag AZ: { A: [a]; B: [b]; C: [c] } H := A A := C C := B B := H EZ: { A: [c]; B: [a]; C: [b] } Abstraktes Rangierproblem: Gegeben sind drei Variablen A, B und C. Die Werte der Variablen sollen wie folgt ausgetauscht werden: a b c A: B: C:

50 KB Algorithmische Grundstrukturen 50 Aufgabe 3 - Lösungsvorschlag B := A A := B Vertauschungsproblem: Die Werte der Variablen A und B sollen ausgetauscht werden: AZ: { A: [a]; B: [b] } EZ: { A: [b]; B: [a] } H := A A := B B := H C := A D := B A := D B := C A := A - B B := A + B A := B - A nicht korrekt Korrekt größter Aufwand Korrekt kleinster Aufwand Korrekt nur für Zahl- Variablen

51 KB Algorithmische Grundstrukturen 51 Aufgabe 5 - Lösungsvorschlag BEGIN Readln(A); Readln(B); REPEAT WHILE A > B DO A := A – B; WHILE B > A DO B := B – A; UNTIL A = B Writeln(A); END Anw.AB Readln(A)10 Readln(B)1024 A > B ? F B > A ? W B := B - A1014 B > A ? W B := B - A10 4 B > A ? F A = B ? F A > B ? W A := A - B64 A > B ? W A := A - B24 A > B ? F B > A ? W B := B - A22 B > A ? F A = B ? W Writeln(A) -->2

52 KB Algorithmische Grundstrukturen 52 Aufgabe 6 - Lösungsvorschlag Problem: Eine Folge positiver Zahlen soll eingelesen und ihr Minimum berechnet und ausgegeben werden. Das Ende der Folge wird durch die Eingabe der Zahl 0 erkannt. Eingabe: z min := z SOLANGE z > 0 Eingabe: z WENN z < min DANN min := z Ausgabe: min Die Eingabefolge 3, 0 liefert die Ausgabe 0. Der Algorithmus ist also nicht korrekt. Eingabe: z min := z SOLANGE z > 0 WENN z < min DANN min := z Eingabe: z Ausgabe: min Die Eingabefolge 3, 0 liefert jetzt die Ausgabe 3 - so, wie es sein soll.

53 KB Algorithmische Grundstrukturen 53 Teil 4 Schleifentypen

54 KB Algorithmische Grundstrukturen 54 Kapitalberechnungen Mit Hilfe eines Programms soll die Kapitalentwicklung bei einer Verzinsung mit einem festen Zinssatz von p = 3% berechnet werden. Problemspezifikation 1: Eingaben : Anfangskapital, Anzahl der Jahre Ausgabe : erreichtes Endkapital Problemspezifikation 2: Eingaben : Anfangskapital, Endkapital Ausgabe : Anzahl der benötigten Jahre Mit Hilfe eines Programms soll die Kapitalentwicklung bei einer Verzinsung mit einem festen Zinssatz von p = 3% berechnet werden. Problemspezifikation 1: Eingaben : Anfangskapital, Anzahl der Jahre Ausgabe : erreichtes Endkapital Problemspezifikation 2: Eingaben : Anfangskapital, Endkapital Ausgabe : Anzahl der benötigten Jahre

55 KB Algorithmische Grundstrukturen 55 Programm Kapital1... BEGIN { Eingaben } write('Anfangskapital : '); readln(Kapital); write('Anzahl der Jahre : '); readln(Jahre); { Berechnungen } Zaehler := 1; WHILE Zaehler <= Jahre DO BEGIN Kapital := Kapital + Kapital * p/100; Zaehler := Zaehler + 1; END; { Ausgaben } writeln('Endkapital : ', Kapital:8:2); readln; END.

56 KB Algorithmische Grundstrukturen 56 Programm Kapital2... BEGIN { Eingaben } write('Anfangskapital : '); readln(Kapital); write('Anzahl der Jahre : '); readln(Jahre); { Berechnungen } FOR Zaehler := 1 TO Jahre DO Kapital := Kapital + Kapital * p/100; { Ausgaben } writeln('Endkapital : ', Kapital:8:2); readln; END.

57 KB Algorithmische Grundstrukturen 57 Programm Kapital3... BEGIN { Eingaben } write('Anfangskapital : '); readln(Kapital); write('Anzahl der Jahre : '); readln(Jahre); { Berechnungen } FOR Zaehler := JAHRE DOWNTO 1 DO Kapital := Kapital + Kapital * p/100; { Ausgaben } writeln('Endkapital : ', Kapital:8:2); readln; END.

58 KB Algorithmische Grundstrukturen 58 falsch Zählschleife Ausgabe: Kapital Eingabe: Kapital, Jahre Kapital := Kapital +... Zaehler := Zaehler + 1 SOLANGE Zaehler <= Jahre Zaehler := 1 Zaehler<=Jahre wahr Kapital := Kapital +... Zaehler := Zaehler + 1 Eingabe: Kapital, Jahre Zaehler := 1 Ausgabe: Kapital Eingabe: Kapital, Jahre Kapital := Kapital +... FÜR Zaehler VON 1 BIS Jahre

59 KB Algorithmische Grundstrukturen 59 Programm Kapital4... BEGIN { Eingaben } write('Anfangskapital : '); readln(Anfangskapital); write('Endkapital : '); readln(Endkapital); { Berechnungen } Kapital := Anfangskapital; Jahre := 0; WHILE Kapital < Endkapital DO BEGIN Kapital := Kapital + Kapital * p/100; Jahre := Jahre + 1; END; { Ausgaben } writeln('Anzahl der Jahre : ', Jahre); readln; END.

60 KB Algorithmische Grundstrukturen 60 Programm Kapital5... BEGIN { Eingaben } write('Anfangskapital : '); readln(Anfangskapital); write('Endkapital : '); readln(Endkapital); { Berechnungen } Kapital := Anfangskapital; Jahre := 0; REPEAT Kapital := Kapital + Kapital * p/100; Jahre := Jahre + 1; UNTIL Kapital >= Endkapital; { Ausgaben } writeln('Anzahl der Jahre : ', Jahre); readln; END.

61 KB Algorithmische Grundstrukturen 61 Wiederholung Ausgabe: Jahre Eingabe: AKapital, EKapital Kapital := Kapital +... Jahre := Jahre + 1 SOLANGE Kapital < EKapital Kapital := AKapital Jahre := 0 Ausgabe: Jahre Eingabe: AKapital, EKapital Kapital := Kapital +... Jahre := Jahre + 1 BIS Kapital >= EKapital Kapital := AKapital Jahre := 0 Wiederholung mit Anfangsbedingung Wiederholung mit Endbedingung

62 KB Algorithmische Grundstrukturen 62 falsch Wiederholung Kapital=EKapital wahr Kapital := Kapital +... Jahre := Jahre + 1 Eingabe: AKapital, EKapital Jahre := 0 Ausgabe: Jahre Kapital := AKapital

63 KB Algorithmische Grundstrukturen 63 Wiederholung mit Anfangsbedingung WHILE DO PASCAL SOLANGE Bed. Anweisung StruktogrammPAP Bed. Anw w f Beachte: Erst Bedingung überprüfen, dann Anweisung ausführen!

64 KB Algorithmische Grundstrukturen 64 Wiederholung mit Endbedingung REPEAT UNTIL PASCAL Anweisung BIS Bedingung StruktogrammPAP Bed. Anw. w f Beachte: Erst Anweisung ausführen, dann Bedingung überprüfen! Die Anweisung wird mindestens einmal ausgeführt.

65 KB Algorithmische Grundstrukturen 65 Achtung: Endlosschleife... BEGIN { Eingaben } write('Anfangskapital : '); readln(Anfangskapital); write('Endkapital : '); readln(Endkapital); { Berechnungen } Kapital := Anfangskapital; Jahre := 0; WHILE Kapital < Endkapital DO BEGIN Jahre := Jahre + 1; END; { Ausgaben } writeln('Anzahl der Jahre : ', Jahre); readln; END.

66 KB Algorithmische Grundstrukturen 66 Teil 5 Fallunterscheidungstypen

67 KB Algorithmische Grundstrukturen 67 Rückerstattungsberechnungen Mit Hilfe eines Programms soll der Rückerstattungsbeitrag bei einer Versicherung berechnet werden. Folgende Rückerstattungssätze seien vereinbart: 0 bis 3 Jahre: 0 % 4 bis 5 Jahre: 10 % mehr als 5 Jahre: 15 % Problemspezifikation: Eingaben : Versicherungsbetrag, Versicherungsdauer Ausgabe : Rückerstattungsbetrag Mit Hilfe eines Programms soll der Rückerstattungsbeitrag bei einer Versicherung berechnet werden. Folgende Rückerstattungssätze seien vereinbart: 0 bis 3 Jahre: 0 % 4 bis 5 Jahre: 10 % mehr als 5 Jahre: 15 % Problemspezifikation: Eingaben : Versicherungsbetrag, Versicherungsdauer Ausgabe : Rückerstattungsbetrag

68 KB Algorithmische Grundstrukturen 68 Programm Beitrag1... BEGIN { Eingaben } write('Versicherungsbetrag : '); readln(Betrag); write('Versicherungsdauer : '); readln(Dauer); { Berechnungen } IF Dauer <= 3 THEN Erstattung := 0 ELSE IF Dauer <= 5 THEN Erstattung := 0.1 * Betrag ELSE Erstattung := 0.15 * Betrag; { Ausgaben } writeln('Rückerstattung : ', Erstattung:6:2); readln; END.

69 KB Algorithmische Grundstrukturen 69 Zweiseitige Fallunterscheidungen Ausgabe: E(erstattung) Eingabe: B(etrag), D(auer) D <= 3 D <= 5 E := 0.1 * BE := 0.15 * B E := 0 wahrfalsch wahrfalsch... IF Dauer <= 3 THEN Erstattung := 0 ELSE IF Dauer <= 5 THEN Erstattung := 0.1 * Betrag ELSE Erstattung := 0.15 * Betrag;...

70 KB Algorithmische Grundstrukturen 70 Programm Beitrag2... BEGIN { Eingaben } write('Versicherungsbetrag : '); readln(Betrag); write('Versicherungsdauer : '); readln(Dauer); { Berechnungen } IF (Dauer >= 0) AND (Dauer <= 3) THEN Erstattung := 0; IF (Dauer = 4) OR (Dauer = 5) THEN Erstattung := 0.1*Betrag; IF Dauer > 5 THEN Erstattung := 0.15 * Betrag; { Ausgaben } writeln('Rückerstattung : ', Erstattung:6:2); readln; END.

71 KB Algorithmische Grundstrukturen 71 Einseitige Fallunterscheidungen Ausgabe: E(erstattung) Eingabe: B(etrag), D(auer) D >= 0 UND D <= 3 E := 0 wahrfalsch... IF (Dauer >= 0) AND (Dauer <= 3) THEN Erstattung := 0; IF (Dauer = 4) OR (Dauer = 5) THEN Erstattung := 0.1*Betrag; IF Dauer > 5 THEN Erstattung := 0.15 * Betrag;... D = 4 ODER D = 5 E := 0.1 * B wahrfalsch D > 5 E := 0.15 * B wahrfalsch

72 KB Algorithmische Grundstrukturen 72 Mehrfachauswahl Ausgabe: E(erstattung) Eingabe: B(etrag), D(auer) D 0..3 E := 0E := 0.1 * BE := 0.15 * B... CASE Dauer OF 0..3 : Erstattung := 0; 4,5 : Erstattung := 0.1 * Betrag; ELSE Erstattung := 0.15 * Betrag; END;... 4,5sonst.

73 KB Algorithmische Grundstrukturen 73 Einseitige Fallunterscheidung IF THEN PASCAL Bed. w f StruktogrammPAP Anw Bed. Anw wf

74 KB Algorithmische Grundstrukturen 74 Zweiseitige Fallunterscheidung IF THEN ELSE PASCAL Bed. w f StruktogrammPAP Anw1 Anw2 Bed. Anw1 Anw2 wf

75 KB Algorithmische Grundstrukturen 75 Mehrfachauswahl CASE OF : ; : ;... ELSE END PASCAL Ausdruck Wert1 Wert2 sonst. Struktogramm Anw1 Anw2... Anw Beachte: Der Ausdruck muss aufzählbare Ergebnisse liefern.

76 KB Algorithmische Grundstrukturen 76 Übungen - Aufgabe 9 Problem: Eine Folge nicht-negativer Zahlen soll eingelesen und ihre Summe berechnet und ausgegeben werden. Das Ende der Folge wird durch die Eingabe einer negativen Zahl erkannt. Bsp.: Eingabefolge: 3, 6, 0, 7, -1 Ausgabe: 16 Eingabefolge: -1 Ausgabe: 0 Erstellen Sie einen Algorithmus mit einer WHILE-Schleife und einen Algorithmus mit einer REPEAT-Schleife. Warum kann der Algorithmus nicht mit einer FOR-Schleife erstellt werden? Kontrollieren Sie die Korrektheit der erstellten Algorithmen mit Hilfe einer Trace-Tabelle. Implementieren Sie einen Algorithmus in Pascal und testen Sie seine Korrektheit.

77 KB Algorithmische Grundstrukturen 77 Übungen - Aufgabe 10 A) Worin besteht der Unterschied zwischen den beiden folgenden Anweisungen? IF B1 THEN IF B2 THEN A1 ELSE A2 IF B1 THEN BEGIN IF B2 THEN A1 END ELSE A2 B) Worin besteht der Unterschied zwischen den beiden folgenden Anweisungen? IF B THEN A1; A2 IF B THEN BEGIN A1; A2 END C) Was ist hier falsch? IF B THEN A1; ELSE A2 IF B THEN A1; A2 ELSE A3

78 KB Algorithmische Grundstrukturen 78 Aufgabe 9 - Lösungsvorschlag Summe := 0 Eingabe: z SOLANGE z >= 0 Summe := Summe + z Eingabe: z Ausgabe: Summe Summe := 0 Eingabe: z WENN z >= 0 DANN WIEDERHOLE Summe := Summe + z Eingabe: z BIS z < 0 Ausgabe: Summe

79 KB Algorithmische Grundstrukturen 79 Aufgabe 10 - Lösungsvorschlag A) Worin besteht der Unterschied zwischen den beiden folgenden Anweisungen? IF B1 THEN IF B2 THEN A1 ELSE A2 IF B1 THEN BEGIN IF B2 THEN A1 END ELSE A2

80 KB Algorithmische Grundstrukturen 80 Aufgabe 10 - Lösungsvorschlag B) Worin besteht der Unterschied zwischen den beiden folgenden Anweisungen? IF B THEN A1; A2 IF B THEN BEGIN A1; A2 END C) Was ist hier falsch? IF B THEN A1; ELSE A2 IF B THEN A1; A2 ELSE A3 Ende der Anweisung

81 KB Algorithmische Grundstrukturen 81 Teil 6 Datentypen

82 KB Algorithmische Grundstrukturen 82 Siebzehn-und-Vier Ziel ist es, das Spiel 17 und 4 zu simulieren. Das Spiel soll wie folgt funktionieren: In jedem Spielzug wird eine Karte mit einer Zahl aus dem Bereich [1;...;11] bestimmt und auf einen Kartenstapel gelegt. Der Spieler kann nach jedem Spielzug entscheiden, ob er aufhört oder weiter spielt. Ist die Summe der Zahlen der Karten des Stapels größer als 21, so hat der Spieler verloren. Hört der Spieler bei einer Stapelsumme kleiner oder gleich 21 auf, so wird die nächste Karte gezogen. Ist die neue Stapelsumme immer noch kleiner oder gleich 21, so hat der Spieler verloren, andernfalls gewonnen. Ziel ist es, das Spiel 17 und 4 zu simulieren. Das Spiel soll wie folgt funktionieren: In jedem Spielzug wird eine Karte mit einer Zahl aus dem Bereich [1;...;11] bestimmt und auf einen Kartenstapel gelegt. Der Spieler kann nach jedem Spielzug entscheiden, ob er aufhört oder weiter spielt. Ist die Summe der Zahlen der Karten des Stapels größer als 21, so hat der Spieler verloren. Hört der Spieler bei einer Stapelsumme kleiner oder gleich 21 auf, so wird die nächste Karte gezogen. Ist die neue Stapelsumme immer noch kleiner oder gleich 21, so hat der Spieler verloren, andernfalls gewonnen.

83 KB Algorithmische Grundstrukturen 83 Spielablauf Karte: 8 Summe: 8 Noch eine Karte? (j/n): j Karte: 5 Summe: 13 Noch eine Karte? (j/n): j Karte: 4 Summe: 17 Noch eine Karte? (j/n): j Karte: 6 | 4 Summe: 23 | 21 verloren | gewonnen Karte: 6 Summe: 23 gewonnen Karte: 3 Summe: 20 verloren Karte: 8 Summe: 8 Noch eine Karte? (j/n): j Karte: 5 Summe: 13 Noch eine Karte? (j/n): j Karte: 4 Summe: 17 Noch eine Karte? (j/n): n Noch eine Karte? (j/n):

84 KB Algorithmische Grundstrukturen 84 Ablaufmodellierung WIEDERHOLE Karte ziehen; Summe bestimmen WENN Summe < 21 DANN Ausgabe: Noch eine Karte? (j/n): Eingabe: Antwort BIS Summe >= 21 oder Antwort = n WENN Summe >= 21 DANN WENN Summe > Ausgabe: verloren SONST Ausgabe: gewonnen SONSTKarte ziehen; Summe bestimmen WENN Summe > 21 DANN Ausgabe: gewonnen SONST Ausgabe: verloren

85 KB Algorithmische Grundstrukturen 85 Datenmodellierung Karte: integer (ganze Zahl) Summe:integer (ganze Zahl) Antwort:char (Zeichen) n

86 KB Algorithmische Grundstrukturen 86 Algorithmus - Version 1, Teil 1 Karte := random(11)+1 {Zufallszahl aus Bereich 1..11} Summe := Summe + Karte Ausgabe: Karte, Summe randomize {Initialisierung des Zufallsgenerators} Summe := 0 Ausgabe: Noch eine Karte? Eingabe: Antwort BIS (Summe >= 21) OR (Antwort = n) Summe < 21 wahrfalsch

87 KB Algorithmische Grundstrukturen 87 Algorithmus - Version 1, Teil 2 Summe >= 21 wahrfalsch Summe > 21 falsch Ausg.: verl. Ausg.: gew. wahr Karte := random(11)+1 Summe := Summe + Karte Ausgabe: Karte, Summe Summe > 21 falsch Ausg.: gew. Ausg.: verl. wahr

88 KB Algorithmische Grundstrukturen 88 Spielablauf Karte: 8 Summe: 8 Noch eine Karte? (j/n): j Karte: 5 Summe: 13 Noch eine Karte? (j/n): j Karte: 4 Summe: 17 Noch eine Karte? (j/n): j Karte: 6 | 4 Summe: 23 | 21 Spiel entschieden Karte: 6 Summe: 23 gewonnen Karte: 3 Summe: 20 verloren Karte: 8 Summe: 8 Noch eine Karte? (j/n): j Karte: 5 Summe: 13 Noch eine Karte? (j/n): j Karte: 4 Summe: 17 Noch eine Karte? (j/n): n Noch eine Karte? (j/n): Benutzer hat genug verloren | gewonnen

89 KB Algorithmische Grundstrukturen 89 Datenmodellierung Karte: integer (ganze Zahl) Summe:integer (ganze Zahl) Antwort:char (Zeichen) entschieden:boolean (Wahrheitswert) genug:boolean (Wahrheitswert) n true false

90 KB Algorithmische Grundstrukturen 90 Algorithmus - Version 2, Teil 1 Karte := random(11)+1 {Zufallszahl aus Bereich 1..11} Summe := Summe + Karte Ausgabe: Karte, Summe randomize {Initialisierung des Zufallsgenerators} Summe := 0 entschieden := false genug := false Ausgabe: Noch eine Karte? Eingabe: Antwort BIS entschieden OR genug NOT entschieden wahrfalsch entschieden := true Summe >= 21 wahrfalsch Antwort = n f genug :=true w

91 KB Algorithmische Grundstrukturen 91 Algorithmus - Version 2, Teil 1 Karte := random(11)+1 {Zufallszahl aus Bereich 1..11} Summe := Summe + Karte Ausgabe: Karte, Summe entschieden := (Summe >= 21) randomize {Initialisierung des Zufallsgenerators} Summe := 0 Ausgabe: Noch eine Karte? Eingabe: Antwort genug := (Antwort = n) BIS entschieden OR genug NOT entschieden wahrfalsch

92 KB Algorithmische Grundstrukturen 92 Algorithmus - Version 2, Teil 2 entschieden wahrfalsch Summe > 21 falsch Ausg.: verl. Ausg.: gew. wahr Karte := random(11)+1 Summe := Summe + Karte Ausgabe: Karte, Summe Summe > 21 falsch Ausg.: gew. Ausg.: verl. wahr

93 KB Algorithmische Grundstrukturen 93 Datentypen Ein Datentyp legt einen Wertebereich und die Grundoperationen, die auf die Elemente des Wertebereichs angewandt werden können, fest. Beispiele (für elementare Datentypen): > boolean (Wahrheitswert) > char(Zeichen) > integer(ganze Zahl) > real(Dezimalzahl)

94 KB Algorithmische Grundstrukturen 94 Datentyp boolean Wertebereich: {false; true} Grundoperationen: NOT, AND, OR ab a AND b falsefalsefalse falsetruefalse truefalsefalse truetruetrue aNOT a falsetrue truefalse ab a OR b falsefalsefalse falsetruetrue truefalsetrue truetruetrue

95 KB Algorithmische Grundstrukturen 95 Datentyp char Wertebereich:... siehe ASCII-Tabelle... CodeZeichenCodeZeichenCodeZeichen 0NUL33!65A B 4EOT40( Z 13CR a 27ESC...98b z

96 KB Algorithmische Grundstrukturen 96 Datentyp char Grundoperationen: ord, chr, succ, pred, =, >,, >=, <= (De)Kodieroperationen: ord: char {0;...; 255}z.B.: ord(´A´) 65 chr: {0;...; 255} charz.B.: chr(65) ´A´ Ordnungsoperationen: succ: char charz.B.: succ(´A´) ´B´ pred: char charz.B.: pred(´A´) Vergleichsoperationen: =: char, char booleanz.B.: ´A´ = ´A´ true >: char, char booleanz.B.: ´A´ > ´B´ false...

97 KB Algorithmische Grundstrukturen 97 Datentyp integer Wertebereich: ;...; Grundoperationen: +, -, *, div, mod, succ, pred, =, >, <,... Divisionsoperationen: div: ganzzahlige Division 20 div 6 = 3 80 div 7 = 11 mod: Rest bei der ganzzahligen Division 20 mod 6 = 2 80 mod 7 = 3

98 KB Algorithmische Grundstrukturen 98 Datentyp real Wertebereich:..., 1.0; -4.56; 6.3E16; -6.3E-16;... Grundoperationen: +, -, *, /, =, >, <,..., round, trunc, sqr,... Beispiele: round: real integer (Runden) round(3.84) = 4 trunc: real integer (Abschneiden) trunc(3.84) = 3 int: real real (ganzer Teil) int(3.84) = 3.0 frac: real real (Nachkommateil) frac(3.84) = 0.84

99 KB Algorithmische Grundstrukturen 99 Typumwandlung integer real: erfolgt automatisch Bsp.: VAR r: real; r := 3; real integer: trunc, round char integer: ord integer char: chr

100 KB Algorithmische Grundstrukturen 100 Übungen - Aufgabe 11 Miniprojekt Mäusepopulation: Der Algorithmus / das Programm zur Beschreibung der Entwicklung der Mäusepopulation soll wie folgt abgeändert werden: Der Benutzer kann wiederholt die Entwicklung einer Population starten. Er kann dabei jedesmal die Anfangspopulation und die Anzahl der Schritte eingeben und entscheiden, wie die Ergebnisse ausgegeben werden: A) absolute Werte: jung: 34;... B) prozentuale Werte: Gesamtanzahl: 123; jung: 30%;... C) grafische Darstellung von Anteilen: Gesamtanzahl: 145 jung: XXXXXX erwachsen: XXXXXXXXXX alt: XXX

101 KB Algorithmische Grundstrukturen 101 Übungen - Aufgabe 12 Miniprojekt Zahlenraten: Der Benutzer soll eine vom Programm vorgegebene Zahl aus dem Intervall [0; 100] mit maximal 8 Rateversuchen ermitteln. Das Programm gibt nach jedem Rateversuch eine passende Rückmeldung. Erweiterungen: A) Führen Sie eine Variable geraten vom Typ boolean ein, mit deren Hilfe das Programm gut lesbar gestaltet werden kann. B) Der Benutzer kann wiederholt das Ratespiel durchführen, ohne das Programm neu starten zu müssen. C) Der Benutzer kann selbst das Intervall, aus dem die zu erratende Zahl stammt, festlegen. Die Anzahl der Rateversuche muss dann natürlich entsprechend angepasst werden.

102 KB Algorithmische Grundstrukturen 102 Teil 7 Hinweise zum algorithmischen Problemlösen

103 KB Algorithmische Grundstrukturen 103 Ein erstes Phasenschema Spezifikation des Problems Entwicklung eines Algorithmus Implementierung des Algorithmus Validierung des Algorithmus

104 KB Algorithmische Grundstrukturen 104 Spezifikation des Problems Hinweise: Das Problem sollte möglichst genau und eindeutig beschrieben werden. Beschreibungstechniken: AZ:... Variablenwerte ZZ:... Variablenwerte; Bildschirmgestaltung Eingaben:... Ausgaben:...

105 KB Algorithmische Grundstrukturen 105 Entwicklung eines Algorithmus Hinweise: - sich Klarheit über die zu bearbeitenden und verwendenden Daten verschaffen - sich mögliche Abläufe klar machen (typische Fälle / extreme Fälle) - eine Ablaufbeschreibung mit Hilfe von Kontroll- strukturen konstruieren Entwurfsmethoden: (top-down; bottom-up; objektorientiert;...)

106 KB Algorithmische Grundstrukturen 106 Implementierung des Algorithmus Hinweise: Programme sollten gut strukturiert sein: - Verschiedene Teile des Algorithmus sollten optisch voneinander abgesetzt werden. - Die Struktur des Algorithmus sollte durch systematisches Einrücken optisch sichtbar gemacht werden. Programme sollten gut lesbar sein: - sinntragende Bezeichner wählen - entscheidenden Stellen kommentieren

107 KB Algorithmische Grundstrukturen 107 Validierung des Algorithmus Hinweise: Validierung während der Erstellung: - Überprüfung mit Trace-Tabellen Validierung nach der Implementierung: - durch systematisches Testen (der Standardfälle, Sonderfälle,...)

108 KB Algorithmische Grundstrukturen 108 Literaturhinweise Es gibt eine Vielzahl guter Einführungen in die Thematik Algorithmische Grundstrukturen. Manche entwickeln die Grundstrukturen ohne Anbindung an eine Programmiersprache, viele verdeutlichen sie parallel an gängigen und aktuellen Sprachen (früher oft Pascal, heute vermehrt Java, Delphi,...). Einige Beispiele: - Rüdeger Baumann: Informatik für die Sekundarstufe II, Klett- Verlag. - Ocker / Schöttle / Simon: Algorithmen und ihre Programmierung in Pascal. Oldenbourg Verlag. - Laubach / Knoch: Grundkurs Informatik 1 / 2. bsv-Verlag. - Helmut Balzert: Lehrbuch Grundlagen der Informatik. Spektrum- Verlag. - Gumm / Sommer: Einführung in die Informatik. Addison-Wesley.


Herunterladen ppt "Algorithmische Grundstrukturen IFB 2002 Klaus Becker."

Ähnliche Präsentationen


Google-Anzeigen