Remove all solution markdown, task images, solution PDFs, and add renamed folder structure as part of THB-wide reorganization.

uebung_01/aufgabenblatt1.iml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module-library">
+      <library>
+        <CLASSES>
+          <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/26.0.2/annotations-26.0.2.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+  </component>
+</module>

uebung_01/src/task3/NumberGuesser.java

@@ -0,0 +1,49 @@
+package task3;
+
+import java.util.Scanner;
+
+public class NumberGuesser {
+    private int number;
+
+    public NumberGuesser(int targetNumber){
+        this.number = targetNumber;
+    }
+    public boolean isBigger(int guess){
+        return guess < number;
+    }
+
+    public void guess(){
+        Scanner scanner = new Scanner(System.in);
+        System.out.println("Guess a number: ");
+        int guess = scanner.nextInt();
+        switch (Integer.compare(guess, number)) {
+            case -1 -> System.out.println("Too low!");
+            case 0 -> System.out.println("Correct!");
+            case 1 -> System.out.println("Too high!");
+        }
+    }
+
+    public void autoGuess(){
+        int low = Integer.MIN_VALUE;
+        int high = Integer.MAX_VALUE;
+
+        while (low <= high) {
+            int mid = low + (high - low) / 2;
+
+            System.out.println("Guess: " + mid);
+            if (mid == number) {
+                return;
+            } else if (isBigger(mid)) {
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        NumberGuesser numberGuesser = new NumberGuesser(100);
+        System.out.println(numberGuesser.isBigger(Integer.MAX_VALUE/2));
+        numberGuesser.autoGuess();
+    }
+}

uebung_01/src/task3/NumberGuesserAI.java

@@ -0,0 +1,38 @@
+package task3;
+
+import java.util.Scanner;
+
+public class NumberGuesserAI {
+    private final int number;
+
+    public NumberGuesserAI(int targetNumber){
+        this.number = targetNumber;
+    }
+    public boolean isBigger(int guess){
+        return guess < number;
+    }
+
+    public void autoGuess(){
+        int low = Integer.MIN_VALUE;
+        int high = Integer.MAX_VALUE;
+
+        while (low <= high) {
+            int mid = low + (high - low) / 2;
+
+            if (mid == number) {
+                System.out.println("Found the number: " + mid);
+                return;
+            } else if (isBigger(mid)) {
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        NumberGuesserAI numberGuesser = new NumberGuesserAI(100);
+        System.out.println(numberGuesser.isBigger(Integer.MAX_VALUE/2));
+        numberGuesser.autoGuess();
+    }
+}

uebung_01/src/task4/AnagrammChecker.java

@@ -0,0 +1,35 @@
+package task4;
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+public class AnagrammChecker {
+    private String word0;
+    private String word1;
+
+    public AnagrammChecker(String word0, String word1){
+        this.word0 = word0;
+        this.word1 = word1;
+    }
+
+
+
+    public void isAnagram(){
+        String sortedWord0 = sortString(word0);
+        String sortedWord1 = sortString(word1);
+
+        if (sortedWord1.equals(sortedWord0)) {
+            System.out.println("Die Wörter sind Anagramme.");
+        } else {
+            System.out.println("Die Wörter sind keine Anagramme.");
+        }
+    }
+
+    private String sortString(String string) {
+        char tempArr[] = string.toCharArray();
+
+        Arrays.sort(tempArr);
+
+        return new String(tempArr);
+    }
+}

uebung_01/src/task4/AnagrammCheckerAI.java

@@ -0,0 +1,27 @@
+package task4;
+
+import java.util.Arrays;
+
+public class AnagrammCheckerAI {
+    private String word0;
+    private String word1;
+
+    public AnagrammCheckerAI(String word0, String word1){
+        this.word0 = word0;
+        this.word1 = word1;
+    }
+
+
+
+    public boolean isAnagram() {
+        if (word0 == null || word1 == null) {
+            return false;
+        }
+        char[] chars0 = word0.toLowerCase().toCharArray();
+        char[] chars1 = word1.toLowerCase().toCharArray();
+        Arrays.sort(chars0);
+        Arrays.sort(chars1);
+        return Arrays.equals(chars0, chars1);
+    }
+
+}

uebung_01/src/task5/PrimeNumberGenerator.java

@@ -0,0 +1,45 @@
+package task5;
+
+public class PrimeNumberGenerator {
+    private int maximum;
+
+    public PrimeNumberGenerator(int maximum) {
+        this.maximum = maximum;
+    }
+    public void printPrimeNumbers() {
+        for (int i = 2; i <= maximum; i++) {
+            if (isPrime(i)) {
+                System.out.println(i);
+            }
+        }
+    }
+    private boolean isPrime(int number) {
+        for (int i = 2; i < number; i++) {
+            if (number % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    public int countPrimeNumbers() {
+        int count = 0;
+        for (int i = 2; i <= maximum; i++) {
+            if (isPrime(i)) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    public static void main(String[] args) {
+        int[] testValues = {100, 500, 1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000};
+
+        System.out.println("maximum,Anzahl Primzahlen (Algorithmus),maximum/ln(maximum) (Schätzung)");
+        for (int max : testValues) {
+            PrimeNumberGenerator generator = new PrimeNumberGenerator(max);
+            int counted = generator.countPrimeNumbers();
+            double estimated = max / Math.log(max);
+            System.out.printf("%d,%d,%.1f%n", max, counted, estimated);
+        }
+    }
+}

uebung_01/src/task5/PrimeNumberGeneratorAI.java

@@ -0,0 +1,51 @@
+package task5;
+
+public class PrimeNumberGeneratorAI {
+    private final int maximum;
+
+    public PrimeNumberGeneratorAI(int maximum) {
+        this.maximum = maximum;
+    }
+
+    public void printPrimeNumbers() {
+        for (int i = 2; i <= maximum; i++) {
+            if (isPrime(i)) {
+                System.out.println(i);
+            }
+        }
+    }
+
+    private boolean isPrime(int number) {
+        if (number < 2) return false;
+        if (number == 2) return true;
+        if (number % 2 == 0) return false;
+        for (int i = 3; i * i <= number; i += 2) {
+            if (number % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public int countPrimes() {
+        int count = 0;
+        for (int i = 2; i <= maximum; i++) {
+            if (isPrime(i)) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    public static void main(String[] args) {
+        int[] testValues = {100, 500, 1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000};
+
+        System.out.println("maximum,Anzahl Primzahlen (Algorithmus),maximum/ln(maximum) (Schätzung)");
+        for (int max : testValues) {
+            PrimeNumberGeneratorAI generator = new PrimeNumberGeneratorAI(max);
+            int counted = generator.countPrimes();
+            double estimated = max / Math.log(max);
+            System.out.printf("%d,%d,%.1f%n", max, counted, estimated);
+        }
+    }
+}

uebung_01/src/task5/primzahlen_ergebnisse.csv

@@ -0,0 +1,11 @@
+maximum,Anzahl Primzahlen (Algorithmus),maximum/ln(maximum) (Schätzung)
+100,25,21.7
+500,95,80.5
+1000,168,144.8
+2000,303,263.1
+5000,669,587.0
+10000,1229,1085.7
+20000,2262,2019.5
+50000,5133,4621.2
+100000,9592,8685.9
+200000,17984,16385.3

uebung_01/src/task6/Sorter.java

@@ -0,0 +1,65 @@
+package task6;
+
+import util.Util;
+
+public class Sorter {
+    public void sort(int[] array) {
+        if (array == null || array.length <= 1) return;
+
+        int n = array.length;
+        int[] temp = new int[n];
+
+        while (true) {
+            int i = 0;
+            int merges = 0;
+
+            while (i < n) {
+                // Find first run
+                int left = i;
+                while (i + 1 < n && array[i] <= array[i + 1]) i++;
+                int mid = i;
+                i++;
+
+                if (i >= n) break;
+
+                // Find second run
+                while (i + 1 < n && array[i] <= array[i + 1]) i++;
+                int right = i;
+                i++;
+
+                // Merge both runs
+                merge(array, temp, left, mid, right);
+                merges++;
+            }
+
+            if (merges == 0) break;
+        }
+    }
+
+    private void merge(int[] array, int[] temp, int left, int mid, int right) {
+        System.arraycopy(array, left, temp, left, right - left + 1);
+
+        int i = left;
+        int j = mid + 1;
+        int k = left;
+
+        while (i <= mid && j <= right) {
+            if (temp[i] <= temp[j]) {
+                array[k++] = temp[i++];
+            } else {
+                array[k++] = temp[j++];
+            }
+        }
+        while (i <= mid) array[k++] = temp[i++];
+        while (j <= right) array[k++] = temp[j++];
+    }
+
+    public static final void main(String[] args) {
+        int[] array = new int[100000000];
+        Util util = new Util();
+        util.fillArrayRandom(array, 10000000);
+        Sorter mySorter = new Sorter();
+        mySorter.sort(array);
+
+    }
+}

uebung_01/src/task6/SorterAI.java

@@ -0,0 +1,90 @@
+package task6;
+
+import org.jetbrains.annotations.NotNull;
+import util.Util;
+
+public class SorterAI {
+    public void sort(int[] array) {
+        if (array == null || array.length <= 1) return;
+        introsort(array, 0, array.length - 1, 2 * (int) Math.floor(Math.log(array.length) / Math.log(2)));
+    }
+
+    private void introsort(int[] array, int low, int high, int depthLimit) {
+        if (high - low < 16) {
+            insertionSort(array, low, high);
+            return;
+        }
+        if (depthLimit == 0) {
+            heapsort(array, low, high);
+            return;
+        }
+        int pivot = partition(array, low, high);
+        introsort(array, low, pivot - 1, depthLimit - 1);
+        introsort(array, pivot + 1, high, depthLimit - 1);
+    }
+
+    private int partition(int @NotNull [] array, int low, int high) {
+        int mid = low + (high - low) / 2;
+        if (array[mid] < array[low]) swap(array, low, mid);
+        if (array[high] < array[low]) swap(array, low, high);
+        if (array[mid] < array[high]) swap(array, mid, high);
+        int pivot = array[high];
+
+        int i = low - 1;
+        for (int j = low; j < high; j++) {
+            if (array[j] <= pivot) {
+                swap(array, ++i, j);
+            }
+        }
+        swap(array, i + 1, high);
+        return i + 1;
+    }
+
+    private void heapsort(int[] array, int low, int high) {
+        int n = high - low + 1;
+        for (int i = n / 2 - 1; i >= 0; i--)
+            heapify(array, low, n, i);
+        for (int i = n - 1; i > 0; i--) {
+            swap(array, low, low + i);
+            heapify(array, low, i, 0);
+        }
+    }
+
+    private void heapify(int[] array, int offset, int n, int i) {
+        int largest = i;
+        int left = 2 * i + 1;
+        int right = 2 * i + 2;
+        if (left < n && array[offset + left] > array[offset + largest]) largest = left;
+        if (right < n && array[offset + right] > array[offset + largest]) largest = right;
+        if (largest != i) {
+            swap(array, offset + i, offset + largest);
+            heapify(array, offset, n, largest);
+        }
+    }
+
+    private void insertionSort(int[] array, int low, int high) {
+        for (int i = low + 1; i <= high; i++) {
+            int key = array[i];
+            int j = i - 1;
+            while (j >= low && array[j] > key) {
+                array[j + 1] = array[j];
+                j--;
+            }
+            array[j + 1] = key;
+        }
+    }
+
+    private void swap(int @NotNull [] array, int i, int j) {
+        int temp = array[i];
+        array[i] = array[j];
+        array[j] = temp;
+    }
+
+    public static final void main(String[] args) {
+        int[] array = new int[1000000000];
+        Util util = new Util();
+        util.fillArrayRandom(array, 100000000);
+        SorterAI mySorter = new SorterAI();
+        mySorter.sort(array);
+    }
+}

uebung_01/src/util/ArrayTester.java

@@ -0,0 +1,14 @@
+package util;
+
+public class ArrayTester {
+    public static final void main(String[] args)
+    {
+        Util util = new Util();
+        int num = 60;
+        int[] array0 = new int[num];
+        int[] array1 = new int[num];
+        util.fillArrayRandom(array0, num*100);
+        util.fillArrayRandom(array1, num*100);
+        System.out.println(util.firstMatch(array0, array1));
+    }
+}

uebung_01/src/util/Util.java

@@ -0,0 +1,116 @@
+package util;
+/**
+ * Write a description of class Util here.
+ *
+ * @author (your name)
+ * @version (a version number or a date)
+ */
+public class Util
+{
+    public void printArray(int[] array)
+    {
+        for (int i = 0; i < array.length; ++i)
+        {
+            System.out.print(array[i]);
+            
+            // Prüfen, ob wir nicht beim letzten Element sind.
+            // Auf das letzte Element sollte kein Komma folgen.
+            if (i < array.length - 1)
+            {
+                System.out.print(",");
+            }
+        }
+        
+        // Nach Ausgabe brechen wir die Zeile um, damit folgende Ausgaben
+        // in einer neuen Zeile beginnen.
+        System.out.println();
+    }
+    
+    public int randomInt(int upperLimit)
+    {
+        double random = Math.random(); // Zufallszahl zwischen 0.0 und 1.0 holen.
+
+        // Zufallszahl per Multiplikation auf 0.0-upperLimit skalieren
+        random = random * upperLimit;
+        
+        // Nachkommastellen abschneiden und in Ganzzahlwert (int) umwandeln.
+        int result = (int) random;
+        
+        return result;
+    }
+    
+    public void fillArrayRandom(int[] array, int upperLimit)
+    {
+        for (int i = 0; i < array.length; ++i)
+        {
+            array[i] = randomInt(upperLimit);
+        }
+    }
+    
+    public int[] concatArray(int[] array0, int[] array1)
+    {
+        int[] result = new int[array0.length + array1.length];
+        
+        // Manuelles Kopieren mit Schleifen.
+        for (int i = 0; i < array0.length; ++i)
+        {
+            result[i] = array0[i];
+        }
+        for (int i = 0; i < array1.length; ++i)
+        {
+            // Um array0.length verschoben einfügen.
+            result[array0.length + i] = array1[i];
+        }
+        
+        // Alternative Lösung unter Verwendung von System.arraycopy().
+        // System.arraycopy(array0, 0, result, 0, array0.length);
+        // System.arraycopy(array1, 0, result, array0.length, array1.length);
+        
+        return result;
+    }
+
+    public int findMax(int[] array) {
+        int max = 0;
+        boolean found = false;
+        int loopRuns = 0;
+        for (int i = 0; !found && i < array.length; ++i) {
+            loopRuns++;
+            if (array[i] > max) {
+                max = array[i];
+            }
+        }
+        return loopRuns;
+    }
+
+    public int firstMatch(int[] array0, int[] array1) {
+        int loopRuns = 0;
+        for (int i = 0; i < array0.length; i++) {
+            for (int j = 0; j < array1.length; j++) {
+                loopRuns++;
+                if (array0[i] == array1[j]) {
+                    return loopRuns;
+                }
+            }
+        }
+        return loopRuns;
+    }
+    
+    public void fillArrayRandomRecursively(int[] array, int start, int upperLimit)
+    {
+        if (array.length - start <= 0)
+        {
+            return;
+        }
+        
+        array[start] = randomInt(upperLimit);
+        fillArrayRandomRecursively(array, start + 1, upperLimit);
+    }
+    
+    public void testRandomFillRecursively()
+    {
+        Util util = new Util();
+        int[] valueArray = new int[100];
+        util.fillArrayRandomRecursively(valueArray, 0, 100);
+        util.printArray(valueArray);
+    }
+}