Optimization

.gitignore

@@ -29,3 +29,4 @@ bin/
 .DS_Store
 /Medien/Bilder & Co/Goldfrosch.pptx
 /Medien/Bilder & Co/Goldfrosch.xlsx
+/src/HZ/

.idea/misc.xml

@@ -1,5 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="21" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_X" default="true" project-jdk-name="openjdk-22" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

README.md

@@ -8,16 +8,14 @@ Dateien wie Bilder die zur Lösung einer Aufgabe gehören sind in <br><ins>Medie
 ## Bisher vollständig vorhanden:
 - Vorlesung 3 komplett
 - Vorlesung 4 komplett
-- Vorlesung 5 Aufgabe 1 & 3 von 3
+- Vorlesung 5 komplett
 - Vorlesung 6 komplett
 - Vorlesung 7 komplett
 - Vorlesung 8 komplett
 - Vorlesung 9 Aufgabe 2
-- Vorlesung 10 Aufgabe 1
+- Vorlesung 10 komplett
 
 ## Angefangene unfertige Lösungen:
-- Damenproblem: VL 5 Aufgabe 2
-<br>Nicht die gewünschte rekursive Backtracking-Implementierung
 - JavaDoc: VL 9 Aufgabe 1
 <br>Das Tool mag mich nicht
 

src/part10/aufg1/Anwendung.java

@@ -6,7 +6,7 @@ public class Anwendung {
 
     public static void main(String[] args){
         matrix nr1 = new matrix(2,3);
-        matrix nr2 = new matrix(3,3);
+        matrix nr2 = new matrix(2,3);
 
         nr1.setValue(1,1,1);
         nr2.setValue(0,0,4);
@@ -25,13 +25,13 @@ public class Anwendung {
         nr3.setRow(new int[]{4,5,6},1);
 
 
-        //matrix nr4 = new matrix(3,2); // works fine
+        matrix nr4 = new matrix(3,2); // works fine
-        matrix nr4 = new matrix(3,3); // causes Runtime Exception
+        //matrix nr4 = new matrix(3,3); // causes Runtime Exception
 
         nr4.setCol(new int[]{7,9,11},0);
         nr4.setCol(new int[]{8,10,12},1);
 
-
+        nr4.multiplyMatrix(nr3);
-        System.out.println(nr3.multiplyMatrix(nr4));
+        nr3.multiplyMatrix(nr4);
     }
 }

src/part10/aufg1/Exceptions/matrix.java

@@ -124,8 +124,7 @@ public class matrix {
             }
         }
         else {
-            // Vectors not compatible Exception
+            throw new RuntimeException("Vectors are not the sime size");
-            // TODO
         }
         return result;
     }

src/part10/aufg2/NegativeValueException.java

@@ -0,0 +1,7 @@
+package part10.aufg2;
+
+public class NegativeValueException extends RuntimeException{
+    NegativeValueException(String s) {
+        super(s);
+    }
+}

src/part10/aufg2/PositiveVector.java

@@ -0,0 +1,94 @@
+package part10.aufg2;
+
+import java.util.Arrays;
+
+public class PositiveVector {
+    double[] values;
+
+    PositiveVector(int size){
+        this.values = new double[size];
+        Arrays.fill(values, 0);
+    }
+
+    public int length(){
+        return this.values.length;
+    }
+    public void setValues(double[] values) {
+        for (int i=0; i<values.length; i++){
+            assert (values[i] >= 0) : "Value cannot be negative";
+        }
+        this.values = values;
+    }
+
+    public double[] getValues() {
+        return values;
+    }
+
+    public void setSingleValue(double value, int index){
+        if (value < 0){
+            System.out.println(value + " is negativ and cannot be assigned!");
+            return;
+        }
+        this.values[index] = value;
+    }
+
+    public double getSingleValue(int index){
+        return this.values[index];
+    }
+
+    public void print(){
+        System.out.println(Arrays.toString(this.values));
+    }
+
+    public PositiveVector vectorAddition(PositiveVector vector2){
+        PositiveVector result = new PositiveVector(this.length());
+
+        if (this.values.length == vector2.getValues().length){
+            for (int i=0; i<this.values.length; i++){
+                result.setSingleValue((this.getSingleValue(i) + vector2.getSingleValue(i)), i);
+            }
+        }
+
+    return result;
+    }
+
+    public PositiveVector vectorSubtraction(PositiveVector vector2) throws NegativeValueException {
+        PositiveVector result = new PositiveVector(this.length());
+
+        if (this.values.length == vector2.getValues().length){
+            for (int i=0; i<this.values.length; i++){
+                if ((this.getSingleValue(i) - vector2.getSingleValue(i)) < 0){
+                    throw new NegativeValueException(this.getSingleValue(i) + " - " + vector2.getSingleValue(i) + " ist negativ");
+                }
+                result.setSingleValue((this.getSingleValue(i) - vector2.getSingleValue(i)), i);
+            }
+        }
+
+        return result;
+    }
+
+    public double dotProduct(PositiveVector vector2) {
+        double result = 0;
+
+        if (this.length() == vector2.length()) {
+            for (int i = 0; i < this.length(); i++) {
+                result += this.getSingleValue(i) * vector2.getSingleValue(i);
+            }
+        }
+        return result;
+    }
+
+
+    public static void main(String[] args){
+        PositiveVector vector1 = new PositiveVector(3);
+        PositiveVector vector2 = new PositiveVector(3);
+
+        vector1.setValues(new double[] {1,0,5});
+        vector2.setValues(new double[] {0,0,1});
+
+        PositiveVector vector3 = vector1.vectorSubtraction(vector2);
+        vector3.print();
+
+        System.out.println(vector1.dotProduct(vector2));
+    }
+}

src/part4/aufg3.java

@@ -9,7 +9,7 @@ public class aufg3 {
     // =====================
 
     public static void main(String[] args){
-        int MAXIMUM = 10_000_000;  // takes about 13 seconds(!!)
+        int MAXIMUM = 100_000_000;  // takes about 4 seconds(!!)
         int MAX_PER_ROW = 20;
 
         boolean[] primes = new boolean[MAXIMUM];
@@ -17,7 +17,7 @@ public class aufg3 {
         Arrays.fill(primes, true);
 
         for(int i=2; i < MAXIMUM * 0.5; i++){
-            for(int j=2; j < ((MAXIMUM*1.0)/i); j++){
+            for(int j=i; j < ((MAXIMUM*1.0)/i); j++){
 
                 int index = i * j;
 

src/part5/aufg1.java

@@ -21,12 +21,12 @@ public class aufg1 {
             result = 0;
         } else if (number < 2) {
             result =  1;
-        }else if (number == 10) {   // Optimization1
+//        }else if (number == 10) {   // Optimization1
-            result =  89;
+//            result =  89;
-        }else if (number == 20) {   // Optimization2
+//        }else if (number == 20) {   // Optimization2
-            result =  10946;
+//            result =  10946;
-        }else if (number == 30) {   // Optimization3
+//        }else if (number == 30) {   // Optimization3
-            result =  1346269;
+//            result =  1346269;
         }else {
             result =  fibonacciRec(number-1) + fibonacciRec(number-2);
         }
@@ -34,11 +34,27 @@ public class aufg1 {
         return result;
     }
 
+    public static int fiboTailRec(int number){
+        return helper(++number, new int[] {0,1});
+    }
+
+    private static int helper(int number, int[] result){
+        if (number < 0){
+            return 0;
+        }
+        if (number < 2){
+            return result[number];
+        }
+
+        return helper(number-1, new int[] {result[1], result[0] + result[1]});
+    }
+
     public static void main(String[] agrs){
         // Fib(47) causes an Integer Overflow
         for (int i=0; i<46; i++) {
-            System.out.println(fibonacciIter(i));
+            System.out.println("i " + i + ": " + fibonacciIter(i));
-            System.out.println(fibonacciRec(i));
+            System.out.println("i " + i + ": " + fibonacciRec(i));
+            System.out.println("i " + i + ": " + fiboTailRec(i));
             System.out.println("==========");
         }
     }

src/part5/aufg2/Demo.java

@@ -0,0 +1,13 @@
+package part5.aufg2;
+
+public class Demo {
+    public static void main(String[] args) {
+        Queenproblem Q = new Queenproblem();
+        Q.solve();
+        System.out.println("====================================\n");
+        Q.setField(new int[]{0,0,0,0,0,0,0,0});
+        Q.solve();
+    }
+}
+
+

src/part5/aufg2/Queenproblem.java

@@ -0,0 +1,146 @@
+package part5.aufg2;
+
+import java.util.Arrays;
+
+public class Queenproblem {
+    // 0 means empty
+    // 1-8 is the y position of the Queen
+    int[] field;
+
+    public Queenproblem(){
+        this.field = new int[8];
+        makeBoardEmpty();
+    }
+
+    public void setField(int[] field) {
+        this.field = field;
+    }
+
+    public void makeBoardEmpty(){
+        this.setField(new int[] {0,0,0,0,0,0,0,0});
+    }
+
+    private int[][] make2D(){
+        int[][] field = new int[8][8];
+
+        for (int[] row : field ){
+            Arrays.fill(row, 0);
+        }
+
+        for (int i=0; i<8; i++) {
+            try {
+                int yPosition = this.field[i];
+                field[yPosition-1][i] = 1;   // -1 to handle 0 as empty and 8 as lowest possible with actual index 7
+            }catch (IndexOutOfBoundsException e){/* System.out.println("Ignored Index Error while making it 2D") */}
+        }
+
+        return field;
+    }
+    public void print(){
+        int[][] field = make2D();
+
+        for (int[] row:field) {
+            System.out.println(Arrays.toString(row));
+        }
+        System.out.println();
+    }
+
+    public boolean checkVertical(int col){
+        return this.field[col - 1] == 0;
+    }
+
+    public boolean checkHorizontal(int row){
+        for (int colFilled : this.field) {
+            if (colFilled == row){
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private void ensureLegalCords(int row, int col){
+        if (col<1 || col>8){
+            throw new RuntimeException("Invalid Col " + col);
+        }
+        if (row<1 || row>8){
+            throw new RuntimeException("Invalid Row " + row);
+        }
+    }
+    public boolean checkFallingDiagonal(int row, int col){
+        ensureLegalCords(row, col);
+
+        for (int i = 0; i < 8; i++) {
+            try {
+                if (this.field[col-1+i] != 0) {
+                    if (this.field[col - 1 + i] == row + i) {
+                        return false;
+                    }
+                }
+            }catch (IndexOutOfBoundsException e){/* Skip Iteration with IndexError */}
+
+            // cannot be in the same try block.
+            // Exceptions in the + direction stop execution of - prematurely
+            try {
+                if (this.field[col-1-i] != 0) {
+                    if (this.field[col - 1 - i] == row - i) {
+                        return false;
+                    }
+                }
+            }catch (IndexOutOfBoundsException e){/* Skip Iteration with IndexError*/ }
+        }
+        return true;
+    }
+
+    public boolean checkRisingDiagonal(int row, int col){
+        ensureLegalCords(row, col);
+
+        for (int i = 0; i < 8; i++) {
+            try {
+                if (this.field[col-1+i] != 0) {
+                    if (this.field[col-1+i] == row-i) {
+                        return false;
+                    }
+                }
+            }catch (IndexOutOfBoundsException e){}
+            try {
+                if (this.field[col-1-i] != 0) {
+                    if (this.field[col-1-i] == row+i) {
+                        return false;
+                    }
+                }
+            }catch (IndexOutOfBoundsException e){}
+        }
+        return true;
+    }
+    public boolean isPossible(int row, int col){
+        if(!checkHorizontal(row)){
+            return false;
+        }
+        if (!checkVertical(col)) {
+            return false;
+        }
+        if (!checkFallingDiagonal(row, col)){
+            return false;
+        }
+        if (!checkRisingDiagonal(row, col)){
+            return false;
+        }
+        return true;
+    }
+
+    public void solve(){
+        for (int col = 1; col < 9; col++) {
+            if (this.field[col-1] == 0) {
+                for (int row = 1; row < 9; row++) {
+                    if (isPossible(row,col)) {
+                        this.field[col-1] = row;
+                        this.solve();
+                        this.field[col-1] = 0;
+                    }
+                }
+                return;
+            }
+        }
+        this.print();
+    }
+}

src/part5/aufg2/aufg2.java

@@ -1,4 +1,4 @@
-package part5;
+package part5.aufg2;
 
 // I know this is not recursive
 // Shut up

src/part5/aufg3.java

@@ -10,7 +10,7 @@ public class aufg3 {
     public static void recursive2(int depth){
         int[] array = new int[100];
         System.out.println(depth);
-        recursive(depth+1);
+        recursive2(depth+1);
     }
 
     public static void recursive3(int depth){