VL03 und VL04

.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*.java]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true

.gitignore

@@ -0,0 +1,2 @@
+# compiled class files.
+*.class

S01-VL03-Aufgabe 1/Aufgabe.java

@@ -0,0 +1,5 @@
+class Aufgabe {
+  public static void main(String[] args) {
+    System.out.println("Hallo Welt");
+  }
+}

S01-VL03-Aufgabe 2/Aufgabe.java

@@ -0,0 +1,16 @@
+class Aufgabe {
+  public static void main(String[] args) {
+    int a1 = 2;
+    int a2 = 4;
+    int a3 = 6;
+
+    System.out.println("a.) Arithmetisches Mittel: " + ((a1 + a2 + a3) / 3));
+    System.out.println("b.) Ist " + a1 + " < " + a2 + " < " + a3 + "? " + (a1 < a2 && a2 < a3 ? "Ja" : "Nein"));
+    System.out.println("c.) Ist " + a1 + " ein ganzzahliges Vielfaches von " + a2 + "? " + (a1 % a2 == 0 ? "Ja" : "Nein"));
+    System.out.println("d.) " + a3 + " invertiert: " + (~a3));
+
+    a3 = Integer.MAX_VALUE;
+    System.out.println("e.) Größter positiver Integer-Wert: " + (a3));
+    System.out.println("f.) Größter postiver Integer-Wert + 1: " + (a3 + 1));
+  }
+}

S01-VL03-Aufgabe 3/Aufgabe.java

@@ -0,0 +1,23 @@
+class Aufgabe {
+  public static void main(String[] args) {
+
+    // Die drei Zahlen für die Prüfung definieren.
+    int a = 3;
+    int b = 4;
+    int c = 5;
+
+    // Die Zahlen überprüfen und das Ergebnis ausgeben.
+    System.out.println("Werte entsprechen dem Satz des Pythagoras: " + (check(a,b,c) ? "Ja" : "Nein"));
+  }
+
+  /**
+   * Prüfen ob die angegebenen Zahlen dem Satz des Pythagoras entsprechen.
+   * @param a Die erste Zahl (a).
+   * @param b Die zweite Zahl (b).
+   * @param c Das Ergebnis (c).
+   * @return Status ob die angegebenen Zahlen dem Satz des Pythagoras entsprechen.
+   */
+  public static boolean check(int a, int b, int c) {
+    return (a*a + b*b == c*c) ? true : false;
+  }
+}

S01-VL03-Aufgabe 4/Aufgabe.java

@@ -0,0 +1,25 @@
+class Aufgabe {
+    public static void main(String[] args) {
+        int i = 5;
+        int j = 3;
+        boolean b = false;
+
+        /*
+         * a.) (!((i<j) && b)) - boolean (true)
+         * b.) i/j - int (1)
+         * c.) (float) (i/j) - float (1.0)
+         * d.) (float) i/j - float (1.6)
+         * e.) (float) i / (float) j - float (1.6)
+         * f.) ((i++ == 5) || (--i == 5)) - boolean (true)
+         * g.) ((i++ == 5) | (--i == 5)) - int (1)
+         */
+
+        System.out.println("a.) " + (!((i<j) && b)));
+        System.out.println("b.) " + (i/j));
+        System.out.println("c.) " + (float) (i/j));
+        System.out.println("d.) " + ((float) i/j));
+        System.out.println("e.) " + ((float) i / (float) j));
+        System.out.println("f.) " + (((i++ == 5) || (--i == 5))));
+        System.out.println("g.) " + (((i++ == 5) | (--i == 5))));
+    }
+}

S01-VL04-Aufgabe 1/Aufgabe.java

@@ -0,0 +1,21 @@
+class Aufgabe {
+  public static void main(String[] args) {
+    final int MAXIMUM = 10;
+
+    System.out.println("Alle geraden Zahlen zwischen 1 und " + MAXIMUM + " (aufsteigend):");
+
+    for(int i = 1; i <= MAXIMUM; i++) {
+      if(i % 2 == 0) {
+        System.out.println(i);
+      }
+    }
+
+    System.out.println("Alle ungeraden Zahlen zwischen 1 und " + MAXIMUM + " (absteigend):");
+
+    for(int i = MAXIMUM; i >= 1; i--) {
+      if(i % 2 == 1) {
+        System.out.println(i);
+      }
+    }
+  }
+}

S01-VL04-Aufgabe 2/Aufgabe.java

@@ -0,0 +1,38 @@
+class Aufgabe {
+  public static void main(String[] args) {
+    final int START = 1;
+    final int ENDE = 20;
+
+    int summe = 0;
+    int n = 0;
+
+    System.out.println("Lösung mit for-Schleife:");
+
+    for(n = START; n <= ENDE; n++) {
+      summe += n;
+      System.out.println(summe);
+    }
+
+    System.out.println("Lösung mit while-Schleife:");
+
+    summe = 0;
+    n = START;
+
+    while(n <= 20) {
+      summe += n;
+      System.out.println(summe);
+      n++;
+    }
+
+    System.out.println("Lösung mit do-while-Schleife:");
+
+    summe = 0;
+    n = START;
+
+    do {
+      summe += n;
+      System.out.println(summe);
+      n++;
+    } while (n <= ENDE);
+  }
+}

S01-VL04-Aufgabe 3/Aufgabe.java

@@ -0,0 +1,40 @@
+class Aufgabe {
+  public static void main(String[] args) {
+    final int MAXIMUM = 200;
+    int[] zahlenreihe = new int[MAXIMUM];
+
+    // Initialisieren der Zahlenreihe.
+    for(int i = 0; i < MAXIMUM; i++) {
+      zahlenreihe[i] = i + 1;
+    }
+
+    // Alle Basen durchlaufen.
+    for(int i = 0; i <= (MAXIMUM / 2); i++) {
+      int basis = zahlenreihe[i];
+
+      // Alle Basen und Zahlen kleiner als 2 können ignoriert werden.
+      // Zahlen kleiner als 2 sind keine Primzahlen.
+      // Eine Base welche keine Primzahl ist wird mit 0 überschrieben ("durchgestrichen").
+      if(basis < 2) {
+        continue;
+      }
+
+      // Alle Zahlen der Zahlenreihe durchlaufen um für die Basis passende Zahlen zu finden.
+      for(int j = i + 1; j < MAXIMUM; j++) {
+        int zahl = zahlenreihe[j];
+
+        // Es ist keine Primzahl wenn die Zahl durch die Basis teilbar ist.
+        if(zahl % basis == 0) {
+          zahlenreihe[j] = 0;
+        }
+      }
+    }
+
+    // In der Zahlenreihe sind jetzt nur noch Primzahlen vorhanden.
+    for(int i = 0; i < MAXIMUM; i++) {
+      if(zahlenreihe[i] >= 2) {
+        System.out.println(zahlenreihe[i]);
+      }
+    }
+  }
+}

S01-VL04-Aufgabe 4/Aufgabe.java

@@ -0,0 +1,32 @@
+class Aufgabe {
+  public static void main(String[] args) {
+    final int laufzeit = 10;
+    final double startwert = 100.0;
+
+    // Die verschiedenen Zinssätze definieren.
+    double zinssatz[] = {3.5, 4.5, 5.5};
+
+    // Es kann eine Matrix erstellt werden in welcher die Informationen für die Entwicklung gespeichert werden.
+    // Die Zeilen sind die Informationen der Jahre. Die Spalten sind die Entwicklung je nach Zinssatz.
+    double entwicklung[][] = new double[laufzeit][3];
+
+    // Für jedes Jahr muss die Entwicklung angepasst werden.
+    for(int i = 0; i < laufzeit; i++) {
+      for(int z = 0; z < zinssatz.length; z++) {
+        double wert = (i == 0) ? startwert : entwicklung[i-1][z];
+        entwicklung[i][z] = wert + (wert * (zinssatz[z] / 100.0));
+      }
+    }
+
+    // Die Parameter ausgeben damit die Grundlage der Entwicklung sichtbar ist.
+    System.out.printf("Laufzeit: %d Jahre - Startwert: %.2f EUR\n\n", laufzeit, startwert);
+
+    // Die Kopfleiste für die Tabelle ausgeben.
+    System.out.printf("Jahr\t%11.2f%%\t%11.2f%%\t%11.2f%%\n", zinssatz[0], zinssatz[1], zinssatz[2]);
+
+    // Die Informationen der Entwicklung ausgeben.
+    for(int i = 0; i < entwicklung.length; i++) {
+      System.out.printf("%d\t%8.2f EUR\t%8.2f EUR\t%8.2f EUR\n", (2023 + 1) + i, entwicklung[i][0], entwicklung[i][1], entwicklung[i][2]);
+    }
+  }
+}

S01-VL04-Aufgabe 5/Aufgabe.java

@@ -0,0 +1,73 @@
+class Aufgabe {
+  public static void main(String[] args) {
+    final int RECHTS = 1;
+    final int LINKS = 0;
+    final int NUM_FROESCHE = 100000;
+
+    // Neuer Frosch startet bei Feld 1.
+    int position = 1;
+    int position_max = 0;
+
+    // Es gibt zwei Eimer in welchen ein Frosch landen kann.
+    // Eimer bei Index 0 ist der linke Eimer.
+    // Eimer bei Index 1 ist der rechte Eimer.
+    int[] eimer = {0, 0};
+
+    // Auf der Zahlengerade springt der aktuelle Frosch.
+    // Das Feld 0 ist bereits ein Eimer (der rechte Eimer).
+    // Wenn der Frosch den Index auf der linken Seite verlässt springt er in den linken Eimer.
+    int[] zahlengerade = new int[1000];
+
+    // Die Zahlengerade wird initialisiert. Am Anfang zeigen alle Felder nach rechts.
+    // 0 = Frosch springt nach links.
+    // 1 = Frosch springt nach rechts.
+    for(int i = 0; i < zahlengerade.length; i++) {
+      zahlengerade[i] = RECHTS;
+    }
+
+    // Schleife mit welcher alle Frösche durchlaufen werden.
+    // Es ist immer nur ein Frosch auf der Zahlengerade unterwegs.
+    for(int anzahl_froesche = NUM_FROESCHE; anzahl_froesche > 0; anzahl_froesche--) {
+      position = 1;
+
+      // Der Frosch bewegt sich so lange auf der Zahlengerade bis dieser in einen Eimer fällt.
+      // Es steht ein Eimer auf Index 0 und Index -1.
+      while(position > 0) {
+
+        // Wenn der Frosch das Feld berüht ändert sich die Richtung des Felds.
+        zahlengerade[position] = (zahlengerade[position] == RECHTS) ? LINKS : RECHTS;
+
+        // Je nach Richtung muss der Frosch jetzt springen.
+        if (zahlengerade[position] == RECHTS) {
+          position += 1;
+
+          // Die maximale Position soll gespeichert werden.
+          if (position_max < position) {
+            position_max = position;
+          }
+        } else {
+
+          // Der Frosch soll nach links springen.
+          // Er könnte jetzt in einen Eimer springen.
+          if (position == 1) {
+
+            // Der Frosch springt in den linken Eimer.
+            eimer[0]++;
+          } else if (position == 2) {
+
+            // Der Frosch springt in den rechten Eimer.
+            eimer[1]++;
+          }
+
+          // Der Frosch springt nach links (evtl. in einen Eimer).
+          position -= 2;
+        }
+      }
+    }
+
+    // Ausgabe der wichtigsten Informationen.
+    System.out.printf("Linker Eimer (Index -1): %d Frösche\n", eimer[0]);
+    System.out.printf("Rechter Eimer (Index 0): %d Frösche\n", eimer[1]);
+    System.out.printf("Maximale Position auf der Zahlengerade: %d\n", position_max);
+  }
+}

S01-VL04-Aufgabe 6/Aufgabe.java

@@ -0,0 +1,78 @@
+class Aufgabe {
+  public static void main(String[] args) {
+    enum Monate {Januar, Februar, März, April, Mai, Juni, Juli, August, September, Oktober, November, Dezember};
+    String quartal = "";
+    Monate monat = Monate.Oktober;
+
+    // Ursprüngliche switch-Anweisung:
+    switch(monat) {
+      case Januar : quartal = "1. Quartal"; break;
+      case Februar : quartal = "1. Quartal"; break;
+      case März : quartal = "1. Quartal"; break;
+      case April : quartal = "2. Quartal"; break;
+      case Mai : quartal = "2. Quartal"; break;
+      case Juni : quartal = "2. Quartal"; break;
+      case Juli : quartal = "3. Quartal"; break;
+      case August : quartal = "3. Quartal"; break;
+      case September : quartal = "3. Quartal"; break;
+      case Oktober : quartal = "4. Quartal"; break;
+      case November : quartal = "4. Quartal"; break;
+      case Dezember : quartal = "4. Quartal"; break;
+      default : quartal = "";
+    }
+
+    System.out.println("a.) ursprüngliche switch-Anweisung: " + quartal);
+
+    // Zusammenfassung mehrerer Ausdrücke.
+    switch(monat) {
+      case Januar, Februar, März : quartal = "1. Quartal"; break;
+      case April, Mai, Juni : quartal = "2. Quartal"; break;
+      case Juli, August, September : quartal = "3. Quartal"; break;
+      case Oktober, November, Dezember : quartal = "4. Quartal"; break;
+      default : quartal = "";
+    }
+
+    System.out.println("b.) Zusammenfassung mehrerer Ausdrücke: " + quartal);
+
+    // Pfeilnotation
+    switch (monat) {
+      case Januar -> quartal = "1. Quartal";
+      case Februar -> quartal = "1. Quartal";
+      case März -> quartal = "1. Quartal";
+      case April -> quartal = "2. Quartal";
+      case Mai -> quartal = "2. Quartal";
+      case Juni -> quartal = "2. Quartal";
+      case Juli -> quartal = "3. Quartal";
+      case August -> quartal = "3. Quartal";
+      case September -> quartal = "3. Quartal";
+      case Oktober -> quartal = "4. Quartal";
+      case November -> quartal = "4. Quartal";
+      case Dezember -> quartal = "4. Quartal";
+      default -> quartal = "";
+    }
+
+    System.out.println("c.) Pfeilnotation: " + quartal);
+
+    // Zusammenfassung mehrerer Ausdrücke in Pfeilnotation.
+    switch(monat) {
+      case Januar, Februar, März -> quartal = "1. Quartal";
+      case April, Mai, Juni -> quartal = "2. Quartal";
+      case Juli, August, September -> quartal = "3. Quartal";
+      case Oktober, November, Dezember -> quartal = "4. Quartal";
+      default -> quartal = "";
+    }
+
+    System.out.println("d.) Zusammenfassung mehrerer Ausdrücke in Pfeilnotation: " + quartal);
+
+    // switch-Ausdruck mit Pfeilnotation
+    quartal = switch(monat) {
+      case Januar, Februar, März -> "1. Quartal";
+      case April, Mai, Juni -> "2. Quartal";
+      case Juli, August, September -> "3. Quartal";
+      case Oktober, November, Dezember -> "4. Quartal";
+      default -> "";
+    };
+
+    System.out.println("e.) switch-Ausdruck mit Pfeilnotation: " + quartal);
+  }
+}

S01-VL05-Aufgabe 1/Aufgabe.java

@@ -0,0 +1,81 @@
+class Aufgabe {
+  public static void main(String[] args) {
+
+    // Es gibt zwei Möglichkeiten die Fibunacci-Folge zu erstellen.
+    // Dabei werden die ersten zwei Felder immer mit festen Werten definiert.
+    //    Variante 1: F0 = 0; F1 = 1
+    //    Variante 2: F0 = 1; F1 = 1
+    // Alle Werte danach werden aber immer nach der gleichen Regel erstellt.
+    //    FN = FN-2 + FN-1
+
+    System.out.println("Iterativ:");
+    iterativ(45);
+
+    System.out.println("Rekursiv:");
+    rekursiv(0, 1, 45);
+  }
+
+  /**
+   * Ermitteln der Fibonaccizahlen mit einer iterativen Lösung.
+   * @param fields Die Anzahl der Felder welche mit Fibonaccizahlen gefüllt werden sollen.
+   */
+  public static void iterativ(int fields) {
+
+    // Initialisieren der Folge. Die Größe der Folge gibt die Anzahl der Fibonaccizahlen an.
+    int[] fibonaccifolge = new int[fields];
+
+    // Alle Felder der Folge initialisieren.
+    // Die ersten zwei Zahlen müssen dabei fest definiert werden.
+    // Die Felder werden dabei nach Variante 1 definiert.
+    for(int i = 0; i < fibonaccifolge.length; i++) {
+      if (i == 0 || i == 1) {
+        fibonaccifolge[i] = i;
+      } else {
+        fibonaccifolge[i] = 0;
+      }
+    }
+
+    // Für alle Felder danach kann dann eine Formel verwendet werden.
+    for(int i = 2; i < fibonaccifolge.length; i++) {
+      fibonaccifolge[i] = fibonaccifolge[i-1] + fibonaccifolge[i-2];
+    }
+
+    // Ausgeben der Fibonaccifolge.
+    for(int i = 0; i < fibonaccifolge.length; i++) {
+      System.out.println(fibonaccifolge[i]);
+    }
+  }
+
+  /**
+   * Ermitteln der Fibonaccizahlen mit einer iterativen Lösung.
+   * @param a Der Wert des Felds FN-2.
+   * @param b Der Wert des Felds FN-1.
+   * @param max Die Anzahl der Fibonaccizahlen welche ermittelt werden sollen.
+   * @return Die ermittelte Fibonaccizahl.
+   */
+  public static int rekursiv(int a, int b, int max) {
+
+    // Der Beginn der Fibonaccifolge muss mit bestimmten Werten initialisiert werden.
+    // Die Werte werden dabei mit den Werten aus Variante 1 initialisiert.
+    if((a == 0 && b == 0) || (a == 0 && b == 1)) {
+      a = 0;
+      b = 1;
+      max -= 2;
+      System.out.println(a);
+      System.out.println(b);
+    }
+
+    // Anzahl der Felder reduzieren.
+    max--;
+
+    // Ausgeben der aktuellen Fibonaccizahl.
+    System.out.println((a + b));
+
+    // Es werden so lange Fibonaccizahlen erstellt so lange noch Felder verfügbar sind.
+    if(max > 0) {
+      return rekursiv(b, a + b, max);
+    } else {
+      return a + b;
+    }
+  }
+}

Template.java

@@ -0,0 +1,5 @@
+class Aufgabe {
+  public static void main(String[] args) {
+    // Code
+  }
+}

clear.sh

@@ -0,0 +1,2 @@
+# remove all compiled class files.
+rm **/*.class