diff --git a/exercises/block2/1-map/README.md b/exercises/block2/1-map/README.md
index c37b1cd..21e27fb 100644
--- a/exercises/block2/1-map/README.md
+++ b/exercises/block2/1-map/README.md
@@ -1,19 +1,19 @@
-# Aufgabe 1 - Rekursive Implementierung von `map`
+# Aufgabe 2 - Rekursive Implementierung von `map`
## Ziel der Aufgabe
Implementiere die Funktion `map` rekursiv. Die Funktion nimmt eine Funktion `f` und eine Liste `xs` und gibt eine neue Liste zurück, in der `f` auf jedes Element von `xs` angewendet wurde.
## Signatur
```haskell
-map :: (a -> b) -> [a] -> [b]
+myMap :: (a -> b) -> [a] -> [b]
```
## Beispiel Testfäle
```haskell
-map (*2) [1, 2, 3] -- [2, 4, 6]
-map show [1, 2, 3] -- ["1", "2", "3"]
-map (const "a") [1, 2, 3] -- ["a", "a", "a"]
-map (+1) [] -- []
+myMap (*2) [1, 2, 3] -- [2, 4, 6]
+myMap show [1, 2, 3] -- ["1", "2", "3"]
+myMap (const "a") [1, 2, 3] -- ["a", "a", "a"]
+myMap (+1) [] -- []
```
## Anforderungen
@@ -22,5 +22,9 @@ map (+1) [] -- []
- Nutze Pattern Matching, um Basis- und Rekursionsfall zu unterscheiden
## Hinweise
+
+ Klicke auf den Pfeil für Hinweise
+
- Die leere Liste `[]` soll als Basisfall betrachtet werden
-- Die Funktion `f` soll auf das erste Element der Liste angewendet und dann mit dem Rest der Liste rekursiv weitergeführt werden
\ No newline at end of file
+- Die Funktion `f` soll auf das erste Element der Liste angewendet und dann mit dem Rest
+
\ No newline at end of file
diff --git a/exercises/block2/1-map/map.hs b/exercises/block2/1-map/map.hs
index c7697a8..e290ac7 100644
--- a/exercises/block2/1-map/map.hs
+++ b/exercises/block2/1-map/map.hs
@@ -1,22 +1,22 @@
--- Aufgabe: Implementiere die rekursive Funktion `map`
+-- Aufgabe: Implementiere die rekursive Funktion `myMap`
-- Funktionssignatur
-map :: (a -> b) -> [a] -> [b]
+myMap :: (a -> b) -> [a] -> [b]
-- TODO: Implementiere die Funktion mit Rekursion
-map _ [] = undefined
-map f (x:xs) = undefined
+myMap _ [] = undefined
+myMap f (x:xs) = undefined
-- Testfälle
-test1 = map (*2) [1,2,3] == [2,4,6]
-test2 = map show [1,2,3] == ["1", "2", "3"]
-test3 = map (+1) [] == []
-test4 = map (const "a") [1,2,3] == ["a", "a", "a"]
+test1 = myMap (*2) [1,2,3] == [2,4,6]
+test2 = myMap show [1,2,3] == ["1", "2", "3"]
+test3 = myMap (+1) [] == []
+test4 = myMap (const "a") [1,2,3] == ["a", "a", "a"]
-- Hauptfunktion zum Testen
main :: IO ()
main = do
- putStrLn "Teste map-Funktion..."
+ putStrLn "Teste myMap-Funktion..."
print test1
print test2
print test3
diff --git a/exercises/block2/2-zip/README.md b/exercises/block2/2-zip/README.md
index 7fd1e48..d7d55c4 100644
--- a/exercises/block2/2-zip/README.md
+++ b/exercises/block2/2-zip/README.md
@@ -5,16 +5,16 @@ Implementiere die Funktion `zip` rekursiv. Die Funktion nimmt zwei Listen und gi
## Signatur
```haskell
-zip :: [a] -> [b] -> [(a, b)]
+myZip :: [a] -> [b] -> [(a, b)]
```
## Beispiel Testfäle
```
-zip [1,2,3] ['a', 'b', 'c'] -- [(1, 'a'), (2, 'b'), (3, 'c')]
-zip [1,2] ["eins", "zwei", "drei"] -- [(1, "eins"), (2, "zwei")]
-zip [True, False] [1,2,3] -- [(True,1), (False,2)]
-zip [] [1,2,3] -- []
-zip [1,2,3] [] -- []
+myZip [1,2,3] ['a', 'b', 'c'] -- [(1, 'a'), (2, 'b'), (3, 'c')]
+myZip [1,2] ["eins", "zwei", "drei"] -- [(1, "eins"), (2, "zwei")]
+myZip [True, False] [1,2,3] -- [(True,1), (False,2)]
+myZip [] [1,2,3] -- []
+myZip [1,2,3] [] -- []
```
@@ -23,6 +23,11 @@ zip [1,2,3] [] -- []
- Nutze kein zip aus der Standardbibliothek
- Die Funktion soll enden, sobald eine der beiden Listen leer ist
+
## Hinweise
-- Der Basisfall tritt ein, wenn eine der Listen leer ist
-- Kombiniere das erste Element beider Listen zu einem Tupel und rufe zip rekursiv für die restlichen Elemente auf
\ No newline at end of file
+
+ Klicke auf den Pfeil für Hinweise
+
+ - Der Basisfall tritt ein, wenn eine der Listen leer ist
+ - Kombiniere das erste Element beider Listen zu einem Tupel und rufe zip rekursiv für die restlichen Elemente auf
+
diff --git a/exercises/block2/2-zip/zip.hs b/exercises/block2/2-zip/zip.hs
index d07a464..80d30eb 100644
--- a/exercises/block2/2-zip/zip.hs
+++ b/exercises/block2/2-zip/zip.hs
@@ -1,24 +1,32 @@
--- Aufgabe: Implementiere die rekursive Funktion `zip`
+-- Aufgabe: Implementiere die rekursive Funktion `myZip`
-- Funktionssignatur
-zip :: [a] -> [b] -> [(a, b)]
+myZip :: [a] -> [b] -> [(a, b)]
-- TODO: Implementiere die Funktion mit Rekursion
-zip [] _ = undefined
-zip _ [] = undefined
-zip (x:xs) (y:ys) = undefined
+myZip [] _ = undefined
+myZip _ [] = undefined
+myZip (x:xs) (y:ys) = undefined
--- Testfälle
-test1 = zip [1,2,3] ['a', 'b', 'c'] == [(1, 'a'), (2, 'b'), (3, 'c')]
-test2 = zip [1,2] ["eins", "zwei", "drei"] == [(1, "eins"), (2, "zwei")]
-test3 = zip [True, False] [1,2,3] == [(True,1), (False,2)]
-test4 = zip [] [1,2,3] == []
-test5 = zip [1,2,3] [] == []
+-- Testfälle mit `null` und expliziten Typannotationen
+test1 :: Bool
+test1 = myZip [1,2,3] ['a', 'b', 'c'] == [(1, 'a'), (2, 'b'), (3, 'c')]
+test2 :: Bool
+test2 = myZip [1,2] ["eins", "zwei", "drei"] == [(1, "eins"), (2, "zwei")]
+
+test3 :: Bool
+test3 = myZip [True, False] [1,2,3] == [(True,1), (False,2)]
+
+test4 :: Bool
+test4 = null (myZip [] [1,2,3])
+
+test5 :: Bool
+test5 = null (myZip [1,2,3] [])
-- Hauptfunktion zum Testen
main :: IO ()
main = do
- putStrLn "Teste zip-Funktion..."
+ putStrLn "Teste myZip-Funktion..."
print test1
print test2
print test3
diff --git a/exercises/block2/3-fibTail/README.md b/exercises/block2/3-fibTail/README.md
new file mode 100644
index 0000000..95fc61d
--- /dev/null
+++ b/exercises/block2/3-fibTail/README.md
@@ -0,0 +1,52 @@
+# Aufgabe 3 - Fibonacci mit Tail-Rekursion
+
+## Ziel der Aufgabe
+Implementiere die Fibonacci-Funktion mit **Tail-Rekursion**, ähnlich wie die `factorialTail`-Funktion. Die Lösung soll eine Hilfsfunktion mit einem Akkumulator verwenden.
+
+
+ Spoiler: Klicke auf den Pfeil für factorialTail
+
+```haskell
+factorialTail :: Integer -> Integer -> Integer
+factorialTail 0 acc = acc
+factorialTail n acc = factorialTail (n - 1) (n * acc)
+
+factorial :: Integer -> Integer
+factorial n = factorialTail n 1
+```
+
+
+
+## Signatur
+```haskell
+fibonacciTail :: Integer -> Integer -> Integer -> Integer
+
+```
+
+## Beispiel Testfäle
+```
+fibTail 0 -- 0
+fibTail 1 -- 1
+fibTail 5 -- 5
+fibTail 10 -- 55
+fibTail 15 -- 610
+```
+
+## Anforderungen
+- Implementiere fibonacciTail, eine Hilfsfunktion mit einem Akkumulator
+- Implementiere fibonacci, die fibonacciTail mit den Startwerten 0 und 1 aufruft
+- Nutze keine if-Statements, sondern Pattern Matching
+- Nutze Tail-Rekursion für eine speichereffiziente Lösung
+
+## Hinweise
+
+ Klicke auf den Pfeil für Hinweise
+
+- fibonacciTail benötigt drei Parameter:
+ - 1: n (die Anzahl der Schritte)
+ - 2: a (die vorherige Fibonacci-Zahl)
+ - 3: b (die aktuelle Fibonacci-Zahl)
+- Wenn n == 0 ist, gib a zurück
+- Wenn n == 1 ist, gib b zurück
+- Ansonsten rufe die Funktion rekursiv mit n - 1 auf und verschiebe a und b
+
\ No newline at end of file
diff --git a/exercises/block2/3-fibTail/fibTail.hs b/exercises/block2/3-fibTail/fibTail.hs
new file mode 100644
index 0000000..b080a50
--- /dev/null
+++ b/exercises/block2/3-fibTail/fibTail.hs
@@ -0,0 +1,23 @@
+-- Aufgabe: Implementiere die rekursive Fibonacci-Funktion mit Tail-Rekursion
+
+fibonacciTail :: Integer -> Integer -> Integer -> Integer
+-- TODO:
+
+-- Testfälle
+test1 = fibonacci 0 == 0
+test2 = fibonacci 1 == 1
+test3 = fibonacci 2 == 1
+test4 = fibonacci 3 == 2
+test5 = fibonacci 5 == 5
+test6 = fibonacci 10 == 55
+
+-- Hauptfunktion zum Testen
+main :: IO ()
+main = do
+ putStrLn "Teste fibonacci-Funktion mit Tail-Rekursion..."
+ print test1
+ print test2
+ print test3
+ print test4
+ print test5
+ print test6
\ No newline at end of file
diff --git a/exercises/block4/1-listenverdrehen/listenverdrehen.hs b/exercises/block4/1-listenverdrehen/listenverdrehen.hs
index ad1a760..4331731 100644
--- a/exercises/block4/1-listenverdrehen/listenverdrehen.hs
+++ b/exercises/block4/1-listenverdrehen/listenverdrehen.hs
@@ -5,7 +5,7 @@ import qualified Distribution.FieldGrammar as Data
--3. gebe die Liste anschließend rückwärts heraus
--Nutze dafür Methoden aus dem module Data.List
---Achtung nutze den richtigen Import, ansonsten kann es zu name clashes kommen
+--Achtung nutze den richtigen Typ von Import, ansonsten kann es zu name clashes kommen
--Import
@@ -13,4 +13,14 @@ import qualified Distribution.FieldGrammar as Data
--Funktion
-uniqueReverseList :: (Eq a, Ord a) => --hier in der Zeile fehlt noch etwas;)
+uniqueReverseList :: --hier in der Zeile fehlt noch etwas. Tipp: man muss Werte auf gleichheit und verhältnis überprüfen können;)
+
+
+main = do
+
+ let x = uniqueReverseList [2,1,13,1,27,71,59,43] == [71,59,43,27,13,2,1]
+ let y = uniqueReverseList "abcde" == "edcba"
+
+ if x == y
+ then putStrLn "Funktion funktioniert"
+ else putStrLn "Funktion funktioniert nicht"
diff --git a/exercises/block4/4-oche/rueckwartsschreiber.hs b/exercises/block4/4-oche/rueckwartsschreiber.hs
index 19eca57..6ce6083 100644
--- a/exercises/block4/4-oche/rueckwartsschreiber.hs
+++ b/exercises/block4/4-oche/rueckwartsschreiber.hs
@@ -2,7 +2,7 @@
--Tipp: Sinnvoll sind dabei die Verwendung der Funktionen map und reverse, sowie words und unwords
--Funktion reverseWords
-reverseWords :: String -> String
+reverseWords ::
--I/O-Abschnitt