Kapitel 2 Grundelemente von Programmiersprachen 2 1 Syntaktische

Kapitel 2: Grundelemente von Programmiersprachen 2. 1 Syntaktische Elemente 2. 2 Typsysteme 2. 2. 1 Einfache Datentypen 2. 2. 2 Zusammengesetzte Datentypen 2. 2. 3 Rekursive Datentypen 2. 3 Kontrollstrukturen 2. 4 Rekursion 2. 4. 1 Klassifikation und Beispiele 2. 4. 2 Umwandlung rekursiver in iterative Verfahren 2. 5 Verzweigte Rekursion und Backtracking-Verfahren 2. 5. 1 Türme von Hanoi 2. 5. 2 Erzeugung fraktaler Muster durch Turtle-Programme 2. 5. 3 Backtracking: Hofstadters MU-Puzzle 1

2. 1 Syntaktische Elemente Grundelemente: • Blöcke (Gültigkeitsbereiche von Vereinbarungen, z. B. der Rumpf einer Funktionsdefinition) • zusammengesetzte Anweisungen (Schleifen, bedingte Verzweigungen) • einfache Anweisungen (Zuweisungen, Prozeduraufrufe) • Ausdrücke (Bedingungen, Terme) • Bezeichner (von Konstanten, Variablen, Prozeduren/Funktionen) • Konstanten (Zahlen, Zeichenketten) 2

Die syntaktische Struktur eines Programmstücks ergibt sich eindeutig aus einer statischen Analyse (des Programmtextes). Beschreibung der syntaktischen Strukturen durch kontextfreie Grammatiken (z. B. in Backus-Naur. Form) oder durch Syntax-Diagramme. 3

Beispiel: <Par. Liste> : : = '(' <Par. Deklaration> ')' <Par. Deklaration>: : = <Par. Komp> | <Par. Komp> '; '<Par. Deklaration> <Par. Komp> : : = 'var' <Par> ': ' <Typ. Bez> | <Par> ': ' <Typ. Bez> <Par> : : = <Par. Bez> | <Par. Bez> ', ' <Par> 4

Syntaxdiagramme 5

Term 6

2. 2 Typsysteme Elemente von Typsystemen: • Werte (Belegungen von Variablen, Komponenten von Ausdrücken, Ausprägungen von Übergabeparametern) • Typen (Mengen von Werten, die unter entsprechenden Operationen abgeschlossen sind, z. B. ganze Zahlen, true/false, Namen der Monate) • Ausdrücke (Programmsegmente, die zu Werten evaluiert werden können, z. B. die rechte Seite einer Zuweisung) • Typkonstruktoren (programmiersprachliche Konstrukte zur Definition neuer (zusammengesetzter) Datentypen) 7

Formen der Typisierung • Statische Typisierung: (Pascal, Modula und Java) Der Typ jeder Variablen und jedes Übergabeparameters wird im Programm explizit definiert. Die Typprüfung wird zur Übersetzungszeit durchgeführt. • Dynamische Typisierung: (z. B. Prolog, Lisp, Logo). Variablen und Parameter sind nicht typisiert - wohl aber deren aktuelle Werte. Ein Wert kann ggf. potentiell unterschiedliche Typen "bedienen" (z. B. kann eine Ziffer als Integer oder Character interpretiert werden). Die Typüberprüfung findet zur Laufzeit statt. 8

Einige einfache Datentypen Vordefinierte Truth-Value = {true, false} Integer = {. . . , -2, -1, 0, +1, +2, +3, . . . } Real = {. . . , -1. 0, . . . , 0. 0, . . . , 1. 0, . . . } Character = {'a', . . . , 'z', 'A', . . . , 'Z', . . . } Aufzählungstyp type Tag = {montag, dienstag, mittwoch, donnerstag, freitag, samstag, sonntag} 9

Elementare Datentypen in Java 10

Typkonvertierungen in Java • boolean kann nicht in einen numerischen Typ überführt werden. • Die numerischen Typen bilden eine lineare Ordnung (byte -> short -> int -> long -> float -> double). In dieser Reihe kann ein Wert "niederen" Typs implizit in einen Wert höheren Typs überführt werden. Beispiel: int n; . . . ; float x = n; . . . • Die Überführung eines höheren in einen niederen Typ erfordert einen sog. cast. • Beispiel: float x; . . . ; x = (float) Math. sin(. . . ); . . . (da sin einen Wert vom Typ double liefert. ) 11

Typumwandlungen in Java • Mittels der statischen Methode (Funktion) String. value. Of(x) aus der Klasse String können Werte x von einem beliebigen elementaren Typ in einen String überführt werden. • Die statische Methode Integer. parse. Int(String s) aus der Klasse Integer überführt einen String s in einen int-Wert (falls nicht möglich: exception). • Zu jedem elementaren Typ gibt es eine zugeordnete Objektklasse (Wrapper-Klasse, Konvertierung erforderlich!). Auf dieser Ebene sind weitere einheitlichere - Konvertierungsmöglichkeiten definiert. 12

Beispiele Beispiel: int i = 5; int j = 2; float x = i / j; ergibt den Wert 2. 0 für x. int i = 5; int j = 2; float x = i / (float) j; ergibt den Wert 2. 5 für x. 13

2. 2. 2 Zusammengesetzte Datentypen • werden erst im Programm durch Verwendung von Typ. Konstruktoren (record, set, array, . . . ) definiert. • Java kennt hiervon nur den Array-Konstruktor; 14

• Verbundtyp (record) in Pascal: allgemeine Form: record I 1 : T 1; . . . ; In : Tn end {Ik: Feldname, Tk: Feldtyp} • Beispiel: type Tel. Eintrag = record Name: string[20]; Nr : string[12] end • Wertemenge des hierdurch konstruierten Typs: kartesisches Produkt T 1 . . . Tn • Kardinalität: # (T 1 . . . Tn ) = # (T 1 ) • . . • # (Tn ) 15

Explizite Definition von Abbildungen durch Arrays (Java): Schema: Sei m : I T, wobei I eine endliche Indexmenge, T der Typ der Werte (Bildmenge) sei. Für endliche T ergibt sich die Kardinalität: # ( I T ) = # ( T ) #(I) Der Ansatz kann iteriert werden, d. h. T kann selbst schon ein Array sein. 16

Beispiel: Labyrinth in Pascal type dim_x = [1. . n] ; dim_y = [1. . m] ; Labyrinth = array dim_x, dim_y of boolean ; var Lab: Labyrinth ; procedure wand(i: dim_x, j: dim_y): boolean ; begin wand : = Lab[i, j] end {wand} ; Beispiel: Labyrinth in Java. . . int Lab[][] = new int[n][m] ; . . . /* Initialisierung erfolgt z. B. in Konstruktor-Methode der Klasse */ public boolean wand(int i, int j) { return Lab[i][j] ; } 17

2. 2. 3 Rekursive Datentypen Ein Datentyp heißt rekursiv, wenn in seiner Typdefinition der Typ selbst wieder vorkommt; d. h. Werte dieses Typs können wiederum Werte des gleichen Typs als Komponenten enthalten. Beispiel: Liste von Zahlen: Listof. Integer : = {nil} + (Integer Listof. Integer) Vereinbarung in Pascal: type List = ^List. Elem; List. Elem = record wert : Integer; nachf : List end; 18

2. 3 Kontrollstrukturen - Anweisungen Unterscheide zwischen: Ausdruck (Term) - Anweisung (Befehl) In C++ und Java ist die Trennung zwischen Ausdruck und Anweisung nicht durchgehalten; i++ und ++i sind Kurzformen für die Anweisung i : = i + 1, sind aber auch Ausdrücke mit Wert(i++) = Wert(++i) = Wert(i) + 1. Beispiele: Ausdruck oder Anweisung? a) 3 > sqrt(k); b) int k = ++i; 19

• Elementare (atomare) Anweisungen: Zuweisungen, Prozeduraufrufe • Strukturierte Anweisungen: Sequenzen, bedingte Anweisungen, iterierte Anweisungen (Schleifen), einige weitere. Für jede strukturierte Anweisung lässt sich ein allgemeines Schema für die "Fortpflanzung„ von Zusicherungen (zum Korrektheitsnachweis) (notiert in spitzen Klammern <. . . > ) angeben. 20

• Anweisungssequenz: In Java: { A 1; A 2; . . . ; An; } Zusicherungen: Beispiel: Hier gilt für n=2: Voraussetzungen: <P> A 1 <Q> und <Q> A 2 <R> Folgerung: <P> A 1; A 2 <R> 21

• Bedingte Anweisungen: 22

• Bedingte Anweisungen: In Java: if (B) A 1 else A 2 bzw. if (B) A Zusicherungen: <P & B> A 1 <Q>, <P & ~B> A 2 <Q> -----------------------<P> if B then A 1 else A 2 <Q> bzw. <P & B> A <Q> &(P & ~B => Q) ---------------<P> if B then A <Q> 23

• Schleifen: In Java: while (B) A bzw. do A while (B); Zusicherungen: <P & B> A <P> ---------------<P> while B do A <P & ~B> 24

Beispiel: {N > 0} i : = 0; fact : = 1; {i = 0 & fact = 1 & N > 0} while i < N do begin {fact = i! & i <= N} i : = i + 1; fact : = fact * i; end; {fact = i! & i <= N & i >= N} {fact = N!} 25

• Schleifen: Zusicherungen: <P> A <I> & <I & ~B> A <I> & (I & B => Q) ---------------------<P> repeat A until B <Q> 26

• Weitere strukturierte Anweisungen: • selektive Anweisung: in Pascal: case in Java: switch • for-Schleife in Java: for(init; test; update) Anweisung ; 27

2. 4. 1 Rekursion Klassifikation und Beispiele Begriff der Rekursion: • allgemein: selbstbezüglicher Verweis, Selbstbezüglichkeit / Selbstähnlichkeit einer Struktur • spezielle Bedeutung im Bereich Programmierung: Selbstaufruf einer Prozedur / Funktion Anmerkung: die Theorie rekursiver Funktionen im Sinne der Mathematik baut auch auf Rekursion auf. 28

Beispiele rekursiver Algorithmen: • größter gemeinsamer Teiler (gg. T) Eingaben a, b ganzzahlig, positiv algorithmus { wenn a=b wenn b>a rückgabe gg. T(a, b: int) int dann rückgabe a; dann rückgabe gg. T(b, a); gg. T(a-b, b) } 29

• Fakultät einer nat. Zahl (fak) Eingabe n 0, ganzzahlig algorithmus fak(n: int) int { wenn n=0 dann rückgabe 1 sonst rückgabe n • fak(n-1) } 30

• Fibonacci-Folge (fibo) Eingabe n 0, ganzzahlig algorithmus fibo(n: int) int { wenn (n=0 oder n=1) dann rückgabe n sonst rückgabe fibo(n-1)+fibo(n-2) } 31

Klassifikation (Rekursionstypen): • endständige Rekursion Das rekursive Aufrufschema einer Prozedur oder Funktion heißt » endständig «, wenn auf jeder Aufrufebene maximal ein rekursiver Aufruf zur Ausführung gelangt und dieser Aufruf weder von weiteren Anweisungen gefolgt wird (d. h. letzte Anweisung) noch in andere Operationen als Rückgabe (return) eingebunden ist. 32

• verzweigte (vs. lineare) Rekursion Ein rekursives Aufrufschema heißt verzweigt, wenn in bestimmten Fällen mehr als ein rekursiver Aufruf zur Ausführung auf einer Aufrufebene gelangt. Bei maximal einem rekursiven Aufruf pro Ebene heißt das rekursive Aufrufschema linear. • indirekte (vs. direkte) Rekursion Als indirekte Rekursion wird der Selbstaufruf einer Prozedur "auf Umwegen" bezeichnet. Beispiel: Funktion F ruft (in bestimmten Fällen) G, G ruft H und H wiederum F auf. 33

Vor- und Nachteile der Rekursion • kompakt, elegant • abstrakt im math. Sinne • Setzen von Variablen ohne Zuweisungen (stattdessen: Parameterübergabe). • schwierig zu handhaben • hohe Ablaufkomplexität, besonders bei verzweigten Rekursionen • Speicherbedarf für Rekursionskeller • Effizienznachteil gegenüber Iteration. 34

Beispiel: "Partitionszahl" • Definition: Die Partitionszahl P(n) einer natürlichen Zahl n ist die Anzahl der unabhängig von der Reihenfolge der Summanden - verschiedenen additiven Zerlegungen von n (positive Summanden). Formal: P(n) : = #( { {k 1, … , kj} mit n = k 1 + … + kj , 0 < ki n} ) Hier ist {k 1 , . . , kj } eine Multimenge, d. h. ein Element darf mehrfach vorkommen. 35

Problem: gegeben n, berechne P(n) ! Lösung: Rekursion. Definition: P(n, k) sei die Anzahl der additiven Zerlegungen von n mit positiven Summanden k (hier sei n > 0 und k > 0). Dann: P(n) = P(n, n) und • P(1, k) = 1 • P(n, 1) = 1 • P(n, k) = P(n, n) für k > n • P(n, n) = P(n, n-1)+1 • P(n, k) = P(n, k-1) + P(n-k, k) für k < n 36

In Java: public class Parti { private static int String 2 Int(String s) { Integer I = new Integer(s); return I. int. Value(); } private static int P(int n, int k) { if ( n == 1 ) return 1; if ( k == 1) return 1; if ( k > n ) return P(n, n); if ( k == n) return P(n, n-1) + 1; return P(n, k-1) + P(n-k, k); } public static void main(String[] args) { int n = String 2 Int(args[0]); System. out. println("------"); System. out. println("P("+n+") = "+P(n, n)); System. out. println("------"); } } 37

Verifikationskriterien: • Vollständigkeit der Fallunterscheidung • Korrektheit des Ergebnisses in terminalen Fällen • Korrektheit der Reduktionsschritte (Fälle) • Sicherstellung der Reduktion auf den terminalen Fall in endlich vielen Schritten 38

2. 4. 2 Umwandlung rekursiver in iterative Verfahren Beispiel: größter gemeinsamer Teiler algorithmus gg. T(a, b: int) int rekursiv: { wenn a=b dann rückgabe a; wenn b>a dann rückgabe gg. T(b, a); rückgabe gg. T(a-b, b) } Iterativ: { solange nicht a=b do {wenn b > a dann vertausche(a, b) sonst a : = a-b}; rückgabe a } 39

Beispiel: Fakultät. algorithmus fak(n: int) int { wenn n=0 dann rückgabe 1 sonst rückgabe n • fak(n-1) } Nicht endständig. Zuerst: Umwandlung in einen Algorithmus mit endständiger Rekursion: algorithmus fakt(n: int, akku: int) int { wenn n=0 dann rückgabe akku sonst rückgabe fakt(n-1, n • akku) } (Aufruf mit akku=1). 40

Endständige Rekursion zur Berechnung der Fakultät: algorithmus fakt(n: int, akku: int) int { wenn n=0 dann rückgabe akku sonst rückgabe fakt(n-1, n • akku) } Nun: ein iterativer Algorithmus: algorithmus faks(n: int) int { akku: int; akku : = 1; solange nicht n=0 führe_aus { akku : = n • akku; n : = n-1 }; rückgabe akku } 41

Ein anderer iterativer Algorithmus: algorithmus fakr(n: int) int { akku : int; akku : = 1; k : int; k : = 0, solange k < n führe_aus { k : = k+1; akku : = k • akku }; rückgabe akku } 42

Primitive Rekursion: Ein allgemeines Schema der linearen Rekursion. Dient zur Definition einer Funktion f: No X Y. Gegeben: • a: X Y (Anfangswertfunktion), • r: No X Y Y (Rekursionsschema). Dann f definiert durch: (1) f(n, x) = a(x), falls n=0 (2) f(n, x) = r(n, x, f(n-1, x)), sonst 43

• Beispiel: Mit X= No, Y= No, a(x)=1, r(n, x, y)=x • y erhält man die Potenzfunktion f(n, x) = xn. • Beispiel: Mit X={()}, Y= No, a()=1, r(n, y)=n • y erhält man die Fakultätsfunktion. • Beispiel: Was für eine Funktion erhält man mit X=Y= R+, a(x)=x/2, r(n, x, y)=1/2(y+(x/y)) ? 44

public class Iter { private static int String 2 Int(String s) { Integer I = new Integer(s); return I. int. Value(); } private static double r(int n, double x, double y) { return 0. 5*(y + x/y); } private static double a(double x) { return x/2; } private static double iter(int n, double x) { double akku = a(x); int k = 0; while ( k < n ) { System. out. println(k+": "+akku); akku = r(k+1, x, akku); k = k+1; } return akku; } public static void main(String[] args) { int x = String 2 Int(args[0]); double y = iter(7, x); System. out. println("---------- "); System. out. println("Ergebnis : "+y); System. out. println("---------- "); } } 45

• Iterativer Algorithmus für f, definiert durch primitive Rekursion aus a und r : algorithmus iter(n: int, x: x. Val) y. Val { akku : y. Val; akku : = a(x); k : int; k : = 0; solange k < n führe_aus { akku : = r(k+1, x, akku); k : = k+1 }; rückgabe akku } 46