Assignments

README.md

@@ -41,8 +41,23 @@ Diese Aufgaben können sie verwenden, um sich **zu Hause** auf die Klausur vorzu
 
 | #   | Thema | Musterlösung |
 | --- | ----- | ------------ |
-| 1.  |       |              |
-| 2.  |       |              |
+| 1.  |[Gegensätze ziehen sich an](./assignments/seelenverwandte.md)|[Click me!](./assignments/solutions/seelenverwandte.groovy)|
+| 2.  |[Begrüßungsliste](./assignments/begruessungsliste.md)|[Click me!](./assignments/solutions/begruessungsliste.groovy)|
+|3.|[Wettervorhersage](./assignments/wetterprognose.md)|[Click me!](./assignments/solutions/wetterprognose.groovy)
+|4.|[Sicheres Navigieren](./assignments/save-navigation.md)|[Click me!](./assignments/solutions/save-navigation-sol.md)
+|5.|[Schleifen](./assignments/schleifen.md)|[Click me!](./assignments/schleifen.md)
+|6.|[Closures verwenden](./assignments/closure-benutzen.md)|[Click me!](./assignments/solutions/closure-benutzen.groovy)
+|7.|[Spread Operator](./assignments/spread-operator.md)|[Click me!](./assignments/solutions/spread-operator.groovy)
+|8|[Vergleiche](./assignments/operatoren.md)|[Click me!](./assignments/solutions/operatoren-sol.groovy)
+|9.|[Ranges](./assignments/ranges.md)|[Click me!](./assignments/solutions/ranges.groovy)
+|10.|[Leben wie die Römer!](./assignments/roemer.md)|[Click me!](./assignments/solutions/roemer.groovy)
+|11.|[Konstruktoren](./assignments/konstruktor.md)|[Click me!](./assignments/solutions/konstruktor.groovy)
+|12.|[Taschenrechner](./assignments/taschenrechner.md)|[Click me!](./assignments/solutions/taschenrechner.groovy)
+|13.|[Mitarbeitermanagement](./assignments/mitarbeiter.md)|[Click me!](./assignments/solutions/mitarbeiter.groovy)
+|14.|[Multiplier](./assignments/multiplier.md)|[Click me!](./assignments/solutions/multiplier.groovy)
+|15.|[Counter](./assignments/counter.md)|[Click me!](./assignments/solutions/counter.groovy)
+
+
 
 ## Links:
 

assignments/begruessungsliste.md

@@ -0,0 +1,3 @@
+### Begrüßungsliste
+
+Anna und Tom haben diesmal beschlossen, eine kleine Party zu veranstalten und möchten sichergehen, dass sie alle ihre eingeladenen Freunde auf der Begrüßungsliste haben. Schreiben sie ein Groovy Programm, dass den beiden dabei hilft, die Namen ihrer Freunde hizuzufügen und die Liste anzuzeigen. Hierbei soll es möglich sein sowohl einzelne, als auch mehrere Namen hinzuzufügen. Tipp: Benutzen sie für die Implementierung eine Liste, sehen sie jedoch davon ab die `list.add()` Methode zu benutzen. Groovy bietet hier einen komfortableren Weg.

assignments/closure-benutzen.md

@@ -0,0 +1,5 @@
+### Closure benutzen
+
+Schreiben sie ein Groovy-Skript, dass eine gegebene Liste von Zahlen (1-10) filtert und hierbei nur die geraden Zahlen behält. Geben sie das Ergebnis auf der Konsole aus. Verwenden sie für ihre Implementierung ein Closure und die `findAll()` Methode für Listen.
+
+_Tipp: Die `findAll()` Methode nimmt ein Closure an und gibt eine neue Liste zurück, die alle Elemente enthält, für die die Bedingung des Closures gelten._

assignments/counter.md

@@ -0,0 +1,12 @@
+### Closures
+
+Schreibe eine Funktion makeCounter, die eine Closure zurückgibt, die jedes Mal, wenn sie aufgerufen wird, um 1 erhöht.
+```Groovy
+def makeCounter() {
+   //TODO
+}
+def counter = makeCounter()
+println(counter())  // Erwartete Ausgabe: 1
+println(counter())  // Erwartete Ausgabe: 2
+println(counter())  // Erwartete Ausgabe: 3
+```

assignments/gitty.txt

@@ -0,0 +1,15 @@
+
+
+#Freiwillige Übungen: Assignment 13: Schleifen
+#Freiwillige Übungen: Assignment 14: Counter
+#Freiwillige Übungen: Assignment 15: Operatoren
+
+
+
+
+
+
+
+
+
+

assignments/konstruktor.md

@@ -0,0 +1,6 @@
+# Konstruktor?
+Erstellen Sie eine Klasse Person, die eine Instanzvariable `name` vom Typ String und
+eine Instanzvariable `age` vom Typ int hat Implementieren Sie einen entsprechenden
+Kostruktor, der die Instanzvariablen initialisiert.
+Fügen Sie außerdem eine Methode `introduce()` hinzu,
+die eine Vorstellung der Person auf der Konsole ausgibt. Erstellen Sie eine Instanz der Klasse und rufen Sie die Methode `introduce()` auf.

assignments/mitarbeiter.md

@@ -0,0 +1,10 @@
+### Mitarbeitermanagement
+
+Erstellen Sie eine Klasse `EmployeeManager`, die die Verwaltung von Mitarbeitern
+ermöglicht. Die Klasse soll folgende Funktionen bieten:
+
+1. Hinzufügen von Mitarbeitern mit Name und Gehalt.
+2. Aktualisieren des Gehalts eines Mitarbeiters.
+3. Entfernen eines Mitarbeiters.
+4. Durchführen von Gehaltsanpassungen für alle Mitarbeiter basierend auf einer Closure, die eine Gehaltsanpassungslogik definiert.
+5. Abrufen einer Liste von Mitarbeitern, die nach einem bestimmten Kriterium gefiltert wurden (basierend auf einer übergebenen Closure).

assignments/multiplier.md

@@ -0,0 +1,11 @@
+# Multiplier:
+Schreibe eine Funktion `makeMultiplier`, die eine Zahl ``n`` als Argument nimmt und eine Closure zurückgibt, die eine Zahl mit ``n`` multipliziert.
+
+```Groovy
+def makeMultiplier(n) {
+    // TODO
+}
+
+def multiplierOf3 = makeMultiplier(3)
+println(multiplierOf3(5))  // Erwartete Ausgabe: 15
+```

assignments/operatoren.md

@@ -0,0 +1,9 @@
+### Operatoren und bedingte Operatoren
+
+Schreiben Sie eine Groovy-Methode vergleich, die zwei Werte annimmt und diese vergleicht. Ist
+einer von den Werten ``null`` soll ein Standardwert verwendet werden. 
+
+#### Die Methode soll folgende Schritte ausführen:
+1. Um den Standardwert zu setzen soll ein passender Operator verwendet werden.
+2. Der Vergleich der zwei Werte soll auch mit dem Einsetzen eines passenden Operators durchgeführt werden.
+3. Je nachdem welches Ergebnis der Vergleich gibt, soll eine passende Ausgabe ausgegeben werden.

assignments/ranges.md

@@ -0,0 +1,14 @@
+### Ranges
+
+Schreiben sie ein kurzes Groovy-Skript, in dem sie eine Range von 1-25 erstellen. Zusätzlich soll die Range die Zahlen in dreier-Sprüngen enthalten:
+-> (1,4,7,10...)
+
+Erstellen sie als nächstes eine Range, die die Kleinbuchstaben a-z enthält.
+
+Geben sie beide Ranges auf der Konsole aus.
+
+_Tipp: Benutzen sie für die zweite Range zum ausgeben folgende Methode:_
+
+```Groovy
+letters.each{print it + " "}
+```

assignments/roemer.md

@@ -0,0 +1,3 @@
+# Römer und Zahlen:
+
+Die Römer hatten ihre eigene Art, Zahlen zu schreiben, und sie waren ziemlich stolz darauf! Deine Aufgabe ist es, eine Klasse zu erstellen, die eine Dezimalzahl in eine römische Zahl umwandelt. 

assignments/save-navigation.md

@@ -0,0 +1,20 @@
+### Save Navigation Operator
+
+
+Wie kann man in Groovy sicherstellen, dass in folgendem Codebeispiel keine NullPointerException auftritt? Sehen sie davon ab try-catch-Blöcke zu verwenden. Hier ist ein bestimmter Operator gefordert.
+
+```Groovy
+class Person {
+    def name
+    def address
+}
+
+class Address {
+    def city
+    def street
+}
+
+def person = new Person(name: "Thomas Smits")
+
+println(person.address.city)
+```

assignments/schleifen.md

@@ -0,0 +1,9 @@
+### Schleifen und Bedingungen
+
+Schreiben Sie eine...
+
+  a) ``while``-Schleife
+
+  b) ``for``-Schleife
+
+die die Fakultät einer gegebenen Zahl berechnet und ausgibt.

assignments/seelenverwandte.md

@@ -0,0 +1,8 @@
+# Freiwillige Übungen: Assignment 1 (Bedingungen?)
+
+### Gegensätze ziehen sich an
+
+Anna und Tom denken, sie sind ineinander verliebt. Nun wollen sie wissen, ob ihre Beziehung auch lange hält und sie wirklich Seelenverwandte sind. Das können sie nur rausfinden, wenn sie das in ihrem Dorf beliebte Blütenspiel spielen. Hierzu nimmt sich jeder der beiden eine Blume. Hat eine der Blumen eine ungerade Anzahl an Blüten und die andere eine gerade Anzahl, dann sind die beiden wirklich für einander bestimmt.
+
+Schreiben sie ein Groovy Programm, dass die Anzahl der Blüten von beiden Blumen übergeben bekommt. Das Programm soll die beiden Zahlen miteinander vergleichen und je nachdem ausgeben, ob die beiden für einander bestimmt sind oder nicht.
+

assignments/solutions/begruessungsliste.groovy

@@ -0,0 +1,17 @@
+class Begruessungsliste {
+    def namen = []
+
+    def addNames(String... neueNamen) {
+        neueNamen.each {namen << it}
+        neueNamen.each { println "${it} wurde zur Begrüßungsliste hinzugefügt."}
+    }
+
+    def showList() {
+        println "Aktuelle Begrüßungsliste: "
+        namen.each { println "- ${it}"}
+    }
+}
+
+Begruessungsliste list = new Begruessungsliste()
+list.addNames("Karl", "Tom")
+list.showList()

assignments/solutions/closure-benutzen.groovy

@@ -0,0 +1,4 @@
+def zahlen = (1..10).toList()
+def istGerade = { zahl -> zahl % 2 == 0 }
+def geradeZahlen = zahlen.findAll(istGerade)
+println geradeZahlen

assignments/solutions/counter.groovy

@@ -0,0 +1,9 @@
+def makeCounter() {
+    def count = 0
+    return {++count}
+}
+
+def counter = makeCounter()
+println(counter())  // Erwartete Ausgabe: 1
+println(counter())  // Erwartete Ausgabe: 2
+println(counter())  // Erwartete Ausgabe: 3

assignments/solutions/konstruktor.groovy

@@ -0,0 +1,17 @@
+class Person {
+    String name
+    int age
+
+    Person(String name, int age) {
+        this.name = name
+        this.age = age
+    }
+
+    def introduce() {
+        println("Hello, my name is ${name} and I am ${age} years old.")
+    }
+}
+
+// Verwendung der Klasse Person
+def person = new Person("Alice", 30)
+person.introduce()

assignments/solutions/mitarbeiter.groovy

@@ -0,0 +1,63 @@
+class Employee {
+    def name
+    def salary
+
+    Employee(name, salary) {
+        this.name = name
+        this.salary = salary
+    }
+
+    String toString() {
+        return "Name: ${name}, Salary: ${salary}"
+    }
+}
+
+class EmployeeManager {
+    def employees = []
+
+    def addEmployee(name, salary) {
+        employees << new Employee(name, salary)
+    }
+
+    def updateSalary(name, newSalary) {
+        employees.find { it.name == name }?.salary = newSalary
+    }
+
+    def removeEmployee(name) {
+        employees.removeAll { it.name == name }
+    }
+
+    def adjustSalaries(Closure adjustmentLogic) {
+        employees.each { it.salary = adjustmentLogic(it.salary) }
+    }
+
+    def filterEmployees(Closure criteria) {
+        return employees.findAll(criteria)
+    }
+}
+
+// Beispielnutzung der Klasse EmployeeManager
+def manager = new EmployeeManager()
+
+// Hinzufügen von Mitarbeitern
+manager.addEmployee("Alice", 50000)
+manager.addEmployee("Bob", 60000)
+manager.addEmployee("Charlie", 55000)
+
+// Aktualisieren des Gehalts eines Mitarbeiters
+manager.updateSalary("Alice", 52000)
+
+// Entfernen eines Mitarbeiters
+manager.removeEmployee("Charlie")
+
+// Durchführen von Gehaltsanpassungen für alle Mitarbeiter
+manager.adjustSalaries { salary -> salary * 1.1 } // 10% Gehaltserhöhung
+
+// Filtern von Mitarbeitern basierend auf einem Kriterium
+def highEarners = manager.filterEmployees { it.salary > 55000 }
+
+println("Alle Mitarbeiter:")
+manager.employees.each { println it }
+
+println("\nHigh Earners:")
+highEarners.each { println it }

assignments/solutions/multiplier.groovy

@@ -0,0 +1,6 @@
+def makeMultiplier(n) {
+    return {it * n}
+}
+
+def multiplierOf3 = makeMultiplier(3)
+println(multiplierOf3(5)) 

assignments/solutions/operatoren-sol.groovy

@@ -0,0 +1,22 @@
+def vergleich(zahl1,zahl2) {
+    def standartwert = 5
+
+    def wert1 = zahl1 ?: standartwert
+    def wert2 = zahl2 ?: standartwert
+
+    def vergleichErgebnis = wert1 <=> wert2
+    
+    if (vergleichErgebnis == -1) {
+        return "Erster Wert ist kleiner."
+    } else if (vergleichErgebnis == 0) {
+        return "Beide Werte sind gleich."
+    } else { 
+        return "Erster Wert ist größer."
+    }
+}
+
+println vergleich(2, 6)        // Ausgabe: Erster Wert ist kleiner.
+println vergleich(null, 6)     // Ausgabe: Erster Wert ist kleiner.
+println vergleich(12, null)    // Ausgabe: Erster Wert ist größer.
+println vergleich(null, null)  // Ausgabe: Beide Werte sind gleich.
+println vergleich(2, 2)        // Ausgabe: Beide Werte sind gleich.

assignments/solutions/ranges.groovy

@@ -0,0 +1,4 @@
+def numbers = (1..25).step 3
+def letters = 'a'..'z'
+println numbers
+letters.each{print it + " "}

assignments/solutions/roemer.groovy

@@ -0,0 +1,23 @@
+class Roman {
+
+    static romanNumerals = [
+        1000: "M", 900: "CM", 500: "D", 400: "CD",
+        100: "C", 90: "XC", 50: "L", 40: "XL",
+        10: "X", 9: "IX", 5: "V", 4: "IV",
+        1: "I"
+    ]
+
+    static String toRoman(int number) {
+        def result = ""
+        romanNumerals.each { key, value ->
+            while (number >= key) {
+                result += value
+                number -= key
+            }
+        }
+        result
+    }
+}
+
+def decimalNumber = 2000
+println("Die Dezimalzahl $decimalNumber wird in römischen Zahlen geschrieben als: ${Roman.toRoman(decimalNumber)}")

assignments/solutions/safe-navigation2.groovy

@@ -0,0 +1,15 @@
+class Person {
+    def name
+    def alter
+
+    def printIfAdult() {
+        if (this.alter > 17) {
+            println this.name + " ist volljährig."
+        }
+    }
+}
+
+def personen = [new Person(name: "Max", alter: 12), new Person(name: "Karl", alter: 40), new Person(name: "Laura", alter: 23), new Person(name: "Ali", alter: 15)]
+
+// Hier den Spread-Operator benutzen
+personen*.printIfAdult()

assignments/solutions/save-navigation-sol.md

@@ -0,0 +1,7 @@
+#### Lösung: 
+
+_Indem man den safe navigation Operator, statt der herkömmlichen Navigation durch den "." Operator benutzt:_
+
+```Groovy
+println(person?.address?.city)
+```

assignments/solutions/schleifen-sol.md

@@ -0,0 +1,26 @@
+#### Lösung
+a)
+```Groovy
+def zahl = 5
+def ergebnis = 1
+
+for (int i = 1; i <= zahl; i++) {
+    ergebnis *= i
+}
+
+println("Die Fakultät von $zahl ist: $ergebnis")
+```
+
+b)
+```Groovy
+def zahl = 5
+def ergbenis = 1
+def i = 1
+
+while (i <= zahl) {
+    ergebnis *= i
+    i++
+}
+
+println("Die Fakultät von $zahl ist: $ergebnis")
+```

assignments/solutions/seelenverwandte.groovy

@@ -0,0 +1,10 @@
+def seelenverwandt(int ersteBlume, int zweiteBlume) {
+    if ((ersteBlume % 2) != (zweiteBlume % 2)){
+        print "Ihr seid für einander bestimmt!"
+    }
+    else {
+        print "Die Beziehung hält kein Leben lang..."
+    }
+}
+
+seelenverwandt(4,5)

assignments/solutions/spread-operator.groovy

@@ -0,0 +1,15 @@
+class Person {
+    def name
+    def alter
+
+    def printIfAdult() {
+        if (this.alter > 17) {
+            println this.name + " ist volljährig."
+        }
+    }
+}
+
+def personen = [new Person(name: "Max", alter: 12), new Person(name: "Karl", alter: 40), new Person(name: "Laura", alter: 23), new Person(name: "Ali", alter: 15)]
+
+// Hier den Spread-Operator benutzen
+personen*.printIfAdult()

assignments/solutions/taschenrechner.groovy

@@ -0,0 +1,52 @@
+class Calculator {
+    def add(int a, int b) {
+        return a + b
+    }
+
+    def subtract(int a, int b) {
+        return a - b
+    }
+
+    def multiply(int a, int b) {
+        return a * b
+    }
+
+    def divide(int a, int b) {
+        if (b == 0) {
+            println("Error: Division by zero!")
+            return
+        }
+        return a / b
+    }
+
+    def performOperation(int a, int b, Closure operation) {
+        return operation(a, b)
+    }
+}
+
+// Verwendung der Klasse Calculator
+def calc = new Calculator()
+
+// Grundrechenoperationen
+println("Addition: ${calc.add(5, 3)}")
+println("Subtraktion: ${calc.subtract(10, 7)}")
+println("Multiplikation: ${calc.multiply(4, 6)}")
+println("Division: ${calc.divide(12, 4)}")
+
+// Closures definieren
+def addClosure = { int a, int b -> a + b }
+def subtractClosure = { int a, int b -> a - b }
+def multiplyClosure = { int a, int b -> a * b }
+def divideClosure = { int a, int b -> 
+    if (b == 0) {
+        println("Error: Division by zero!")
+        return
+    }
+    return a / b 
+}
+
+// Verwendung von performOperation mit Closures
+println("Addition mit Closure: ${calc.performOperation(5, 3, addClosure)}")
+println("Subtraktion mit Closure: ${calc.performOperation(10, 7, subtractClosure)}")
+println("Multiplikation mit Closure: ${calc.performOperation(4, 6, multiplyClosure)}")
+println("Division mit Closure: ${calc.performOperation(12, 4, divideClosure)}")

assignments/solutions/wetterprognose.groovy

@@ -0,0 +1,38 @@
+class Wetterprognose {
+    List<String> vorhersagen
+
+    Wetterprognose(List<String> vorhersagen) {
+        this.vorhersagen = vorhersagen
+    }
+
+    def countSunnyDays() {
+        int count = 0
+        vorhersagen.each { if (it == "Sonnig") count++ }
+        return count
+    }
+
+    def printSunnyDays() {
+        println "Anzahl der Tage mit Sonnenschein: ${countSunnyDays()}"
+    }
+}
+
+
+// Test 1: Keine sonnigen Tage
+def vorhersagen1 = ["Regnerisch", "Wolkig", "Regnerisch", "Schnee"]
+def wetter1 = new Wetterprognose(vorhersagen1)
+wetter1.printSunnyDays() // Erwartete Ausgabe: Anzahl der Tage mit Sonnenschein: 0
+
+// Test 2: Einige sonnige Tage
+def vorhersagen2 = ["Sonnig", "Wolkig", "Sonnig", "Regnerisch"]
+def wetter2 = new Wetterprognose(vorhersagen2)
+wetter2.printSunnyDays() // Erwartete Ausgabe: Anzahl der Tage mit Sonnenschein: 2
+
+// Test 3: Alle Tage sonnig
+def vorhersagen3 = ["Sonnig", "Sonnig", "Sonnig", "Sonnig"]
+def wetter3 = new Wetterprognose(vorhersagen3)
+wetter3.printSunnyDays() // Erwartete Ausgabe: Anzahl der Tage mit Sonnenschein: 4
+
+// Test 4: Wechselhaftes Wetter
+def vorhersagen4 = ["Regnerisch", "Sonnig", "Wolkig", "Sonnig", "Schnee", "Sonnig"]
+def wetter4 = new Wetterprognose(vorhersagen4)
+wetter4.printSunnyDays() // Erwartete Ausgabe: Anzahl der Tage mit Sonnenschein: 3

assignments/spread-operator.md

@@ -0,0 +1,33 @@
+### Spread Operator
+
+Gegeben sei folgender Groovy-Code:
+
+```Groovy
+class Person {
+    def name
+    def alter
+
+    def printIfAdult() {
+        if (this.alter > 17) {
+            println this.name + " ist volljährig."
+        }
+    }
+}
+
+def personen = //Hier die Liste einfügen
+
+for (person in personen) {
+    person.printIfAdult()
+}
+```
+
+Erstellen Sie an der angegebenen Stelle eine Liste von folgenden Personen mit folgenden Attributen:
+
+| Name  | Alter |
+| ----- | ----- |
+| Max   | 12    |
+| Karl  | 40    |
+| Laura | 23    |
+| Ali   | 15    |
+
+Schreiben sie nun den Code so um, sodass anstelle der for-in-Schleife ein passender Operator benutzt wird.

assignments/taschenrechner.md

@@ -0,0 +1,13 @@
+### Taschenrechner 
+
+a) Erstelle eine Klasse Calculator, die Methoden für die Grundrechenoperationen
+   Addition, Subtraktion, Multiplikation und Division bereitstellt. Implementiere die
+   Methoden `add(int a, int b)`, `subtract(int a, int b)`, `multiply(int a, int b)` und
+   `divide(int a, int b)`. Die Methoden sollen die beiden übergebenen Zahlen
+   entsprechend der Operation verarbeiten und das Ergebnis zurückgeben.
+
+b) Erweitere die Klasse um eine Methode `performOperation(int a, int b, Closure
+   operation)`, die eine Closure als Parameter akzeptiert. Diese Closure soll eine
+   Berechnung mit den beiden Zahlen durchführen und das Ergebnis zurückgeben. Zeige,
+   wie man diese Methode verwendet, indem du verschiedene Closures übergibst.
+   

assignments/wetterprognose.md

@@ -0,0 +1,35 @@
+### Wetterprognose für die Party 
+
+Da Anna und Tom nun ihre Begrüßungsliste haben, möchten sie natürlich auch sicherstellen, dass das Wetter gut ist. Sie haben eine Liste von täglichen Wettervorhersagen für die nächste Woche und möchten die Tage mit Sonnenschein zählen, um zu entscheiden, welcher Tag am besten für die Party geeignet ist. Helfen sie den beiden, indem sie ein Groovy Programm schreiben, welche die Anzahl der Zahe mit Sonnenschein in der Wettervorhersage berechnet.
+
+Das Programm soll:
+
+1. Eine Liste von täglichen Wettervorhersagen entgegennehmen
+   Beispiel ["Sonnig", "Regen", "Wolken", "Sonnig", "Sonnig", "Regen", "Wolken"]
+2. Die Anzahl der Tage mit Sonnenschein ("Sonnig") in der Liste zählen.
+3. Die Anzahl der Tage mit Sonnenschein ausgeben.
+
+Achten sie darauf, dass sie hier keine statische Methode benutzen, sondern eine Klasse schreiben, deren Konstruktor man die Liste übergibt und die dann den Rest übernimmt (sowohl die Auswertung, als auch die Ausgabe)
+
+### Testen sie ihren Code mit folgenden Aufrufen:
+````Groovy
+// Test 1: Keine sonnigen Tage
+def vorhersagen1 = ["Regnerisch", "Wolkig", "Regnerisch", "Schnee"]
+def wetter1 = new Wetterprognose(vorhersagen1)
+wetter1.printSunnyDays() // Erwartete Ausgabe: Anzahl der Tage mit Sonnenschein: 0
+
+// Test 2: Einige sonnige Tage
+def vorhersagen2 = ["Sonnig", "Wolkig", "Sonnig", "Regnerisch"]
+def wetter2 = new Wetterprognose(vorhersagen2)
+wetter2.printSunnyDays() // Erwartete Ausgabe: Anzahl der Tage mit Sonnenschein: 2
+
+// Test 3: Alle Tage sonnig
+def vorhersagen3 = ["Sonnig", "Sonnig", "Sonnig", "Sonnig"]
+def wetter3 = new Wetterprognose(vorhersagen3)
+wetter3.printSunnyDays() // Erwartete Ausgabe: Anzahl der Tage mit Sonnenschein: 4
+
+// Test 4: Wechselhaftes Wetter
+def vorhersagen4 = ["Regnerisch", "Sonnig", "Wolkig", "Sonnig", "Schnee", "Sonnig"]
+def wetter4 = new Wetterprognose(vorhersagen4)
+wetter4.printSunnyDays() // Erwartete Ausgabe: Anzahl der Tage mit Sonnenschein: 3
+````

aufgaben/ileyan_aufgaben.md

@@ -1,75 +0,0 @@
-## Leicht: Gegensätze ziehen sich an
-
-Anna und Tom denken, sie sind ineinander verliebt. Nun wollen sie wissen, ob ihre Beziehung auch lange hält und sie wirklich Seelenverwandte sind. Das können sie nur rausfinden, wenn sie das in ihrem Dorf beliebte Blütenspiel spielen. Hierzu nimmt sich jeder der beiden eine Blume. Hat eine der Blumen eine ungerade Anzahl an Blüten und die andere eine gerade Anzahl, dann sind die beiden wirklich für einander bestimmt.
-
-Schreibem sie ein Groovy Programm, dass die Anzahl der Blüten von beiden Blumen übergeben bekommt. Das Programm soll die beiden Zahlen miteinander vergleichen und je nachdem ausgeben, ob die beiden für einander bestimmt sind oder nicht.
-
-### Lösung:
-
-```Groovy
-def seelenverwandt(int ersteBlume, int zweiteBlume) {
-    if ((ersteBlume % 2) != (zweiteBlume % 2)) {
-        print "Ihr seid für einander bestimmt"!
-    }
-    else {
-        print "Die Beziehung hält kein Leben lang..."
-    }
-}
-```
-
-## Mittel: Begrüßungsliste
-
-Anna und Tom haben diesmal beschlossen, eine kleine Party zu veranstalten und möchten sichergehen, dass sie alle ihre eingeladenen Freunde auf der Begrüßungsliste haben. Schreiben sie ein Groovy Programm, dass den beiden dabei hilft, die Namen ihrer Freunde hizuzufügen und die Liste anzuzeigen. Hierbei soll es möglich sein sowohl einzelne, als auch mehrere Namen hinzuzufügen. Tipp: Benutzen sie für die Implementierung eine Liste, sehen sie jedoch davon ab die list.add() Methode zu benutzen. Groovy bietet hier einen komfortableren Weg.
-
-### Lösung:
-
-```Groovy
-class Begruessungsliste {
-    List<String> namen = []
-
-    def addNames(String... neueNamen) {
-        namen << neueNamen
-        neueNamen.each { println "${it} wurde zur Begrüßungsliste hinzugefügt."}
-    }
-
-    def showList() {
-        println "Aktuelle Begrüßungsliste: "
-        namen.each { println "- ${it}"}
-    }
-}
-```
-
-## Schwer: Wetterprognose für die Party
-
-Da Anna und Tom nun ihre Begrüßungsliste haben, möchten sie natürlich auch sicherstellen, dass das Wetter gut ist. Sie haben eine Liste von täglichen Wettervorhersagen für die nächste Woche und möchten die Tage mit Sonnenschein zählen, um zu entscheiden, welcher Tag am besten für die Party geeignet ist. Helfen sie den beiden, indem sie ein Groovy Programm schreiben, welche die Anzahl der Zahe mit Sonnenschein in der Wettervorhersage berechnet.
-
-Das Programm soll:
-
-1. Eine Liste von täglichen Wettervorhersagen entgegennehmen
-   Beispiel ["Sonnig", "Regen", "Wolken", "Sonnig", "Sonnig", "Regen", "Wolken"]
-2. Die Anzahl der Tage mit Sonnenschein ("Sonnig") in der Liste zählen.
-3. Die Anzahl der Tage mit Sonnenschein ausgeben.
-
-Achten sie darauf, dass sie hier keine statische Methode benutzen, sondern eine Klasse schreiben, deren Konstruktor man die Liste übergibt und die dann den Rest übernimmt (sowohl die Auswertung, als auch die Ausgabe)
-
-### Lösung:
-
-```Groovy
-class Wetterprognose {
-    List<String> vorgersagen
-
-    Wetterprognose(List<String> vorhersagen) {
-        this.vorhersagen = vorhersagen
-    }
-
-    def countSunnyDays() {
-        int count = 0
-        vorhersagen.each {if {it == "Sonnig"} count++}
-        return count
-    }
-
-    def printSunnyDays() {
-        println "Anzahl der Tage mit Sonnenschein ${countSunnyDays(vorhersagen)}"
-    }
-}
-```

aufgaben/ileyan_klausuraufgaben.md

@@ -1,317 +0,0 @@
-## GStrings vs Strings:
-
-Erläutern sie kurz den Unterschied zwischen einem GString in Groovy und einem String und wie man einen mehrzeiligen GString definieren kann.
-
-_Ein GString erlaubt es Variablen und Ausdrücke in einen String zu einzubetten, während ein String ein ganz herkömmlicher Java String ist, der keine Einbettugnen unterstützt. Mehrzeilige GStrings werden durch dreifache Anführungszeichen (""") definiert._
-
----
-
-## Save Navigation Operator
-
-Wie kann man in Groovy sicherstellen, dass in folgendem Codebeispiel keine NullPointerException auftritt? Sehen sie davon ab try-catch-Blöcke zu verwenden. Hier ist ein bestimmter Operator gefordert.
-
-```Groovy
-class Person {
-    def name
-    def address
-}
-
-class Address {
-    def city
-    def street
-}
-
-def person = new Person(name: "Thomas Smits")
-
-println(person.address.city)
-```
-
-_Indem man den safe navigation Operator, statt der herkömmlichen Navigation durch den "." Operator benutzt:_
-
-```Groovy
-println(person?.address?.city)
-```
-
----
-
-# Live Übung:
-
-## Closure benutzen:
-
-Schreiben sie ein Groovy-Skript, dass eine gegebene Liste von Zahlen (1-10) filtert und hierbei nur die geraden Zahlen behält. Geben sie das Ergebnis auf der Konsole aus. Verwenden sie für ihre Implementierung ein Closure und die findAll() Methode für Listen.
-
-_Tipp: Die findAll() Methode nimmt ein Closure an und gibt eine neue Liste zurück, die alle Elemente enthält, für die die Bedingung des Closures gelten._
-
-#### Lösung:
-
-```Groovy
-def zahlen = (1..10).toList()
-def istGerade = { zahl -> zahl % 2 == 0 }
-def geradeZahlen = zahlen.findAll(istGerade)
-println geradeZahlen
-```
-
----
-
-## Klassen und Closures:
-
-Gegeben sei eine simple Klasse **Person**, die als Attribute den Namen und das Alter einer Person erhält.
-
-```Groovy
-class Person{
-    def name
-    def alter
-}
-```
-
-Kopieren sie den obrigen Code, erstellen sie folgende drei Objekte dieser Klasse und packen sie diese in eine Liste:
-
-| Name  | Alter |
-| ----- | ----- |
-| Max   | 12    |
-| Karl  | 40    |
-| Laura | 23    |
-
-Erweitern sie die Klasse nicht, sondern nehmen Sie sie genauso wie sie ist. Wenden sie nun zwei Closures auf diese Liste an, um alle Personen, die volljährig sind in eine Liste zu schreiben. Die Namen sollen diesmal aber groß geschrieben sein. Ihre Ausgabe sollte also wie folgt aussehen:
-
-```Groovy
-[KARL, LAURA]
-```
-
-_Tipp: Sie werden sowohl die **findAll()**, als auch die **collect()** Methode auf Listen brauchen. Beide Methoden nehmen ein Closure als Argument an. \
-Die **findAll()** Methode prüft alle Elemente einer Liste auf eine Bedingung und gibt eine neue Liste aus mit allen Elementen, auf die die Bedingung zutrifft. \
-Die **collect()** Methode wird verwendet, um eine Liste oder eine Sammlung zu transformieren und gibt eine neue Liste mit den transformierten Elementen aus._
-
-#### Lösung:
-
-```Groovy
-class Person {
-    def name
-    def alter
-    }
-
-def personen = [new Person(name: "Max", alter: 12), new Person(name: "Karl", alter: 40), new Person(name: "Laura", alter: 23)]
-
-def volljaehrig = { person -> person.alter > 17}
-def erwachsenePersonen = personen.findAll(volljaehrig)
-
-def nameInGrossbuchstaben = { person -> person.name.toUpperCase() }
-def ergebnis = erwachsenePersonen.collect(nameInGrossbuchstaben)
-
-println ergebnis
-
-```
-
----
-
-## Spread Operator:
-
-Gegeben sei folgender Groovy-Code:
-
-```Groovy
-class Person {
-    def name
-    def alter
-
-    def printIfAdult() {
-        if (this.alter > 17) {
-            println this.name + " ist volljährig."
-        }
-    }
-}
-
-def personen = //Hier die Liste einfügen
-
-for (person in personen) {
-    person.printIfAdult()
-}
-```
-
-Erstellen Sie an der angegebenen Stelle eine Liste von folgenden Personen mit folgenden Attributen:
-
-| Name  | Alter |
-| ----- | ----- |
-| Max   | 12    |
-| Karl  | 40    |
-| Laura | 23    |
-| Ali   | 15    |
-
-Schreiben sie nun den Code so um, sodass anstelle der for-in-Schleife ein passender Operator benutzt wird.
-
-#### Lösung:
-
-```Groovy
-class Person {
-    def name
-    def alter
-
-    def printIfAdult() {
-        if (this.alter > 17) {
-            println this.name + " ist volljährig."
-        }
-    }
-}
-
-def personen = [new Person(name: "Max", alter: 12), new Person(name: "Karl", alter: 40), new Person(name: "Laura", alter: 23), new Person(name: "Ali", alter: 15)]
-
-// Hier den Spread-Operator benutzen
-personen*.printIfAdult()
-```
-
----
-
-## Ranges:
-
-Schreiben sie ein kurzes Groovy-Skript, in dem sie eine Range von 1-25 erstellen. Zusätzlich soll die Range die Zahlen in dreier-Sprüngen enthalten:
--> (1,4,7,10...)
-
-Erstellen sie als nächstes eine Range, die die Kleinbuchstaben a-z enthält.
-
-Geben sie beide Ranges auf der Konsole aus.
-
-_Tipp: Benutzen sie für die zweite Range zum ausgeben folgende Methode:_
-
-```Groovy
-// (Es wird später noch genauer hierauf eingegangen.)
-letters.each{print it + " "}
-```
-
-#### Lösung:
-
-```Groovy
-def numbers = (1..25).step 3
-def letters = 'a'..'z'
-println numbers
-letters.each{print it + " "}
-```
-
----
-
-## for-in-Schleifen
-
-Gegeben sei folgender String:
-
-```Groovy
-def str = "GGRROOOOVVYY  IISSTT  CCOOOOLL!!"
-```
-
-Benutzen sie eine for-in Schleife, um auf diesem String folgende Ausgabe zu erzeugen, definieren sie hierbei **keinen** neuen String.
-
-```Groovy
-"groovy ist cool!"
-```
-
-#### Lösung:
-
-```Groovy
-def str = "GGRROOOOVVYY  IISSTT  CCOOOOLL!!"
-
-for(i in 0..str.length()) {
-    if (i % 2 == 0) {
-        continue
-    }
-    print str[i].toLowerCase()
-}
-```
-
----
-
-## Schleifen umwandeln:
-
-Gegeben sei folgender Groovy-Code:
-
-```Groovy
-def str = "GGRROOOOVVYY  IISSTT  CCOOOOLL!!"
-
-for(int i = 0; i < str.length(); i++){
-    if (i % 2 == 0) {
-        continue
-    }
-    print str[i].toLowerCase()
-}
-```
-
-Schauen sie sich die Ausgabe an und wandeln sie den Code so um, dass eine while-Schleife benutzt wird, aber die gleiche Ausgabe erzeugt wird.
-
-#### Lösung:
-
-```Groovy
-def str = "GGRROOOOVVYY  IISSTT  CCOOOOLL!!"
-
-int i = 0
-
-while (i < str.length()) {
-    if (i % 2 == 0) {
-        i++
-        continue
-    }
-    print str[i].toLowerCase()
-    i++
-}
-```
-
----
-
-## Code umwandeln:
-
-Gegeben sei folgender Java-Code:
-
-```Java
-import java.util.ArrayList;
-import java.util.List;
-
-public class Main {
-    public static void main(String[] args) {
-        List<String> names = new ArrayList<>();
-        names.add("Alice");
-        names.add("Bob");
-        names.add("Charlie");
-        names.add("David");
-        names.add("Eve");
-
-        for (String name : names) {
-            System.out.println(name);
-        }
-
-        int sum = 0;
-        for (int i = 1; i <= 10; i++) {
-            sum += i;
-        }
-        System.out.println("Sum of numbers from 1 to 10: " + sum);
-    }
-}
-```
-
-Der Code hat folgende Ausgabe:
-
-```
-Alice
-Bob
-Charlie
-David
-Eve
-Summe der Zahlen von 1 bis 10: 55
-```
-
-Wandeln sie den Java-Code so in Groovy-Code um, dass er die selbe Ausgabe erzeugt und folgende Groovy-Features benutzt:
-
-1. String Interpolation
-2. Ranges
-3. Variablendefinition mit **def**
-4. each-Schleifen und Closures
-5. Dynamische Listen
-6. for-in Schleifen
-
-Versuchen sie sich beim implementieren so kurz wie möglich zu halten. Ziel dieser Aufgabe ist es, das gelernte zu wiederholen und zu zeigen wie kompakt Groovy-Code im Vergleich zu Java-Code sein kann.
-
-#### Lösung:
-
-```Groovy
-def names = ["Alice", "Bob", "Charlie", "David", "Eve"]
-names.each{println it}
-def sum = 0
-for (i in 1..10) {
-    sum += i
-}
-println("Summe der Zahlen von 1 bis 10: ${sum}");
-```

aufgaben/klausuraufgaben.md

@@ -1,85 +0,0 @@
-
-### Aufgabe 1 (2 Punkte)
-Erklären Sie kurz die Funktion des "Elvis-Operators" in Groovy und geben Sie ein passendes Beispiel
-
-##### Lösung
-Der "Elvis-Operator" ist eine Kurzform des ternären Operators. Dieser wird verwendet, um einen Standardwert anzugeben, wenn eine Variable "null" oder falsly ist. 
-``` Groovy
-def result = ausdruck1 ?: ausdruck2
-```
-ausdruck2 ist der Standartwert, falls ausdruck1 null oder falsly ist.
-
-### Aufgabe 2 (2 Punkte)
-Überführen Sie folgende Java-Code in Groovy-Code
-
-```java
-public static void main(String[] args){
-	int a = 1;
-	int b = 2;
-	int c = 3;
-	System.out.println("Ihre Zahlen sind: " + a + ", " + b + ", " + c);
-}
-```
-
-##### Lösung
-```Groovy
-def(a,b,c) = [1,2,3]
-println "Das sind Ihre Zahlen: $a, $b, $c"
-```
-
-### Aufgabe 3
-#### a)
-Was gibt folgender Groovy-Code aus ? 
-```Groovy
-def namen = ["Alice", "Bob", "Charlie", "Diana"]
-
-namen.each { name ->
-println name.toUpperCase()
-}
-```
-
-##### Lösung
-ALICE
-BOB
-CHARLIE
-DIANA
-
-#### b)
-Fügen Sie "namen" folgende Werte hinzu: 
-"Paolo", 5
-
-##### Lösung
-```Groovy
-name << "Paolo"
-name << 5
-```
-
-### Aufgabe 4
-Folgende Klasse ist gegeben:
-```Groovy
-class Person{
-	def name
-	def age
-}
-```
-
-Initialisieren Sie ein Objekt der Klasse "Person" mit name = "Reinhard" und age = 12
-
-##### Lösung
-```Groovy
-def person = new Person(name: "Reinhard", age: 12)
-```
-oder
-```Groovy
-def person = new Person()
-person.name = "Reinhard"
-person.age = 12
-```
-
-### Aufgabe 5
-Kreuzen Sie richtige Aussagen an
-- [ ] Groovy ist eine Mischung aus Java und Ruby
-- [ ] Groovy Code lässt sich auch über den Java-Compiler ausführen
-- [ ] Groovy unterstützt sowohl dynamische als auch statische Typisierung
-- [ ] Groovy unterstützt GString-Interpolation
-- [ ] Java-Bibliotheken lassen sich nicht integrieren

aufgaben/yase_aufgaben.md

@@ -1,144 +0,0 @@
-# Aufgaben
-
-## Aufgabe 1: Römer und ihre Zahlen
-
-Die Römer hatten ihre eigene Art, Zahlen zu schreiben, und sie waren ziemlich stolz darauf! Deine Aufgabe ist es, eine Klasse zu erstellen, die eine Dezimalzahl in eine römische Zahl umwandelt. 
-
-## Lösung
-```
-class Roman {
-
-static def romanNumerals = [
-    1000: "M", 900: "CM", 500: "D", 400: "CD",
-    100: "C", 90: "XC", 50: "L", 40: "XL",
-    10: "X", 9: "IX", 5: "V", 4: "IV",
-    1: "I"
-]
-
-static def toRoman(int number) {
-    def result = ""
-    for (entry in romanNumerals.entrySet()) {
-        while (number >= entry.key) {
-            result += entry.value
-            number -= entry.key
-        }
-    }
-    return result
-}
-
-static void main (String[] args) {
-def decimalNumber = 2000
-println("Die Dezimalzahl $decimalNumber wird in römischen Zahlen geschrieben als: ${toRoman(decimalNumber)}")
-    }    
-}
-```
-
-## Aufgabe 2: String-Filter
-
-Schreibe ein Programm, das eine Zeichenkette von der Tastatur einliest und in drei Teile aufteilt:
-
-- Eine Zeile mit nur den Vokalen der Zeichenkette.
-- Eine Zeile mit nur den Konsonanten der Zeichenkette.
-- Eine Zeile mit nur den Sonderzeichen der Zeichenkette (alles außer Vokale und Konsonanten).
-
-### Beispielausgabe:
-
-Für den Eingabestring "Hallo, Welt! 2024" sollte das Programm folgende Ausgaben erzeugen:
-
-```
-a o e
-H l l W l t
-, ! 2 0 2 4
-```
-
-## Lösung
-```
-class StringFilter {
-
-    static void filterString(String input) {
-        def vowels = "aeiouAEIOU"
-        def consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
-
-        def vowelString = ""
-        def consonantString = ""
-        def specialCharString = ""
-
-        for (c in input) {
-            if (vowels.contains(c.toString())) {
-                vowelString += c + " "
-            } else if (consonants.contains(c.toString())) {
-                consonantString += c + " "
-            } else {
-                specialCharString += c + " "
-            }
-        }
-
-        println "Vokale: $vowelString"
-        println "Konsonanten: $consonantString"
-        println "Sonderzeichen: $specialCharString"
-    }
-
-    static void main(String[] args) {
-        print "Bitte gib einen String ein: "
-       def input = System.console().readLine()
-        filterString(input)
-    }
-}
-```
-
-## Aufgabe 3: Zahlenraten!
-Der mächtige Groovy-Zauberer hat sich in seiner geheimen Kammer eine Zahl zwischen 1 und 100 ausgedacht. Deine Aufgabe, tapferer Abenteurer, ist es, diese magische Zahl zu erraten.
-
-Jedes Mal, wenn du eine Zahl eingibst, wird der Groovy-Zauberer dir mitteilen, ob deine Schätzung zu hoch oder zu niedrig war. Deine Herausforderung besteht darin, die richtige Zahl zu finden, indem du so lange rätst, bis du die magische Zahl des Zauberers gefunden hast.
-
-Schreibe ein Programm, das folgende Anforderungen erfüllt:
-
-Das Programm generiert eine zufällige Zahl zwischen 1 und 100.
-Der Benutzer wird aufgefordert, eine Zahl einzugeben.
-Das Programm gibt eine Rückmeldung, ob die eingegebene Zahl zu hoch oder zu niedrig ist.
-Der Benutzer rät so lange, bis er die richtige Zahl gefunden hat.
-Wenn die Zahl erraten wurde, gibt das Programm eine Erfolgsmeldung aus.
-Viel Spaß beim Raten, und möge der Groovy-Zauber mit dir sein!
-
-## Lösung
-```
-import java.util.Random
-import java.util.Scanner
-
-class GuessingGame {
-
-    private int targetNumber
-    private Random random = new Random()
-
-    GuessingGame() {
-        targetNumber = random.nextInt(100) + 1
-    }
-
-    boolean checkGuess(int guess) {
-        if (guess > targetNumber) {
-            println("Zu hoch! Versuch es nochmal.")
-            return false
-        } else if (guess < targetNumber) {
-            println("Zu niedrig! Versuch es nochmal.")
-            return false
-        } else {
-            println("Herzlichen Glückwunsch! Du hast die Zahl $targetNumber erraten!")
-            return true
-        }
-    }
-
-    static void main(String[] args) {
-        Scanner scanner = new Scanner(System.in)
-        GuessingGame game = new GuessingGame()
-        boolean correctGuess = false
-
-        println("Willkommen beim ultimativen Ratespiel! Ich habe mir eine Zahl zwischen 1 und 100 ausgedacht. Kannst du sie erraten?")
-
-        while (!correctGuess) {
-            print("Gib deine Zahl ein: ")
-            int guess = scanner.nextInt()
-            correctGuess = game.checkGuess(guess)
-        }
-    }
-}
-```

aufgaben/yuliya_aufgaben.md

@@ -1,183 +0,0 @@
-# Übungsaufgaben
-
-## Aufgabe 1
-
-### Aufgabenstellung:
-
-
-Erstellen Sie eine Klasse Person, die eine Instanzvariable name vom Typ String und
-eine Instanzvariable age vom Typ int hat. Implementieren Sie einen entsprechenden
-Kostruktor, der die Instanzvariablen initialisiert.
-Fügen Sie außerdem eine Methode introduce() hinzu,
-die eine Vorstellung der Person auf der Konsole ausgibt. Erstellen Sie eine Instanz
-der Klasse und rufen Sie die Methode introduce() auf.
-
-### Lösung
-```
-class Person {
-    String name
-    int age
-
-    Person(String name, int age) {
-        this.name = name
-        this.age = age
-    }
-
-    def introduce() {
-        println("Hello, my name is ${name} and I am ${age} years old.")
-    }
-}
-
-// Verwendung der Klasse Person
-def person = new Person("Alice", 30)
-person.introduce()
-```
-
-## Aufgabe 2
-
-### Aufgabenstellung:
-
-a) Erstelle eine Klasse Calculator, die Methoden für die Grundrechenoperationen
-   Addition, Subtraktion, Multiplikation und Division bereitstellt. Implementiere die
-   Methoden add(int a, int b), subtract(int a, int b), multiply(int a, int b) und
-   divide(int a, int b). Die Methoden sollen die beiden übergebenen Zahlen
-   entsprechend der Operation verarbeiten und das Ergebnis zurückgeben.
-
-b) Erweitere die Klasse um eine Methode performOperation(int a, int b, Closure
-   operation), die eine Closure als Parameter akzeptiert. Diese Closure soll eine
-   Berechnung mit den beiden Zahlen durchführen und das Ergebnis zurückgeben. Zeige,
-   wie man diese Methode verwendet, indem du verschiedene Closures übergibst.
-   
-### Lösung
-```
-class Calculator {
-    def add(int a, int b) {
-        return a + b
-    }
-
-    def subtract(int a, int b) {
-        return a - b
-    }
-
-    def multiply(int a, int b) {
-        return a * b
-    }
-
-    def divide(int a, int b) {
-        if (b == 0) {
-            println("Error: Division by zero!")
-            return
-        }
-        return a / b
-    }
-
-    def performOperation(int a, int b, Closure operation) {
-        return operation(a, b)
-    }
-}
-
-// Verwendung der Klasse Calculator
-def calc = new Calculator()
-
-// Grundrechenoperationen
-println("Addition: ${calc.add(5, 3)}")
-println("Subtraction: ${calc.subtract(10, 7)}")
-println("Multiplication: ${calc.multiply(4, 6)}")
-println("Division: ${calc.divide(12, 4)}")
-
-// Closures definieren
-def addClosure = { int a, int b -> a + b }
-def subtractClosure = { int a, int b -> a - b }
-def multiplyClosure = { int a, int b -> a * b }
-def divideClosure = { int a, int b -> 
-    if (b == 0) {
-        println("Error: Division by zero!")
-        return
-    }
-    return a / b 
-}
-
-// Verwendung von performOperation mit Closures
-println("Addition mit Closure: ${calc.performOperation(5, 3, addClosure)}")
-println("Subtraction mit Closure: ${calc.performOperation(10, 7, subtractClosure)}")
-println("Multiplication mit Closure: ${calc.performOperation(4, 6, multiplyClosure)}")
-println("Division mit Closure: ${calc.performOperation(12, 4, divideClosure)}")
-```
-
-## Aufgabe 3
-
-### Aufgabenstellung
-Erstellen Sie eine Klasse EmployeeManager, die die Verwaltung von Mitarbeitern
-ermöglicht. Die Klasse soll folgende Funktionen bieten:
-
-1. Hinzufügen von Mitarbeitern mit Name und Gehalt.
-2. Aktualisieren des Gehalts eines Mitarbeiters.
-3. Entfernen eines Mitarbeiters.
-4. Durchführen von Gehaltsanpassungen für alle Mitarbeiter basierend auf einer Closure, die eine Gehaltsanpassungslogik definiert.
-5. Abrufen einer Liste von Mitarbeitern, die nach einem bestimmten Kriterium gefiltert wurden (basierend auf einer übergebenen Closure).
-
-```
-class Employee {
-    String name
-    double salary
-
-    Employee(String name, double salary) {
-        this.name = name
-        this.salary = salary
-    }
-
-    String toString() {
-        return "Name: ${name}, Salary: ${salary}"
-    }
-}
-
-class EmployeeManager {
-    List<Employee> employees = []
-
-    void addEmployee(String name, double salary) {
-        employees << new Employee(name, salary)
-    }
-
-    void updateSalary(String name, double newSalary) {
-        employees.find { it.name == name }?.salary = newSalary
-    }
-
-    void removeEmployee(String name) {
-        employees.removeAll { it.name == name }
-    }
-
-    void adjustSalaries(Closure adjustmentLogic) {
-        employees.each { it.salary = adjustmentLogic(it.salary) }
-    }
-
-    List<Employee> filterEmployees(Closure criteria) {
-        return employees.findAll(criteria)
-    }
-}
-
-// Beispielnutzung der Klasse EmployeeManager
-def manager = new EmployeeManager()
-
-// Hinzufügen von Mitarbeitern
-manager.addEmployee("Alice", 50000)
-manager.addEmployee("Bob", 60000)
-manager.addEmployee("Charlie", 55000)
-
-// Aktualisieren des Gehalts eines Mitarbeiters
-manager.updateSalary("Alice", 52000)
-
-// Entfernen eines Mitarbeiters
-manager.removeEmployee("Charlie")
-
-// Durchführen von Gehaltsanpassungen für alle Mitarbeiter
-manager.adjustSalaries { salary -> salary * 1.1 } // 10% Gehaltserhöhung
-
-// Filtern von Mitarbeitern basierend auf einem Kriterium
-def highEarners = manager.filterEmployees { it.salary > 55000 }
-
-println("Alle Mitarbeiter:")
-manager.employees.each { println it }
-
-println("\nHigh Earners:")
-highEarners.each { println it }
-``

aufgaben/yuliya_klausuraufgaben.md

@@ -1,60 +0,0 @@
-# Klausuraufgaben
-
-### 1. Welche Ausgabe hat der Code?
-```
-class Person {
-    String name
-    int age
-    }
-    
-Person person = new Person()
-println (person.name)
-println (person.age)
-```
-
-Lösung
-```
-null
-0
-```
-
-
-### 2. Initialisieren Sie eine Instanz der Klasse Person (s.unten) mit den Attributen "John" und 25, indem Sie eine Map verwenden.
-```
-class Person {
-    String name
-    int age
-    }
-```
-
-Lösung
-```
-Person person = new Person(name: "John", age: 20)
-```
-
-### 3. Was ist ein Mixin in Groovy und wie wird es verwendet?
-
-Lösung
-
-Ein Mixin ermöglicht das Hinzufügen von Funktionalität zu Klassen ohne Vererbung. Es wird mit
-der @Mixin Annotation verwendet.
-
-### 4. Schreibe eine Funktion makeMultiplier, die eine Zahl n als Argument nimmt und eine Closure zurückgibt, die eine Zahl mit n multipliziert.
-```
-def makeMultiplier(n) {
-    // TODO
-}
-
-def multiplierOf3 = makeMultiplier(3)
-println(multiplierOf3(5))  // Erwartete Ausgabe: 15
-```
-
-Lösung
-```
-def makeMultiplier(n) {
-    return {it * n}
-}
-
-def multiplierOf3 = makeMultiplier(3)
-println(multiplierOf3(5))  // Erwartete Ausgabe: 15
-```

aufgaben/yuliya_liveuebung.md

@@ -1,98 +0,0 @@
-# Live-Übung
-
-## Operatoren
-
-### 1) Gegeben ist eine Liste von Strings: 
-```
-def words = ["Groovy", "ist", "cool"]
-```
-Verwende den Spread-Operator *., um eine Liste der Längen dieser Strings zu erstellen.
-
-Lösung
-```
-def words = ["Groovy", "ist", "cool"]
-def lengths = words*.length()
-
-println("Längen: $lengths")  // Erwartete Ausgabe: Längen: [6, 3, 4]
-```
-
-### 2) Gegeben ist eine Liste von Zahlen:
-```
-def numbers = [1, 2, 3, 4, 5]
-```
- Verwende den Spread-Operator *., um eine Liste der Quadrate dieser Zahlen zu erstellen.
- 
- Lösung
- ```
- def numbers = [1, 2, 3, 4, 5]
-
-def squares = numbers*.multiply(numbers)
-
-println("Quadrate: $squares")  // Erwartete Ausgabe: Quadrate: [1, 4, 9, 16, 25]
-```
-
-## Schleifen und Bedingungen
-
-Schreibe eine 
-
-  a) while-Schleife
-
-  b) for-Schleife
-
-, die die Fakultät einer gegebenen Zahl berechnet und ausgibt.
-
-Lösung
-a)
-```
-def zahl = 5
-def ergebnis = 1
-
-for (int i = 1; i <= zahl; i++) {
-    ergebnis *= i
-}
-
-println("Die Fakultät von $zahl ist: $ergebnis")
-```
-
-b)
-```
-def zahl = 5
-def ergbenis = 1
-def i = 1
-
-while (i <= zahl) {
-    ergebnis *= i
-    i++
-}
-
-println("Die Fakultät von $zahl ist: $ergebnis")
-```
-
-
-
-## Closures
-
-Schreibe eine Funktion makeCounter, die eine Closure zurückgibt, die jedes Mal, wenn sie aufgerufen wird, um 1 erhöht.
-```
-def makeCounter() {
-   //TODO
-}
-
-def counter = makeCounter()
-println(counter())  // Erwartete Ausgabe: 1
-println(counter())  // Erwartete Ausgabe: 2
-println(counter())  // Erwartete Ausgabe: 3
-```
-
-Lösung
-```
-def makeCounter() {
-    def count = 0
-    return {++count}
-}
-
-def counter = makeCounter()
-println(counter())  // Erwartete Ausgabe: 1
-println(counter())  // Erwartete Ausgabe: 2
-println(counter())  // Erwartete Ausgabe: 3
-```