merge

Datenstrukturen.md

@@ -1,3 +1,41 @@
+### Enums
+Enums sind gleich wie in Java
+
+```Groovy
+enum Day{
+	MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
+}
+
+Day today = Day.MONDAY
+```
+
+Man kann in Enums zusätzlich noch Eigenschaften und Methoden einbauen
+
+```Groovy
+enum Day{
+	MONDAY("First Day of the Week"),
+	TUESDAY("Second Day of the Week),
+	//...
+
+	final String description
+
+	Day(String description){
+		this.description = description
+	}
+
+	String getDescription(){
+		return description
+	}
+}
+
+	Day today = Day.FRIDAY
+	def description = today.getDescription
+	println("Today is $today: $description")
+
+```
+
+Zusätzlich dazu kann man auch Methoden überschreiben (z.B. toString()-Methode)
+
 ### Ranges
 Ähnlich wie in Ruby, jedoch nicht gleich
 ```Groovy
@@ -109,3 +147,5 @@ Entfernen eines Elements:
 ```Groovy
 mySet.remove(1)
 println mySet // [2,3,4,5,6,7]
+```
+

ileyan/aufgaben.md

@@ -0,0 +1,75 @@
+## 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)}"
+    }
+}
+```

yase/Schleifen.md

@@ -0,0 +1,100 @@
+# Schleifen
+
+## while-Schleife
+Syntax Kopfgesteuerte `while-Schleife`
+ 
+```
+class Beispiel {
+    static void main(String[] args){
+        def y = 0
+        while (y < 5){
+            print(y + " ") // -> 1 2 3 4 
+            y++
+        }
+    }
+
+}
+```
+
+## for-Schleife
+Syntax der `for-Schleife` wie in Java
+
+```
+class Beispiel {
+    static void main(String[] args){
+        for (int i = 0; i < 5; i++){
+            print(i + " ") // -> 1 2 3 4
+        }
+    }
+}
+```
+
+## for-in Schleife
+```
+for (variable in iterable) {body}
+```
+
+Die `for-in Schleife` folgt dieser einfachen Struktur. Sie durchläuft das Objekt `iterable`. Häufig verwendete Iterables sind Ranges, Collections, Maps, Arrays, Iterators und Enumerationen. Jedes Objekt kann ein Groovy ein Iterable sein. Klammern um den Body sind optinal, wenn er nur aus einer Anweisung besteht.
+Im Folgenden Beispiele für Iterationen:
+
+### über Ranges:
+```
+class Beispiel {
+    static void main(String[] args){
+        for (i in 0..5){
+            print(i + " ") // -> 1 2 3 4 5
+        }
+        for (i in 'a'..<'d'){
+            print(i + " ") // -> a b c letzter Buchstabe exklusiv
+        }
+    }
+}
+```
+
+### über eine Liste:
+```
+class Beispiel {
+    static void main(String[] args){
+        def list = [1, 2, 3, 4, 5]
+        for (element in list){
+            print element + " " // -> 1 2 3 4 5
+        }
+    }
+}
+```
+
+### über eine Array:
+```
+class Beispiel {
+    static void main(String[] args){
+        def arr = ['a', 'b', 'c']
+        for (ch in arr){
+            print (ch + " ") // -> a b c
+        }
+    }
+}
+```
+
+### über eine Map:
+```
+class Beispiel {
+    static void main(String[] args){
+        def map = [name: "Alice", age: 18]
+        for (entry in map){
+            print(${entry.key}: ${entry.value}) // -> name: Alice age: 18
+        }
+    }
+}
+```
+
+### über eine Zeichenfolge:
+```
+class Beispiel {
+    static void main(String[] args){
+        def text = "Groovy"
+        for (ch in text){
+            print(ch + " ") // -> G r o o v y
+        }
+    }
+}
+```

yase/aufgaben_datentypen.md

@@ -0,0 +1,144 @@
+# 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)
+        }
+    }
+}
+```