block 2: 1&2

exercises/block2/1-map/README.md

@@ -0,0 +1,26 @@
+# Aufgabe 1 - 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]
+```
+
+## 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) [] -- []
+```
+
+## Anforderungen
+- Nutze Rekursion zur Implementierung
+- Nutze kein map aus der Standardbibliothek
+- Nutze Pattern Matching, um Basis- und Rekursionsfall zu unterscheiden
+
+## 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

exercises/block2/1-map/map.hs

@@ -0,0 +1,23 @@
+-- Aufgabe: Implementiere die rekursive Funktion `map`
+
+-- Funktionssignatur
+map :: (a -> b) -> [a] -> [b]
+
+-- TODO: Implementiere die Funktion mit Rekursion
+map _ [] = undefined
+map 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"]
+
+-- Hauptfunktion zum Testen
+main :: IO ()
+main = do
+    putStrLn "Teste map-Funktion..."
+    print test1
+    print test2
+    print test3
+    print test4

exercises/block2/2-zip/README.md

@@ -0,0 +1,28 @@
+# Aufgabe 1 - Rekursive Implementierung von `zip`
+
+## Ziel der Aufgabe
+Implementiere die Funktion `zip` rekursiv. Die Funktion nimmt zwei Listen und gibt eine Liste von Paaren zurück, wobei jeweils das erste Element der ersten Liste mit dem ersten Element der zweiten Liste kombiniert wird.
+
+## Signatur
+```haskell
+zip :: [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] [] -- []
+
+```
+
+## Anforderungen
+- Nutze Rekursion zur Implementierung
+- 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

exercises/block2/2-zip/zip.hs

@@ -0,0 +1,26 @@
+-- Aufgabe: Implementiere die rekursive Funktion `zip`
+
+-- Funktionssignatur
+zip :: [a] -> [b] -> [(a, b)]
+
+-- TODO: Implementiere die Funktion mit Rekursion
+zip [] _ = undefined
+zip _ [] = undefined
+zip (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] [] == []
+
+-- Hauptfunktion zum Testen
+main :: IO ()
+main = do
+    putStrLn "Teste zip-Funktion..."
+    print test1
+    print test2
+    print test3
+    print test4
+    print test5