Mittwoch lesson

Code/Steiner/fractionsSteinerTask/.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "java.project.sourcePaths": ["src"],
+    "java.project.outputPath": "bin",
+    "java.project.referencedLibraries": [
+        "lib/**/*.jar"
+    ]
+}

Code/Steiner/fractionsSteinerTask/README.md

@@ -0,0 +1,18 @@
+## Getting Started
+
+Welcome to the VS Code Java world. Here is a guideline to help you get started to write Java code in Visual Studio Code.
+
+## Folder Structure
+
+The workspace contains two folders by default, where:
+
+- `src`: the folder to maintain sources
+- `lib`: the folder to maintain dependencies
+
+Meanwhile, the compiled output files will be generated in the `bin` folder by default.
+
+> If you want to customize the folder structure, open `.vscode/settings.json` and update the related settings there.
+
+## Dependency Management
+
+The `JAVA PROJECTS` view allows you to manage your dependencies. More details can be found [here](https://github.com/microsoft/vscode-java-dependency#manage-dependencies).

Code/Steiner/fractionsSteinerTask/src/Anteil.java

@@ -0,0 +1,34 @@
+public class Anteil extends Bruch {
+
+    private static Bruch verteilt = new Bruch(0, 1);
+
+    // Standardkonstruktor: Anteil = 0
+    public Anteil() {
+        super(0, 1);
+    }
+
+    // Konstruktor mit Zähler und Nenner
+    public Anteil(int z, int n) {
+        super(z, n);
+        Bruch neuerAnteil = new Bruch(z, n);
+        verteilt = verteilt.addiere(neuerAnteil);
+
+        if (verteilt.dezimalwert() > 1) {
+            System.out.println("Fehler: Der Gesamtwert der verteilten Anteile übersteigt 1.");
+            verteilt = verteilt.subtrahiere(neuerAnteil); // Rollback des Fehlers
+            setZaehler(0); // Setzt Anteil zurück
+            setNenner(1);
+        }
+    }
+
+    // Methode, um den verteilten Anteil als double zu erhalten
+    public static double getVerteilt() {
+        return verteilt.dezimalwert();
+    }
+
+    // Methode, um den verbleibenden Anteil als Bruch zu erhalten
+    public static Bruch getRest() {
+        Bruch eins = new Bruch(1, 1);
+        return eins.subtrahiere(verteilt);
+    }
+}

Code/Steiner/fractionsSteinerTask/src/AnteilTest.java

@@ -0,0 +1,57 @@
+public class AnteilTest {
+    public static void main(String[] args) {
+
+        // Bruch-Test
+
+        System.out.println("*** Aufgabe Bruch ergänzen");
+
+        Bruch bruch1 = new Bruch(1, 2);
+
+        Bruch bruch2 = new Bruch(3, 4);
+
+        Bruch bruch3 = bruch1.addiere(bruch2);
+
+        bruch3.gekuerztausgeben();
+
+        System.out.println("");
+
+        System.out.println(bruch3.dezimalwert());
+
+        Bruch bruch4 = bruch1.subtrahiere(bruch2);
+
+        bruch4.gekuerztausgeben();
+
+        System.out.println("");
+
+        System.out.println(bruch4.dezimalwert());
+
+        // Anteil-Test
+
+        System.out.println("");
+
+        System.out.println("*** Aufgabe Anteil");
+
+        int vermoegen = 200000;
+
+        Anteil anteil1 = new Anteil(1, 4);
+
+        Anteil anteil2 = new Anteil(1, 2);
+
+        System.out.println("Anteil anteil1: " + anteil1.bruchToString());
+
+        System.out.println("Betrag von anteil1: " + vermoegen * anteil1.dezimalwert());
+
+        System.out.println("Anteil anteil2: " + anteil2.bruchToString());
+
+        System.out.println("Betrag von anteil2: " + vermoegen * anteil2.dezimalwert());
+
+        System.out.println("");
+
+        // System.out.println("Verteilt: " + Anteil.verteilt.bruchToString());
+
+        System.out.println("Rest: " + anteil1.getRest().bruchToString());
+
+        System.out.println("Restbetrag: " + vermoegen * anteil1.getRest().dezimalwert());
+
+    }
+}

Code/Steiner/fractionsSteinerTask/src/Bruch.java

@@ -0,0 +1,101 @@
+public class Bruch {
+
+    private int zaehler;
+    private int nenner;
+
+    Bruch() {
+        zaehler = 0;
+        nenner = 1;
+    }
+
+    Bruch(int x) {
+        zaehler = x;
+        nenner = 1;
+    }
+
+    Bruch(int x, int y) {
+        zaehler = x;
+        nenner = y;
+    }
+
+    void setZaehler(int z) {
+        zaehler = z;
+    }
+
+    void setNenner(int n) {
+        nenner = n;
+    }
+
+    int getZaehler() {
+        return zaehler;
+    }
+
+    int getNenner() {
+        return nenner;
+    }
+
+    String bruchToString() {
+        return zaehler + "/" + nenner;
+    }
+
+    void ausgeben() {
+        System.out.println(zaehler + "/" + nenner);
+    }
+
+    void kuerzen() {
+        int m, n, r;
+        m = Math.abs(zaehler);
+        n = Math.abs(nenner);
+        r = m % n;
+        while (r > 0) {
+            m = n;
+            n = r;
+            r = m % n;
+        }
+        zaehler /= n;
+        nenner /= n;
+    }
+
+    void gekuerztausgeben() {
+        kuerzen();
+        ausgeben();
+    }
+
+    Bruch multipliziere(Bruch m) {
+        var z = zaehler * m.zaehler;
+        var n = nenner * m.nenner;
+        return new Bruch(z, n);
+    }
+
+    boolean equals(Bruch x) {
+        var a = new Bruch(this.zaehler, this.nenner);
+        var b = new Bruch(x.zaehler, x.nenner);
+        a.kuerzen();
+        b.kuerzen();
+        return (a.zaehler == b.zaehler) && (a.nenner == b.nenner);
+    }
+
+    // Neue Methode: Addition
+    Bruch addiere(Bruch b) {
+        int neuerZaehler = this.zaehler * b.nenner + b.zaehler * this.nenner;
+        int neuerNenner = this.nenner * b.nenner;
+        return new Bruch(neuerZaehler, neuerNenner);
+    }
+
+    // Neue Methode: Subtraktion
+    Bruch subtrahiere(Bruch b) {
+        int neuerZaehler = this.zaehler * b.nenner - b.zaehler * this.nenner;
+        int neuerNenner = this.nenner * b.nenner;
+        return new Bruch(neuerZaehler, neuerNenner);
+    }
+
+    // Neue Methode: Dezimalwert
+    double dezimalwert() {
+        if (nenner == 0) {
+            System.out.println("Error Divided by 0");
+            return 0;
+        } else {
+            return (double) zaehler / nenner;
+        }
+    }
+}

Code/Steiner/fractionsSteinerTask/src/BruchTest.java

@@ -0,0 +1,78 @@
+import java.util.ArrayList;
+
+public class BruchTest {
+    public static void main(String[] args) {
+        ArrayList<Bruch> brueche = new ArrayList<>();
+
+        // Test 1: Standardkonstruktor
+        brueche.add(new Bruch());
+        System.out.println("Test 1: " + brueche.get(0).bruchToString()); // Erwartet: 0/1
+
+        // Test 2: Konstruktor mit einem Parameter
+        brueche.add(new Bruch(3));
+        System.out.println("Test 2: " + brueche.get(1).bruchToString()); // Erwartet: 3/1
+
+        // Test 3: Konstruktor mit zwei Parametern (positive Werte)
+        brueche.add(new Bruch(4, 8));
+        System.out.println("Test 3: " + brueche.get(2).bruchToString()); // Erwartet: 4/8
+        brueche.get(2).gekuerztausgeben(); // Erwartet: 1/2
+
+        // Test 4: Konstruktor mit zwei Parametern (negative Werte)
+        brueche.add(new Bruch(-4, 8));
+        System.out.println("Test 4: " + brueche.get(3).bruchToString()); // Erwartet: -4/8
+        brueche.get(3).gekuerztausgeben(); // Erwartet: -1/2
+
+        // Test 5: Setzen von Zähler und Nenner (normal)
+        brueche.get(2).setZaehler(6);
+        brueche.get(2).setNenner(9);
+        System.out.println("Test 5: " + brueche.get(2).bruchToString()); // Erwartet: 6/9
+        brueche.get(2).gekuerztausgeben(); // Erwartet: 2/3
+
+        // Test 6: Setzen von Zähler und Nenner (mit Null)
+        brueche.get(2).setZaehler(0);
+        brueche.get(2).setNenner(9);
+        System.out.println("Test 6: " + brueche.get(2).bruchToString()); // Erwartet: 0/9
+
+        // Test 7: Setzen von Zähler und Nenner (Division durch Null)
+        brueche.get(2).setNenner(0);
+        System.out.println("Test 7: " + brueche.get(2).bruchToString());
+
+        // Test 8: Multiplikation
+        Bruch bruch4 = new Bruch(2, 3);
+        Bruch produkt = brueche.get(2).multipliziere(bruch4);
+        System.out.println("Test 8: " + produkt.bruchToString()); // Erwartet: 0/1
+
+        // Test 9: Gleichheit
+        Bruch bruch5 = new Bruch(2, 3);
+        Bruch bruch6 = new Bruch(4, 6);
+        System.out.println("Test 9: " + bruch5.equals(bruch6)); // Erwartet: true
+
+        // Test 10: Ungleichheit
+        Bruch bruch7 = new Bruch(1, 2);
+        System.out.println("Test 10: " + bruch5.equals(bruch7)); // Erwartet: false
+
+        // Test 11: Addition (positive und negative Werte)
+        Bruch bruch8 = new Bruch(1, 4);
+        Bruch summe = bruch5.addiere(bruch8);
+        System.out.println("Test 11: " + summe.bruchToString()); // Erwartet: 11/12
+
+        // Test 12: Subtraktion (negatives Ergebnis)
+        Bruch bruch9 = new Bruch(3, 4);
+        Bruch differenz = bruch5.subtrahiere(bruch9);
+        System.out.println("Test 12: " + differenz.bruchToString()); // Erwartet: -1/12
+
+        // Test 13: Dezimalwert
+        double dezimalwert = bruch5.dezimalwert();
+        System.out.println("Test 13: " + dezimalwert); // Erwartet: 0.6666666666666666 (2/3)
+
+        // Test 14: Dezimalwert eines anderen Bruchs
+        Bruch bruch10 = new Bruch(3, 4);
+        double dezimalwert2 = bruch10.dezimalwert();
+        System.out.println("Test 14: " + dezimalwert2); // Erwartet: 0.75
+
+        // Test 16: Dezimalwert eines anderen Bruchs (null)
+        Bruch bruch11 = new Bruch(3, 0);
+        double dezimalwert3 = bruch11.dezimalwert();
+        System.out.println("Test 15: " + dezimalwert3); // Erwartet: 0
+    }
+}