Lösung: public static void brettlaengen(int laenge){ brettlaengen("", laenge); }

Transkript

1 - 1 - Aufgabe 1: (15 Punkte) Eine Tischlerei benötigt zur Herstellung ihrer Regalserie Freddie Bretter der Länge 1 bzw. Meter, welche aus längeren Brettern des Zulieferers zugeschnitten werden müssen. Die Länge der Ausgangsbretter in Metern ist dabei stets ganzzahlig. Schreiben Sie eine Java-Methode static void brettlaengen(int laenge), welche für ein Ausgangsbrett der Länge laenge alle möglichen Zuschnittskombinationen für Bretter der Länge 1 bzw. Meter ausgibt. Die Kombinationen für ein Ausgangsbrett der Länge 3 sind z.b.: Lösung: public static void brettlaengen(int laenge){ brettlaengen("", laenge); public static void brettlaengen(string kombinationen, int laenge){ if (laenge == 0) System.out.println(kombinationen); if (laenge >= 1) brettlaengen(kombinationen + " 1", laenge - 1); if (laenge >= ) brettlaengen(kombinationen + " ", laenge - );

2 - - Aufgabe : (15 Punkte) Gegeben seien die folgenden Haskell-Funktionsdefinitionen: mult :: Int -> Int mult a = a + a g :: (Int -> Int) -> Int -> Int g f x = f (x * x) Reduzieren Sie den Ausdruck g mult + g (+ 1) schrittweise! Wenden Sie dabei in jedem Schritt nur eine Reduktionsregel an und dokumentieren sie die jeweiligen Zwischenschritte! In einigen Schritten kommen mehrere Redexe für eine Reduktion in Frage. Gehen Sie in diesen Fällen davon aus, dass der am weitesten links stehende, äußerste Redex zuerst reduziert wird. Beachten Sie, dass Teilausdrücke ggf. mehrfach ausgewertet werden müssen! Lösung: g mult + g (+1) mult ( * ) + g (+1) (*) + (*) + g (+1) 4 + (*) + g (+1) g (+1) 8 + g (+1) 8 + (+1) ( * ) 8 + (+1)

3 - 3 - Aufgabe 3: (15 Punkte) Entwickeln Sie in einer Programmiersprache Ihrer Wahl (Haskell oder Java) eine Funktion bzw. Methode, welche alle möglichen Permutationen einer ihr übergebenen Liste paarweise disjunkter, natürlicher Zahlen erzeugt. Die Liste der Permutationen der Liste [1,, 3] wäre z.b.: [[1,, 3], [1, 3, ], [, 1, 3], [, 3, 1], [3, 1, ], [3,, 1]] Hinweis: Für eine Implementierung in Java bietet sich die Verwendung von Arrays anstelle von Listen an. Haskell-Lösung: -- man erzeugt alle permutationen einer liste (l:ls), indem man alle -- Permutationen der liste ls erzeugt und l an allen Positionen dieser -- Permutationen einmal einfügt. perm :: [a] -> [[a]] perm [] = [[]] perm (l:ls) = insert l (perm ls) -- fügt ein Element in alle Positionen einer Liste von Listen ein insert :: a -> [[a]] -> [[a]] insert x [] = [] insert x (y:ys) = (map (insert x y) [0.. (length y)]) ++ insert x ys -- fügt ein Element an eine bestimmte Stelle einer Liste ein insert :: a -> [a] -> Int -> [a] insert a [] n = [a] insert a (y:ys) 0 = (a:(y:ys)) insert a (y:ys) n = (y:(insert a ys (n-1))) oder etwas kürzer: perm :: [a] -> [[a]] perm [] = [[]] perm (x:xs) = [ps ++ [x] ++ qs rs <- perm xs, (ps, qs) <- splits rs] splits :: [a] -> [([a],[a])] splits [] = [([], [])] splits (y:ys) = ([],y:ys):[(y:ps,qs) (ps,qs) <- splits ys]

4 - 4 - Java-Lösung: public static int[][] permutation(int[] liste){ // die erste Permutation im Ergebnis ist die liste selbst int[][] result = new int[1][liste.length]; result[0] = liste; // der rest entsteht durch Vertauschung. Dabei wird jedes Element der // Liste mit jedem der weiter rechts in der Liste stehenden Elementen // einmal vertauscht. for (int left = 0; left < liste.length - 1; left++){ // wie viele Permutation gibt es bereits, aus denen durch // Vertauschungen neue Permutationen entstehen? int anz = result.length; // in den bisherigen Perumtationen das Element an Position left mit // allen rechts danebenliegenden vertauschen und die neuen // Permutationen hinten anhängen for (int right = left + 1; right < liste.length; right++){ for (int zeile = 0; zeile < anz; zeile++){ // die neue Permutation erzeugen int[] newperm = new int[liste.length]; // Reihenfolge aus der alten Permutation übernehmen for (int h = 0; h < newperm.length; h++) newperm[h] = result[zeile][h]; // Elemente left und right vertauschen newperm[left] = result[zeile][right]; newperm[right] = result[zeile][left]; // neue Permutation anhängen result = append(result, newperm); return result; static int[][] append(int[][] r, int[] a){ int[][] result = new int[r.length + 1][]; for (int i = 0; i < result.length - 1; i++) result[i] = r[i]; result[result.length - 1] = a; return result;

5 - 5 - Aufgabe 4: ( = 4 Punkte) Eine Versicherungsagentur beschließt im Rahmen eines Forschungsprojektes die Realisierung einiger Teile ihrer Mitarbeiter-, Kunden- und Policenverwaltung durch eine neue, in Java zu implementierende Software zu erproben. Kernkomponenten dieser neuen Software bilden die Klassen Mitarbeiter, Kunde und Police, welche durch eine möglichst genaue Abbildung der in der Realität auftretenden Abhängigkeiten miteinander verknüpft werden sollen. Das Projektteam hat hierfür folgende Abhängigkeiten analysiert: Die Agentur beschäftigt mehrere Mitarbeiter, welche jeweils wiederum für unterschiedliche Kunden zuständig sind. Um ein persönliches Verhältnis zu den Kunden aufbauen zu können, wird jeder Kunde nur von einem Mitarbeiter betreut. Da die Agentur verschiedene Arten von Versicherungen anbietet, kann jeder Kunde mehrere Versicherungspolicen besitzen. Die Provision, welche die Agentur durch die Vermittlung der Versicherungspolice erhalten hat, wird in den Policen selbst festgehalten. Für die erste Version der Software wurden für die einzelnen Klassen folgende Methoden definiert: Klasse Police: double getprovision() // gibt die Provision der Police aus String getpolicenid() // gibt das Aktenzeichen der Police aus Klasse Kunde: void addpolice(police police) // fügt eine neue Police zu den Policen des // Kunden hinzu String getname() // gibt den Namen des Kunden zurück String getanschrift() // gibt die Anschrift des Kunden zurück Police[] getpolicen() // gibt ein Array aller Policen den Kunden // zurück Klasse Mitarbeiter: void addkunde(kunde kunde) // fügt einen neuen Kunden in die Liste der // Kunden des Mitarbeiters ein String getname() // gibt den Namen des Mitarbeiters aus Enumeration getkunden() // Gibt eine Aufzählung aller Kunden des // Mitarbeiters aus void provisionenausgeben() // Erzeugt eine Liste der Provisionssummen // pro Kunde des Mitarbeiters a) Stellen Sie die im Text geschilderte Situation durch ein Klassendiagramm dar! b) Implementieren Sie die Klassen Police und Kunde. Achten Sie dabei besonders auf sinnvolle Parameter für die jeweiligen Konstruktoren und eine sichere Kapselung der zu verwaltenden Daten. c) Schreiben Sie die Methode provisionenausgeben() der Klasse Mitarbeiter, welche eine Auflistung aller Kunden und die Summen der durch Verträge mit ihnen erwirtschafteten Provisionen ausgibt! Hinweis: 1. Die übrigen Methoden der Klasse Mitarbeiter brauchen in dieser Aufgabe nicht implementiert zu werden.. Die einzigen Methoden des Interface Enumeration sind: Object nextelement() und boolean hasmoreelements()

6 - 6 - a) * Kunde name:string anschrift:string policen:police[] addpolice(police:police) getname()string getanschrift():string getpolicen():police[] 1 Mi tarbeiter name:string 1 kund en:vect or addkunde(kun de:kunde) getname():string getkun den():enumera tion provi sionenausgeben() Police provi sion:doub le id:string * getprovision():double getpolicenid():double b) public class Police { protected double provision; protected String id; public Police (String id, double provision){ this.id = id; this.provision = provision; public double getprovision(){ return provision; public String getid(){ return id;

7 - 7 - public class Kunde { protected String name; protected String anschrift; protected Police[] policen; public Kunde(String name, String anschrift){ this.name = name; this.anschrift = anschrift; this.policen = new Policen[0]; public String getname(){ return name; public String getanschrift(){ return anschrift; public void addpolice(police police){ Police[] tmp = policen; policen = new Police[tmp.length + 1]; for (int i = 0; i < tmp.length; i++) policen[i] = tmp[i]; policen[policen.length 1] = police; public Police[] getpolicen(){ return policen; c) public static void provisionenausgeben(){ Enumeration kunden = getkunden(); while (kunden.hasmoreelements()){ Kunde kunde = (Kunde)kunden.nextElement(); double provision = 0; Police[] policen = kunde.getpolicen(); for (int i = 0; i < policen.length; i++) provision += policen[i].getprovision(); System.out.println(kunde.getName() + ": " + provision);

8 - 8 - Aufgabe 5: (10 Punkte) Gegeben sei die folgende Java-Klasse: public class Preis{ public double p; private Preis(double p){ p = p; protected static int bruttopreis{ return p + p * 0.16; * Name nicht Aussagekräftig * Konstruktor ist private * this. fehlt * static, * int statt double, * Klammer vergessen * Konstanten sollten als solche definiert werden public void reduzieren(double p){ * throws vergessen if (p < 0) throw new InvalidArgumentException(); this.p = this.p * (1 - p); public static double sum(preis[] a){ int i = 1; * Arrayindex startet bei 0 double r; * Variable nicht initialisiert while (i < a.length()){ * Klammern zuviel r = r + a[i]; * a[i] ist kein double sondern ein Objekt. Es fehlt das.p * Schleifenzähler wird nicht erhöht return r; Unterstreichen Sie die in dem Quellcode vorhandenen Fehler und dokumentieren Sie die Art des Fehlers in kurzen Stichpunkten.

9 - 9 - Aufgabe 6: (4 Punkte) Gegeben sei das IMP-Programm P: while n > 0 do (e := e * ; n := n 1) Ermitteln Sie die Reduktionssemantik von P in der Umgebung ρ und im Zustand σ, wobei gilt: ρ ( n ) = α1 σ ( α 1 ) = 1 e σ ( α ) = 1 ρ ( ) = α Lösung: Lemma1: e, σ 1, σ e*, σ e : = e*, σ σ [ α / ] n, σ n : = n e : = e*; n : = n 1, σ [ α / ] 1 1, σ [ α / ] 1 n 1, σ [ α / ] 0 1, σ [ α / ] σ [ α1 / 0, α / ] σ [ α / 0, α / ] 1 Lemma: while n > 0 n, σ do [ α1 / 0, α / ] 0 0, σ [ α1 / 0, α / ] 0 n > 0, σ [ α1 / 0, α / ] false ( e : = e*; n : = n 1 ), σ [ α / 0, α / ] σ [ α / 0, α / ] 1 1 Hauptrechnung: n, σ 1 0, σ 0 n > 0, σ true Lemma1 Lemma while n > 0 do ( e : = e*; n : = n 1 ), σ σ [ / 0, / ] α 1 α