Add GPT work

src/part1/GPT_Code/Goldfrosch.java

@@ -0,0 +1,112 @@
+package part1.GPT_Code;
+
+public class Goldfrosch {
+
+    public static void frogsV1(int frogs) {
+        int numFrogsInLeftEimer = 0;
+        int numFrogsInRightEimer = 0;
+        int currentPosition = 1;
+        int direction = 1; // 1: nach rechts, -1: nach links
+
+        for (int i = 1; i <= frogs; i++) { // Wir lassen die Frösche für 1000 Schritte hüpfen
+            if (currentPosition == 0 || currentPosition == -1) { // Der Frosch ist im Eimer gelandet
+                if (currentPosition == 0) {
+                    numFrogsInLeftEimer++;
+                } else {
+                    numFrogsInRightEimer++;
+                }
+                currentPosition = 1; // Ein neuer Frosch startet auf Platz 1
+                direction = 1; // Pfeil zeigt zu Beginn immer nach rechts
+            }
+            if (direction == 1) {
+                currentPosition += 1;
+                direction = -1; // Pfeil ändern
+            } else {
+                currentPosition -= 2;
+                direction = 1; // Pfeil ändern
+            }
+        }
+
+        System.out.println("Anzahl der Frösche im linken Eimer: " + numFrogsInLeftEimer);
+        System.out.println("Anzahl der Frösche im rechten Eimer: " + numFrogsInRightEimer);
+    }
+
+    public static void frogsV2(int frogs) {
+        int numFrogsInLeftEimer = 0;
+        int numFrogsInRightEimer = 0;
+        int currentPosition = 1;
+
+        for (int i = 1; i <= frogs; i++) { // Wir lassen die Frösche für 1000 Schritte hüpfen
+            if (currentPosition == 0 || currentPosition == -1) { // Der Frosch ist im Eimer gelandet
+                if (currentPosition == 0) {
+                    numFrogsInLeftEimer++;
+                } else {
+                    numFrogsInRightEimer++;
+                }
+                currentPosition = 1; // Ein neuer Frosch startet auf Platz 1
+            } else if (currentPosition == 1) {
+                currentPosition = -2; // Pfeil zeigt nach links, hüpft nach i-2
+            } else {
+                currentPosition = currentPosition + 1; // Pfeil zeigt nach rechts, hüpft nach i+1
+            }
+
+        }
+
+        System.out.println("Anzahl der Frösche im linken Eimer: " + numFrogsInLeftEimer);
+        System.out.println("Anzahl der Frösche im rechten Eimer: " + numFrogsInRightEimer);
+    }
+
+    public static void frogsV3(int frog) {
+        int numFrogsInLeftEimer = 0;
+        int numFrogsInRightEimer = 0;
+        int currentPosition = 1;
+
+        for (int i = 1; i <= frog; i++) { // Wir lassen die Frösche für 1000 Schritte hüpfen
+            if (currentPosition == 0 || currentPosition == -1) { // Frosch landet im Eimer
+                if (currentPosition == 0) {
+                    numFrogsInLeftEimer++;
+                } else {
+                    numFrogsInRightEimer++;
+                }
+                currentPosition = 1; // Ein neuer Frosch startet auf Platz 1
+            }
+            currentPosition = getPositionAfterHop(currentPosition);
+        }
+
+        System.out.println("Anzahl der Frösche im linken Eimer: " + numFrogsInLeftEimer);
+        System.out.println("Anzahl der Frösche im rechten Eimer: " + numFrogsInRightEimer);
+    }
+
+    public static int getPositionAfterHop(int currentPos) {
+        if(currentPos == 1) {
+            return -2;
+        } else {
+            return currentPos+1;
+        }
+    }
+
+    public static void main(String[] args) {
+        System.out.println("V1");
+        frogsV1(1000);
+        System.out.println("==========");
+        System.out.println("V2");
+        frogsV2(1000);
+        System.out.println("==========");
+        System.out.println("V3");
+        frogsV3(1000);
+    }
+}
+
+/*
+    Dieses Programm simuliert den Froschprozess für 1000 Schritte und zählt
+    dann die Anzahl der Frösche in den beiden Eimern.
+
+    b) Das Verhältnis der Froschanzahlen in beiden Eimern auf lange Sicht ist 1:1.
+    Dies liegt daran, dass der Frosch immer um eins nach rechts oder um zwei nach links hüpft.
+    Da der Froschprozess solange wiederholt wird, bis ein neuer Frosch auf den Platz 1 gesetzt wird,
+    wird sich die Anzahl der Frösche in beiden Eimern angleichen.
+
+    c) Nein, es kann nicht vorkommen, dass ein Frosch nach rechts ins Unendliche weghüpft.
+    Da die Schritte des Frosches begrenzt sind (entweder +1 oder -2),
+    wird der Froschprozess in einem begrenzten Bereich bleiben.
+*/

src/part1/GPT_Code/Matrix.java

@@ -0,0 +1,81 @@
+package part1.GPT_Code;
+
+/*
+    Hier ist eine mögliche Implementierung in Java:
+ */
+
+public class Matrix {
+    private int[][] matrix;
+    private int rows;
+    private int columns;
+
+    public Matrix(int rows, int columns) {
+        this.rows = rows;
+        this.columns = columns;
+        this.matrix = new int[rows][columns];
+    }
+
+    public void setElement(int row, int column, int value) {
+        this.matrix[row][column] = value;
+    }
+
+    public int getElement(int row, int column) {
+        return this.matrix[row][column];
+    }
+
+    public void scalarMultiplication(int scalar) {
+        for (int i = 0; i < this.rows; i++) {
+            for (int j = 0; j < this.columns; j++) {
+                this.matrix[i][j] *= scalar;
+            }
+        }
+    }
+
+    public Matrix add(Matrix otherMatrix) {
+        if (this.rows != otherMatrix.rows || this.columns != otherMatrix.columns) {
+            throw new IllegalArgumentException("Matrices must have the same dimensions");
+        }
+        Matrix result = new Matrix(this.rows, this.columns);
+        for (int i = 0; i < this.rows; i++) {
+            for (int j = 0; j < this.columns; j++) {
+                result.setElement(i, j, this.matrix[i][j] + otherMatrix.getElement(i, j));
+            }
+        }
+        return result;
+    }
+
+    public void printMatrix() {
+        for (int i = 0; i < this.rows; i++) {
+            for (int j = 0; j < this.columns; j++) {
+                System.out.print(this.matrix[i][j] + " ");
+            }
+            System.out.println();
+        }
+    }
+
+    public static void main(String[] args) {
+        Matrix m1 = new Matrix(2, 2);
+        m1.setElement(0, 0, 1);
+        m1.setElement(0, 1, 2);
+        m1.setElement(1, 0, 3);
+        m1.setElement(1, 1, 4);
+        System.out.println("Matrix m1:");
+        m1.printMatrix();
+
+        m1.scalarMultiplication(2);
+        System.out.println("Matrix m1 after scalar multiplication:");
+        m1.printMatrix();
+
+        Matrix m2 = new Matrix(2, 2);
+        m2.setElement(0, 0, 5);
+        m2.setElement(0, 1, 6);
+        m2.setElement(1, 0, 7);
+        m2.setElement(1, 1, 8);
+        System.out.println("Matrix m2:");
+        m2.printMatrix();
+
+        Matrix m3 = m1.add(m2);
+        System.out.println("Matrix m3 = m1 + m2:");
+        m3.printMatrix();
+    }
+}

src/part1/GPT_Code/PrimeFactorization.java

@@ -0,0 +1,39 @@
+package part1.GPT_Code;
+
+/*
+Hier ist eine mögliche Implementierung in Java:
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PrimeFactorization {
+    public static List<Integer> primeFactorization(int n) {
+        List<Integer> factors = new ArrayList<>();
+
+        for (int i = 2; i <= n; i++) {
+            while (n % i == 0) {
+                factors.add(i);
+                n /= i;
+            }
+        }
+
+        if (n > 2) {
+            factors.add(n);
+        }
+
+        return factors;
+    }
+
+    public static void main(String[] args) {
+        int number = 120;
+
+        List<Integer> primeFactors = primeFactorization(number);
+
+        System.out.println("Prime factors of " + number + ": " + primeFactors);
+    }
+}
+
+/*
+    Die Methode primeFactorization verwendet eine Schleife, um die Primfaktoren der gegebenen Zahl zu finden und sie in der Liste factors zu speichern. Schließlich gibt die main-Methode die Liste der Primfaktoren aus.
+*/

src/part1/GPT_Code/Rounding.java

@@ -0,0 +1,64 @@
+package part1.GPT_Code;
+/*
+Ja, natürlich. Hier ist eine überarbeitete Implementierung ohne die Verwendung von anderen Paketen:
+*/
+
+public class Rounding {
+    public static String roundToNDecimalPlacesV1(String number, int decimalPlaces) {
+        int index = number.indexOf('.');
+        if (decimalPlaces == 0) {
+            return number.substring(0, index); // return the whole number before the decimal point
+        } else {
+            if (index == -1) { // if the number is an integer
+                return number;
+            } else {
+                String roundedNumber = number.substring(0, index + decimalPlaces + 1); // get the number including the specified decimal places
+                return roundedNumber;
+            }
+        }
+    }
+
+
+    public static String roundToNDecimalPlacesV2(String number, int decimalPlaces) {
+        int index = number.indexOf('.');
+        if (decimalPlaces == 0) {
+            if (index != -1) {
+                return number.substring(0, index); // return the whole number before the decimal point
+            } else {
+                return number; // return the original number if it's an integer
+            }
+        } else {
+            StringBuilder sb = new StringBuilder();
+            if (index == -1) { // if the number is an integer
+                sb.append(number);
+                sb.append('.');
+                for (int i = 0; i < decimalPlaces; i++) {
+                    sb.append('0'); // append decimal places as zeros
+                }
+            } else {
+                sb.append(number.substring(0, index + decimalPlaces + 1)); // get the number including the specified decimal places
+            }
+            return sb.toString();
+        }
+    }
+
+
+
+    public static void main(String[] args) {
+        String input = "3.19";
+        int decimalPlaces = 1;
+
+        String result = roundToNDecimalPlacesV1(input, decimalPlaces);
+        System.out.println("Rounded number: " + result);
+
+        System.out.println("=====");
+
+        result = roundToNDecimalPlacesV2(input, decimalPlaces);
+        System.out.println("Rounded number: " + result);
+
+    }
+}
+
+/*
+    In dieser Implementierung wird die Methode roundToNDecimalPlaces verwendet, um die Eingabe auf die gewünschte Anzahl von Nachkommastellen zu runden. Der gerundete Wert wird als String zurückgegeben und kann dann weiterverwendet oder ausgegeben werden.
+*/

src/part1/GPT_Code/SiebDesErathostenes.java

@@ -0,0 +1,36 @@
+package part1.GPT_Code;
+public class SiebDesErathostenes {
+
+    public static void main(String[] args) {
+        final int MAXIMUM = 100; // Beispielwert, kann angepasst werden
+        boolean[] isPrime = new boolean[MAXIMUM + 1];
+
+        for (int i = 2; i <= MAXIMUM; i++) {
+            isPrime[i] = true;
+        }
+
+        for (int i = 2; i * i <= MAXIMUM; i++) {
+            if (isPrime[i]) {
+                for (int j = i * i; j <= MAXIMUM; j += i) {
+                    isPrime[j] = false;
+                }
+            }
+        }
+
+        System.out.println("Primzahlen zwischen 1 und " + MAXIMUM + ":");
+        for (int i = 2; i <= MAXIMUM; i++) {
+            if (isPrime[i]) {
+                System.out.print(i + " ");
+            }
+        }
+    }
+}
+
+    /*
+     * Dieses Programm implementiert das Sieb des Eratosthenes, um alle Primzahlen zwischen
+     * 1 und einer festgelegten oberen Schranke (in diesem Fall die Integer-Konstante MAXIMUM) auszugeben.
+     * Das Array isPrime wird verwendet, um zu speichern, ob eine Zahl als prim markiert ist oder nicht.
+     * Zuerst werden alle Zahlen von 2 bis MAXIMUM als prim markiert. Dann wird das Sieb des
+     * Eratosthenes angewendet, um alle Vielfachen der primes zu markieren. Schließlich werden
+     * alle prim markierten Zahlen ausgegeben.
+     */