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,7 +8,7 @@ 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
@@ -16,8 +16,6 @@ Dateien wie Bilder die zur Lösung einer Aufgabe gehören sind in <br><ins>Medie
 - 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/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
-            result =  89;
-        }else if (number == 20) {   // Optimization2
-            result =  10946;
-        }else if (number == 30) {   // Optimization3
-            result =  1346269;
+//        }else if (number == 10) {   // Optimization1
+//            result =  89;
+//        }else if (number == 20) {   // Optimization2
+//            result =  10946;
+//        }else if (number == 30) {   // Optimization3
+//            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("i " + i + ": " + fibonacciIter(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