diff --git a/yuliya/aufgaben.md b/yuliya/aufgaben.md
index fb99f70..026c5bc 100644
--- a/yuliya/aufgaben.md
+++ b/yuliya/aufgaben.md
@@ -1,4 +1,6 @@
-# Aufgabe 1
+# Übungsaufgaben
+
+## Aufgabe 1
 
 ### Aufgabenstellung:
 
@@ -31,7 +33,8 @@ def person = new Person("Alice", 30)
 person.introduce()
 ```
 
-# Aufgabe 2
+## Aufgabe 2
+
 ### Aufgabenstellung:
 
 a) Erstelle eine Klasse Calculator, die Methoden für die Grundrechenoperationen
@@ -101,7 +104,8 @@ println("Multiplication mit Closure: ${calc.performOperation(4, 6, multiplyClosu
 println("Division mit Closure: ${calc.performOperation(12, 4, divideClosure)}")
 ```
 
-# Aufgabe 3
+## Aufgabe 3
+
 ### Aufgabenstellung
 Erstellen Sie eine Klasse EmployeeManager, die die Verwaltung von Mitarbeitern
 ermöglicht. Die Klasse soll folgende Funktionen bieten:
@@ -176,46 +180,4 @@ manager.employees.each { println it }
 
 println("\nHigh Earners:")
 highEarners.each { println it }
-```
-
-## Klausuraufgaben
-
-### 1. Was ist ein Default-Konstruktor? 
-
-Lösung
-
-Groovy fügt automatisch einen Standardkonstruktor hinzu, wenn keine Konstruktoren explizit
-definiert sind. Dieser Konstruktor initialisiert alle Eigenschaften der Klasse mit ihren
-Standardwerten.
-
-### 2. Folgende Klasse ist vorgegeben:
-```
-class Person {
-    String name
-    int age
-    }
-```
-### Initialisieren Sie eine Instanz der Klasse Person mit Attributen "John" und 25.
-
-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. Wie iteriert man über eine Map in Groovy und was gibt die each Methode zurück? Beipiel?
-
-Lösung
-
-Man iteriert über eine Map mit der each Methode. Diese Methode gibt jedes Key-Value-Paar der
-Map zurück.
-```
-def myMap = ['subject': 'groovy', 'topic': 'closures']
-myMap.each { key, value -> println "$key: $value" }
-```
+``
diff --git a/yuliya/groovy.pptx.zip b/yuliya/groovy.pptx.zip
new file mode 100644
index 0000000..60bb16e
Binary files /dev/null and b/yuliya/groovy.pptx.zip differ
diff --git a/yuliya/klausuraufgaben.md b/yuliya/klausuraufgaben.md
new file mode 100644
index 0000000..175311c
--- /dev/null
+++ b/yuliya/klausuraufgaben.md
@@ -0,0 +1,60 @@
+# 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
+```
diff --git a/yuliya/liveuebung.md b/yuliya/liveuebung.md
new file mode 100644
index 0000000..1497dc7
--- /dev/null
+++ b/yuliya/liveuebung.md
@@ -0,0 +1,98 @@
+# 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
+```