Übungen

Aufgabe 1 - Anonyme Funktionen

Formuliere mit Hilfe von anonymen Funktionen folgende Funktionen:

a) Eine Funktion, die eine Liste von Zahlen auf deren Quadratzahlen abbildet und z.B. so aufgerufen werden kann:

> quadratzahlen [2, 4, 3]
[4,16,9] : List Int

b) Eine Funktion, die alle ungeraden Zahlen einer Liste zurückgibt und z.B. so aufgerufen werden kann:

> ungerade [2, 4, 3, 5, 6]
[3,5] : List Int

c) Eine Funktion, die eine Liste von Zahlen aufsummiert, wenn sie größer als eine gegebene Zahl sind und z.B. so aufgerufen werden kann:

> summeAb 5 [5, 8, 2, 3, 7]
20 : Int

d) Eine Funktion, die aus einer Liste von Noten eine Liste mit den Werten "bestanden" oder "nicht bestanden" berechnet und z.B. so aufgerufen werden kann:

> bestanden [2, 5, 1, 4, 6]
["bestanden", "nicht bestanden", "bestanden", "bestanden", "nicht bestanden"]
    : List String

Aufgabe 2 - Partiell angewandte Funktionen

Der REPL-Dialog benutzt partiell angewandte Funktionen.

> begruessung = String.append "hallo "
<function> : ...
> begruessung "Alex"
...
> wiederhole = String.repeat 4
<function> : ...
> "T" ++ (wiederhole "o") ++ "r"
...
> m = (-) 0
<function> : ...
> m 5
...
> n = (>=) 0
<function> : ...
> n -1
...
> plus x = (+) x
<function> : ...
> inc = plus 1
<function> : ...
> inc 4
...

Stelle zunächst Vermutungen auf, was jeweils anstelle von ... steht. Überprüfe, indem du den REPL-Dialog selbst führst. Erkläre die Ergebnisse.

Aufgabe 3 - Listenverarbeitung mit partiell angewandten Funktionen

Der REPL-Dialog benutzt partiell angewandte Funktionen zur Verarbeitung von Listen.

> List.map ((+) 1) [0,1,2,3]
...
> List.map ((++) "be") ["laden","grüßen","suchen"]
...
> List.filter ((>) 0) [0,1,-1,2,-2]
...
> List.map (String.repeat 2) ["ha","li","ha","lo"]
...
> List.map ((\x y -> y - x) 5) [5,6,7,8]
...
> List.filter ((\x y -> y > x) 0) [0,1,-1,2,-2]
...

Stelle zunächst Vermutungen auf, was jeweils anstelle von ... steht. Überprüfe, indem du den REPL-Dialog selbst führst. Erkläre die Ergebnisse.

Aufgabe 4 - Caesar-Verfahren und Funktionskomposition

a) Buchstaben verschieben

Beim Caesar-Verfahren werden (Groß-) Buchstaben duch (Groß-) Buchstaben ersetzt, die im Alphabet um 3 Einheiten verschoben sind. Der Buchstabe 'G' wird also durch 'J' ersetzt, der Buchstabe 'Y' durch den den zyklisch im Alphabet verschobenen Buchstaben 'B'.

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
| | | | | | | | | | | | | | | | | | | | | | | | | |
D E F G H I J K L M N O P Q R S T U V W X Y Z A B C

Eine Buchstabenverschiebung lässt sich mit Hilfe vordefinierter Funktionen so realisieren:

Char.toCode 'Y' -> 89 
89 - 65 -> 24
24 + 3 -> 27
modBy 26 27 -> 1
65 + 1 -> 66
Char.fromCode 66 -> 'B'

Entwickle eine Implementierung dieser Buchstabenverschiebung. Benutze dabei den Pipe-Operator oder den Kompositionsoperator.

b) Einen Text verschlüsseln

Die Verschlüsselung ganzer Zeichenketten lässt sich mit Hilfe der String.map-Funktion realisieren. Man könnte aber auch ohne diese Funktion auskommen und die Verschlüsselung mit Hilfe von Listen und der List.map-Funktion realisieren. Dazu müsste man eine Zeichenkette in eine Liste umwandeln, um diese dann zu verarbeiten:

String.toList "HALLO" -> ['H','A','L','L','O']
List.map (... Buchstabenverschiebung ...) ['H','A','L','L','O'] -> ['K','D','O','O','R']
String.fromList ['K','D','O','O','R'] -> "KDOOR"

Implementiere diese Verschlüsselung von Zeichenketten. Benutze dabei den Pipe-Operator oder den Kompositionsoperator.

Aufgabe 5

Gar nicht so einfach: Versuche vorherzusagen, welche Rückgaben die in den folgenden REPL-Dialogen definierten Funktion liefern. Teste und erkläre die Ergebnisse.

> f1 = (\x -> x - 1) >> (+) 1
<function> : number -> number
> f1 4
...

> f2 = \liste -> liste |> List.filter (\x -> x > 0) |> List.map (\x -> 0 - x)
<function> : List number -> List number
> f2 [-3,0,2,4,-1]
...

> f3 = \f -> List.map f (List.range 1 10)
<function> : (Int -> a) -> List a
> f3 ((-) 0)
...

> f4 = \liste -> liste |> List.sort |> List.take 1
<function> : List comparable -> List comparable
> f4 [4,6,1,3]
...

> f5 = \x -> x |> (++) "(" |> (\y -> y ++ ")")
<function> : String -> String
> f5 "x"
...

> f6 = \i -> List.filter (\x -> x > i)
<function> : comparable -> List comparable -> List comparable
> f6 3 [1,2,3,4,5]
...