Dokument exercises

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;
+    }
   }
 }

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) {

Main.java

@@ -19,5 +19,9 @@ public class Main {
         // exercise 3
         System.out.println("Aufgabe 3");
         handleArray.printArrayRev(array);
+
+        // exercise 4
+        System.out.println("Aufgabe 4");
+        System.out.println(handleArray.sumRec(array));      
     }
 }

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))