Bugfix

.github/workflows/enable-automerge.yml

@@ -0,0 +1,36 @@
+name: Enable auto-merge for open PRs
+
+on:
+  workflow_dispatch: {}
+  pull_request:
+    types: [opened, reopened,ready_for_review]
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  enable:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Enable auto-merge for all open PRs (and the current one)
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          REPO: ${{ github.repository }}
+        run: |
+          set -euo pipefail
+
+          echo "Listing open PRs in $REPO..."
+          prs=$(gh pr list --repo "$REPO" --state open --json number --jq '.[].number')
+
+          if [ -z "$prs" ]; then
+            echo "No open PRs."
+            exit 0
+          fi
+
+          for pr in $prs; do
+            echo "Enabling auto-merge for PR #$pr"
+            # Choose merge strategy: --merge | --squash | --rebase
+            # Use --merge here; change if you prefer squash:
+            gh pr merge "$pr" --repo "$REPO" --auto --merge || true
+          done

solutions/java/calculator-conundrum/1/src/main/java/CalculatorConundrum.java

@@ -0,0 +1,18 @@
+class CalculatorConundrum {
+    public String calculate(int operand1, int operand2, String operation) {
+        switch (operation) {
+            case null : throw new IllegalArgumentException("Operation cannot be null");
+            case "" : throw new IllegalArgumentException("Operation cannot be empty");
+            case "+" : return operand1 + " + " + operand2 + " = " + (operand1 + operand2);
+            case "*" : return operand1 + " * " + operand2 + " = " + (operand1 * operand2);
+            case "/" :
+                try {
+                    return operand1 + " / " + operand2 + " = " + (operand1 / operand2);
+                } catch (ArithmeticException e) {
+                    throw new IllegalOperationException("Division by zero is not allowed", e);
+                }
+            default: throw new IllegalOperationException(String.format("Operation '%s' does not exist", operation));
+
+        }
+    }
+}

solutions/java/captains-log/1/src/main/java/CaptainsLog.java

@@ -0,0 +1,30 @@
+import java.util.Random;
+import java.util.List;
+import java.util.concurrent.ThreadLocalRandom;
+
+class CaptainsLog {
+
+    private static final char[] PLANET_CLASSES = new char[]{'D', 'H', 'J', 'K', 'L', 'M', 'N', 'R', 'T', 'Y'};
+
+    private Random random;
+
+    CaptainsLog(Random random) {
+        this.random = random;
+    }
+
+    char randomPlanetClass() {
+        List<Character> buchstaben = List.of('D', 'H', 'J', 'K', 'L', 'M', 'N', 'R', 'T', 'Y');
+        int index = random.nextInt(buchstaben.size());
+
+        return buchstaben.get(index);
+    }
+
+    String randomShipRegistryNumber() {
+        int zahl = random.nextInt(10000 - 1000) + 1000;
+        return "NCC-" + zahl;
+    }
+
+    double randomStardate() {
+        return 41000 +random.nextDouble() * (42000 - 41000);
+    }
+}

solutions/java/football-match-reports/1/src/main/java/FootballMatchReports.java

@@ -0,0 +1,24 @@
+public class FootballMatchReports {    
+    public static String onField(int shirtNum) {
+        switch (shirtNum) {
+            case 1:
+                return "goalie";
+            case 2:
+                return "left back";
+            case 3, 4:
+                return "center back";
+            case 5:
+                return "right back";
+            case 6, 7, 8:
+                return "midfielder";
+            case 9:
+                return "left wing";
+            case 10:
+                return "striker";
+            case 11:
+                return "right wing";
+            default:
+                return "invalid";
+        }
+    }
+}

solutions/java/gotta-snatch-em-all/1/src/main/java/GottaSnatchEmAll.java

@@ -0,0 +1,47 @@
+import java.util.List;
+import java.util.Set;
+
+class GottaSnatchEmAll {
+
+    static Set<String> newCollection(List<String> cards) {
+        return Set.copyOf(cards);
+    }
+
+    static boolean addCard(String card, Set<String> collection) {
+        return collection.add(card);
+    }
+
+    static boolean canTrade(Set<String> myCollection, Set<String> theirCollection) {
+        boolean a = !myCollection.containsAll(theirCollection);
+        boolean b = !theirCollection.containsAll(myCollection);
+        return a && b;
+    }
+
+    static Set<String> commonCards(List<Set<String>> collections) {
+        if (collections == null || collections.isEmpty()) {
+            return Set.of();
+        }
+
+        Set<String> common = Set.copyOf(collections.get(0));
+
+        for (int i = 1; i < collections.size(); i++) {
+            common = common.stream()
+                           .filter(collections.get(i)::contains)
+                           .collect(java.util.stream.Collectors.toUnmodifiableSet());
+        }
+
+        return common;
+    }
+
+     static Set<String> allCards(List<Set<String>> collections) {
+        List<String> cards = new java.util.ArrayList<>();
+        for (Set<String> set : collections) {
+            for (String card : set) {
+                if (!cards.contains(card)) {
+                    cards.add(card);
+                }
+            }
+        }
+        return Set.copyOf(cards);
+    }
+}

solutions/java/international-calling-connoisseur/1/src/main/java/DialingCodes.java

@@ -0,0 +1,41 @@
+import java.util.Map;
+import java.util.HashMap;
+
+public class DialingCodes {
+
+    Map<Integer, String> map = new HashMap<>();
+
+    public Map<Integer, String> getCodes() {
+        return map;
+    }
+
+    public void setDialingCode(Integer code, String country) {
+        map.put(code, country);
+    }
+
+    public String getCountry(Integer code) {
+        return map.get(code);
+    }
+
+    public void addNewDialingCode(Integer code, String country) {
+       if (map.containsKey(code) || map.containsValue(country)) {
+           return;
+       }
+           map.put(code, country);
+    }
+
+    public Integer findDialingCode(String country) {
+        for (Map.Entry<Integer, String> entry : map.entrySet()) {
+            if (entry.getValue().equals(country)) {
+                return entry.getKey(); // Gefunden!
+            }
+        }
+        return null;
+    }
+    public void updateCountryDialingCode(Integer code, String country) {
+        if (map.containsValue(country)) {
+            map.remove(findDialingCode(country));
+            map.put(code, country);
+        }
+    }
+}

solutions/java/jedliks-toy-car/1/src/main/java/JedliksToyCar.java

@@ -0,0 +1,25 @@
+public class JedliksToyCar {
+        int batteries = 100;
+        int meters;
+    public static JedliksToyCar buy() {
+        return new JedliksToyCar();  
+    }
+
+    public String distanceDisplay() {
+        return String.format("Driven %d meters", meters);
+    }
+
+    public String batteryDisplay() {
+        if (batteries == 0) {
+            return "Battery empty";
+        }
+        return String.format("Battery at %d%%", batteries);
+    }
+
+    public void drive() {
+        if (batteries > 0) {   
+        meters += 20;
+        batteries -= 1;
+        }
+    }
+}

solutions/java/karls-languages/1/src/main/java/LanguageList.java

@@ -0,0 +1,37 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class LanguageList {
+    private final List<String> languages = new ArrayList<>();
+
+    public boolean isEmpty() {
+        return languages.isEmpty();
+    }
+
+    public void addLanguage(String language) {
+        languages.add(language);
+    }
+
+    public void removeLanguage(String language) {
+        languages.remove(language);
+    }
+
+    public String firstLanguage() {
+        return languages.get(0);
+    }
+
+    public int count() {
+        return languages.size();
+    }
+
+    public boolean containsLanguage(String language) {
+       return languages.contains(language);
+    }
+
+    public boolean isExciting() {
+        if (languages.contains("Kotlin") || languages.contains("Java")) {
+            return true;
+        }
+        return false;
+    }
+}

solutions/java/log-levels/1/src/main/java/LogLevels.java

@@ -0,0 +1,53 @@
+public class LogLevels {
+
+    public static String message(String logLine) {
+        String[] parts = logLine.trim().split("\\s+", 2);
+        StringBuilder rest = new StringBuilder();
+            for (int i = 1; i < parts.length; i++) {
+                if (i > 1) rest.append(" "); // Separator dazwischen
+                rest.append(parts[i]);
+            }
+        return rest.toString();
+    }
+
+    public static String logLevel(String logLine) {
+        String[] parts = logLine.split(" ");
+        if (parts[0].equals("[ERROR]:")) {
+            return "error";
+        } else if (parts[0].equals("[WARNING]:")) {
+            return "warning";
+        } else {
+            return "info";
+        }
+    }
+
+    public static String reformat(String logLine) {
+        String[] parts = logLine.trim().split("\\s+", 2);
+
+        if (parts[0].equals("[ERROR]:")) {
+            StringBuilder rest = new StringBuilder();
+            for (int i = 1; i < parts.length; i++) {
+                if (i > 1) rest.append(" "); // Separator dazwischen
+                rest.append(parts[i]);
+            }
+            rest.append(" (error)");
+            return rest.toString();
+        } else if (parts[0].equals("[WARNING]:")) {
+            StringBuilder rest = new StringBuilder();
+            for (int i = 1; i < parts.length; i++) {
+                if (i > 1) rest.append(" "); // Separator dazwischen
+                rest.append(parts[i]);
+            }
+            rest.append(" (warning)");
+            return rest.toString();
+        } else {
+            StringBuilder rest = new StringBuilder();
+            for (int i = 1; i < parts.length; i++) {
+                if (i > 1) rest.append(" "); // Separator dazwischen
+                rest.append(parts[i]);
+            }
+            rest.append(" (info)");
+            return rest.toString();
+        }
+    }
+}

solutions/java/logs-logs-logs/1/src/main/java/LogLevel.java

@@ -0,0 +1,9 @@
+public enum LogLevel {
+    TRACE,
+    DEBUG,
+    INFO,
+    WARNING,
+    ERROR,
+    FATAL,
+    UNKNOWN;
+}

solutions/java/logs-logs-logs/1/src/main/java/LogLine.java

@@ -0,0 +1,34 @@
+public class LogLine {
+    private String logLine;
+
+    public LogLine(String logLine) {
+        this.logLine = logLine;
+    }
+
+    public LogLevel getLogLevel() {
+        String code = logLine.substring(1, 4);
+        switch (code) {
+            case "TRC": return LogLevel.TRACE;
+            case "DBG": return LogLevel.DEBUG;
+            case "INF": return LogLevel.INFO;
+            case "WRN": return LogLevel.WARNING;
+            case "ERR": return LogLevel.ERROR;
+            case "FTL": return LogLevel.FATAL;
+            default: return LogLevel.UNKNOWN;
+        }
+    }
+
+    public String getOutputForShortLog() {
+        String code = logLine.substring(1, 4);
+        String message = logLine.substring(7);
+        switch (code) {
+            case "TRC": return "1:" + message;
+            case "DBG": return "2:" + message;
+            case "INF": return "4:" + message;
+            case "WRN": return "5:" + message;
+            case "ERR": return "6:" + message;
+            case "FTL": return "42:" + message;
+            default: return "0:" + message;
+        }
+    }
+}