diff --git a/klausur/2013-02-20-Klausur-Loesung.pdf b/klausur/2013-02-20-Klausur-Loesung.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..5a9faadb485f6199d07ff5ff71d6eec0be247f14
Binary files /dev/null and b/klausur/2013-02-20-Klausur-Loesung.pdf differ
diff --git a/klausur/2013-02-20-Klausur.pdf b/klausur/2013-02-20-Klausur.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..056ae329b7c2b4033172efa2849738cfad1b0d5e
Binary files /dev/null and b/klausur/2013-02-20-Klausur.pdf differ
diff --git a/klausur/2013-03-20-Klausur-Loesung.pdf b/klausur/2013-03-20-Klausur-Loesung.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..43a0d1efde0188cbb921ce48f08fe2f9e64ae6d9
Binary files /dev/null and b/klausur/2013-03-20-Klausur-Loesung.pdf differ
diff --git a/klausur/2013-03-20-Klausur.pdf b/klausur/2013-03-20-Klausur.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..a13dd2868c06943b4f911bef9e07d82238d7ff0d
Binary files /dev/null and b/klausur/2013-03-20-Klausur.pdf differ
diff --git a/klausur/code/haskell/kl.hs b/klausur/code/haskell/kl.hs
new file mode 100644
index 0000000000000000000000000000000000000000..a18a29a685bb0a11f288cde63afbb424bafe0bf5
--- /dev/null
+++ b/klausur/code/haskell/kl.hs
@@ -0,0 +1,16 @@
+minim :: [Int] -> Int
+minim [x] = x
+minim (x : xs) = if x < m then x else m
+    where m = minim xs
+
+
+levenshtein :: String -> String -> Int
+levenshtein [] ys = length ys
+levenshtein xs [] = length xs
+levenshtein (x:xs) (y:ys)
+    | x == y = levenshtein xs ys
+    | otherwise = 1 + minim
+        [ levenshtein (x:xs) ys -- y einfuegen
+        , levenshtein xs (y:ys) -- x loeschen
+        , levenshtein xs ys-- x zu y aendern
+        ]
diff --git a/klausur/code/java/Baum.java b/klausur/code/java/Baum.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc71bff13b970b87fdb492beab41fc0cb0aefb9b
--- /dev/null
+++ b/klausur/code/java/Baum.java
@@ -0,0 +1,77 @@
+import java.util.List;
+import java.util.LinkedList;
+
+public class Baum {
+    private int wert;
+    private Baum links, rechts;
+
+    public Baum(Baum l, int wert, Baum r) {
+        this.links = l;
+        this.wert = wert;
+        this.rechts = r;
+    }
+
+    public int hoehe() {
+        int l = 0;
+        if (this.links != null)
+            l = this.links.hoehe();
+
+        int r = 0;
+        if (this.rechts != null)
+            r = this.rechts.hoehe();
+        if (l > r)
+            return l + 1;
+        else
+            return r + 1;
+    }
+
+    public void einfuegen(int x) {
+        Baum prev = null;
+        Baum cur = this;
+        while (cur != null) {
+            prev = cur;
+            if (x <= cur.wert)
+                cur = cur.links;
+            else
+                cur = cur.rechts;
+        }
+
+        Baum neu = new Baum(null, x, null);
+        if (x <= prev.wert)
+            prev.links = neu;
+        else
+            prev.rechts = neu;
+    }
+
+    public List<Integer> toList() {
+        List<Integer> res = new LinkedList<>();
+        this.toList(res);
+        return res;
+    }
+
+    private void toList(List<Integer> res) {
+        if (this.links != null)
+            this.links.toList(res);
+        res.add(this.wert);
+        if (this.rechts != null)
+            this.rechts.toList(res);
+    }
+
+    public <T> T apply(BaumFolder<T> f) {
+        T l;
+        if (this.links != null) {
+            l = this.links.apply(f);
+        } else {
+            l = f.handleNull();
+        }
+        T r;
+        if (this.rechts != null) {
+            r = this.rechts.apply(f);
+        } else {
+
+            r = f.handleNull();
+        }
+        return f.handleBaum(l, this.wert, r);
+    }
+
+}
\ No newline at end of file
diff --git a/klausur/code/java/BaumFolder.java b/klausur/code/java/BaumFolder.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab2d98e72481234aa2ce86ef6807b538e65e68a7
--- /dev/null
+++ b/klausur/code/java/BaumFolder.java
@@ -0,0 +1,5 @@
+public interface BaumFolder<T> {
+    T handleNull();
+
+    T handleBaum(T l, int w, T r);
+}
diff --git a/klausur/code/java/BaumInc.java b/klausur/code/java/BaumInc.java
new file mode 100644
index 0000000000000000000000000000000000000000..b3739150a80f2f353ee67db94a13ebd3a0149293
--- /dev/null
+++ b/klausur/code/java/BaumInc.java
@@ -0,0 +1,9 @@
+class BaumInc implements BaumFolder<Baum> {
+    public Baum handleNull() {
+        return null;
+    }
+
+    public Baum handleBaum(Baum links, int wert, Baum rechts) {
+        return new Baum(links, wert + 1, rechts);
+    }
+}
diff --git a/klausur/code/java/BaumSum.java b/klausur/code/java/BaumSum.java
new file mode 100644
index 0000000000000000000000000000000000000000..02d15a6e00f32baaae7cd6659e90e20051ab05d8
--- /dev/null
+++ b/klausur/code/java/BaumSum.java
@@ -0,0 +1,9 @@
+class BaumSum implements BaumFolder<Integer> {
+    public Integer handleNull() {
+        return 0;
+    }
+
+    public Integer handleBaum(Integer l, int w, Integer r) {
+        return l + w + r;
+    }
+}
diff --git a/klausur/code/java/BaumTest.java b/klausur/code/java/BaumTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4ea6d1bb78590dea634ceb154cde685445eaf08b
--- /dev/null
+++ b/klausur/code/java/BaumTest.java
@@ -0,0 +1,20 @@
+public class BaumTest {
+
+    public static void main(String[] args) {
+        Baum l = new Baum(null, 24, null);
+        Baum r = new Baum(null, 66, null);
+        Baum testTree = new Baum(l, 43, r);
+
+        // Height
+        System.out.println(testTree.hoehe());
+
+        // Insert
+        testTree.einfuegen(34);
+        testTree.einfuegen(100);
+        testTree.einfuegen(0);
+        System.out.println(testTree.hoehe());
+
+        // toList
+        System.out.println(testTree.toList());
+    }
+}
\ No newline at end of file
diff --git a/ub11/t02/a01.pl b/ub11/t02/a01.pl
index fb22fa24351badd83fd1d8800bd0d82df9c5683f..640171a49282cab67e3732d76714ffc79bd4e8ab 100644
--- a/ub11/t02/a01.pl
+++ b/ub11/t02/a01.pl
@@ -1,8 +1,14 @@
 % Part (a)
 % Test Aufruf: increment(node(leaf(s(0)),s(s(0)),leaf(0)),Res).
+increment(leaf(X), leaf(s(X))).
+increment(node(L, V, R), node( ResL, s(V), ResR )) :- increment(L, ResL), increment(R, ResR). 
 
 % Part (b)
 % Test Aufruf: append([a,b,c],[d,e],Res).
+append([], YS, YS).
+append([X|XS], YS, [X|Res]) :- append(XS, YS, Res).
 
 % Part (c)
-% Test Aufruf: inorder(node(leaf(s(0)),s(s(0)),node(leaf(s(0)),0,leaf(s(s(s(0)))))), Res).
\ No newline at end of file
+% Test Aufruf: inorder(node(leaf(s(0)),s(s(0)),node(leaf(s(0)),0,leaf(s(s(s(0)))))), Res).
+inorder(leaf(X), [X]).
+inorder(node(L, V, R), Res) :- inorder(L, ResL), inorder(R, ResR), append(ResL, [V|ResR], Res).
\ No newline at end of file
diff --git a/ub11/t02/a07.pl b/ub11/t02/a07.pl
index b821043421abcd84478501fed15638e307674713..cd05315f0ed0cbb2fa04fa163674e47f937c3b8d 100644
--- a/ub11/t02/a07.pl
+++ b/ub11/t02/a07.pl
@@ -1,5 +1,9 @@
 % prime(N) ist genau dann wahr, wenn N > 1 und N eine Primzahl ist.
+prime(N) :- N > 1, X is N div 2, nodivisors(N, X).
 
 % nodivisors(N, X) ist genau dann wahr, wenn  N keine Teiler zwischen X und 2 hat.
+nodivisors(_, 1).
+nodivisors(N, X) :- notdivisor(N, X), Y is X - 1, nodivisors(N, Y).
 
-% notdivisor (N , X ) ist wahr gdw . N nicht durch X teilbar ist .
\ No newline at end of file
+% notdivisor (N , X ) ist wahr gdw . N nicht durch X teilbar ist .
+notdivisor(N, X) :- Y is N mod X, Y > 0.
\ No newline at end of file