diff --git a/HandleArray.java b/HandleArray.java
index e98fbe5..897fea0 100644
--- a/HandleArray.java
+++ b/HandleArray.java
@@ -1,6 +1,7 @@
 import java.util.Arrays;
 
 public class HandleArray {
+  // BITTE Main.java UND README.md MIT BEACHTEN !!!!!
   public void printArray(int[] arrayInput) {
     System.out.print(arrayInput[0] + " ");
     if (arrayInput.length > 1) {
@@ -19,7 +20,12 @@ public class HandleArray {
     }
   }
 
-  public void sumRec() {
-    
+  public int sumRec(int[] arrayInput) {
+    // WIRD AUSGEGEBEN IN DER Main.java
+    if(arrayInput.length > 0) {
+      return arrayInput[0] + sumRec(Arrays.copyOfRange(arrayInput, 1, arrayInput.length));
+    } else {
+      return 0;
+    }
   }
 }
diff --git a/IntToBinary.java b/IntToBinary.java
index 1d251be..56c6509 100644
--- a/IntToBinary.java
+++ b/IntToBinary.java
@@ -1,5 +1,7 @@
 public class IntToBinary {
   // !!!!! DER REST DER AUFGABE IST IN DER README.md BEANTWORTED !!!!!
+  // BITTE Main.java MIT BEACHTEN
+  // BITTE Main.java MIT BEACHTEN !!!!!!!!!!
   
   public int binary(int n) {
     if (n < 0) {
diff --git a/Main.java b/Main.java
index e868107..4c6e148 100644
--- a/Main.java
+++ b/Main.java
@@ -18,6 +18,10 @@ public class Main {
 
         // exercise 3
         System.out.println("Aufgabe 3");
-        handleArray.printArrayRev(array);      
+        handleArray.printArrayRev(array);
+
+        // exercise 4
+        System.out.println("Aufgabe 4");
+        System.out.println(handleArray.sumRec(array));      
     }
 }
diff --git a/README.md b/README.md
index 5e88f50..9e3429a 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,7 @@
 
 # Aufgabe 1
 ## Dokumentieren Sie die Ausführung des Aufrufs binary(6), indem Sie die Auswertung aller binary-Aufrufe als eigerückte Nebenrechnungen notieren. 
+```
 binary(6)
    // else
    binary(6 / 2) + (6 % 2) // wird zu binary(3) + 0
@@ -16,10 +17,76 @@ binary(6)
         return 11
 
 -> binary(6) = toInt("11" + "0")
+
    return 110
+```
 
 ## Wie viele binary-Aufrufe werden bei der Auswertung von binary(n) in Abhängigkeit von n ausgeführt?
 Bei jedem Aufruf -> n/2 bis n <= 1
+
 tiefe = anzahl der teilungen / 2
 ---> O(n) = log2(n) + 1
+
 + 1 durch den letzten aufruf (Rekursions Anker)
+
+
+# Aufgabe 2
+```
+printArray([15, 3, 22, 43]) 
+  //gibt 15 aus 
+  printArray([3, 22, 43]) 
+         // in print Array 
+         // gibt 3 aus 
+         printArray([22, 43]) 
+                 // gibt 22 aus 
+                 printArray([43]) 
+                         // gibt 43 aus 
+                         // Abbruch (length == 1) 
+```
+
+Rekursions Anker -> array.length > 1 
+
+Rekursiver Aufruf -> printArray(Arrays.copyOfRange(arrayInput, 1, arrayInput.length)) 
+
+
+# Aufgabe 4 
+```
+printArrayRev([15, 3, 22, 43]) 
+  //gibt 43 aus 
+  printArrayRev([15, 3, 22]) 
+      //gibt 22 aus 
+      printArrayRev([15, 3]) 
+          //gibt 3 aus 
+          printArrayRev([15]) 
+              //gibt 15 aus 
+              ---> Abbruch (length == 1) 
+```
+ 
+
+Rekursions Anker: 
+
+arrayInput.length == 1 
+
+Rekursiver Aufruf: 
+
+printArrayRev(Arrays.copyOfRange(arrayInput, 0, arrayInput.length - 1)) 
+
+ 
+# Aufgabe 4 
+
+```
+sumRec([15, 3, 22, 43]) 
+  = 15 + sumRec([3, 22, 43]) 
+        = 15 + (3 + sumRec([22, 43])) 
+               = 15 + (3 + (22 + sumRec([43]))) 
+                      = 15 + (3 + (22 + (43 + sumRec([])))) // ABBRUCH return 0 
+                             = 15 + (3 + (22 + (43 + 0))) 
+```
+ 
+Rekursions Anker: 
+
+arrayInput.length == 0 
+
+Rekursiver Aufruf: 
+
+sumRec(Arrays.copyOfRange(arrayInput, 1, arrayInput.length))