{"id":54130,"date":"2025-12-05T08:46:36","date_gmt":"2025-12-05T07:46:36","guid":{"rendered":"https:\/\/www.happycoders.eu\/?p=54130"},"modified":"2025-12-15T08:43:47","modified_gmt":"2025-12-15T07:43:47","slug":"advent-of-code-2025","status":"publish","type":"post","link":"https:\/\/www.happycoders.eu\/de\/algorithmen\/advent-of-code-2025\/","title":{"rendered":"Advent\u00a0of\u00a0Code 2025\u00a0\u2013 Java L\u00f6sungen"},"content":{"rendered":"\n

Dieses Jahr habe ich wieder beim Advent of Code<\/em><\/a> mitgemacht. In diesem Artikel findest du meine L\u00f6sungen. Mein Ziel ist es, die L\u00f6sungen m\u00f6glichst verst\u00e4ndlich zu implementieren, nicht m\u00f6glichst \u201esmart\u201c oder kurz. Ich setze SonarQube<\/a> ein, um eine m\u00f6glichst hohe Code-Qualit\u00e4t zu erreichen.<\/p>\n\n\n\n

Ich werden au\u00dferdem versuchen, m\u00f6glichst viele Features des aktuellen Java 25<\/a> zu verwenden \u2013 einschlie\u00dflich Preview-Features.<\/p>\n\n\n\n

Wer Advent of Code<\/em> noch nicht kennt: Es gibt \u2013 in eine vorweihnachtliche Geschichte verpackt \u2013 jeden Tag eine Programmieraufgabe. Oder besser gesagt: jeden Tag zwei \u2013 n\u00e4mlich eine, die sich recht schnell l\u00f6sen l\u00e4sst \u2013 und eine zweite, bei der einem in der Regel die Zeit- oder Platzkomplexit\u00e4t<\/a> der ersten L\u00f6sung einen Strich durch die Rechnung macht \u2026 und man noch mal von vorne \u00fcberlegen muss.<\/p>\n\n\n\n

Die L\u00f6sungen findest du in diesem GitHub-Projekt: Advent of Code 2025 \u2013 Java 25 Solutions<\/a>.<\/p>\n\n\n\n

Hier findest du meine L\u00f6sungen f\u00fcr Advent of Code 2015<\/a> und Advent of Code 2022<\/a>.<\/p>\n\n\n\n

Und jetzt geht's los!<\/p>\n\n\n\n

Advent of Code 2025 \u2013 Tag 1 Java-L\u00f6sung<\/h2>\n\n\n\n

Aufgabe: Advent of Code 2025 \u2013 Tag 1 Aufgabe<\/a><\/p>\n\n\n\n

Advent of Code 2025 beginnt recht knifflig!<\/p>\n\n\n\n

Wir beginnen mit einem Parser f\u00fcr die Rotation:<\/p>\n\n\n

private<\/span> static<\/span> int<\/span> parseRotation<\/span>(String s)<\/span> <\/span>{\n  int<\/span> multiplicator = s.charAt(0<\/span>) == 'R'<\/span> ? 1<\/span> : -1<\/span>;\n  return<\/span> multiplicator * Integer.parseInt(s.substring(1<\/span>));\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Teil 1<\/h3>\n\n\n\n
Teil 1 ist noch schnell gel\u00f6st: wir m\u00fcssen f\u00fcr jede Zeile der Eingabe die Rotationen ausf\u00fchren und immer dann einen Counter hochz\u00e4hlen, wenn nach der Rotation der Zeiger auf der Null steht:<\/p>\n\n\n
position = Math.floorMod(position + rotation, DIAL_SIZE);\nif<\/span> (position == 0<\/span>) {\n  zeroCount++;\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Wichtig ist dabei, dass wir Math.floorMod(...)<\/code> verwenden und nicht den %<\/code>-Operator, denn der berechnet in Java nicht den Modulo, sondern den Rest nach einer Teilung. Beispielsweise ergibt -140 % 100<\/code> nicht etwa 60, sondern -40. Um 60 zu erhalten, m\u00fcssen wir Math.floorMod(-140, 100)<\/code> aufrufen.<\/p>\n\n\n\n
Teil 2<\/h3>\n\n\n\n
Teil 2 m\u00fcssen wir komplett anders angehen. Zun\u00e4chst einmal berechnen wir die neue Position ohne die Modulo-Operation:<\/p>\n\n\n
position += rotation;<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Jetzt m\u00fcssen wir unterscheiden, ob wir rechts oder links herum gedreht haben. Bei einer Rechts-Rotation ist die Berechnung einfach: die H\u00e4ufigkeit, mit der der Zeiger auf die Null gezeigt hat, ist die Position geteilt durch DIAL_SIZE<\/code>:<\/p>\n\n\n
if<\/span> (rotation > 0<\/span>) {\n  zeroCount += position \/ DIAL_SIZE;\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Bei einer Links-Rotation ist die Berechnung komplizierter:<\/p>\n\n\n
else<\/span> {\n  zeroCount += (DIAL_SIZE - position) \/ DIAL_SIZE;\n\n  boolean<\/span> startedAtZero = position - rotation == 0<\/span>;\n  if<\/span> (startedAtZero) {\n    zeroCount--;\n  }\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Da wir mit einer negativen Zahl arbeiten, m\u00fcssen wir diese zun\u00e4chst von DIAL_SIZE<\/code> subtrahieren. Dann ist noch ein Sonderfall zu beachten: Wenn der Zeiger zu Beginn der Operation auf Null steht, w\u00fcrde diese Null mitgez\u00e4hlt werden. Deshalb m\u00fcssen wir in diesem Fall eine Null abziehen.<\/p>\n\n\n\n
Der else<\/code>-Block lie\u00dfe sich auch \u201esmart\u201c wie folgt schreiben:  <\/p>\n\n\n
else<\/span> {\n  zeroCount += (DIAL_SIZE - position) \/ DIAL_SIZE - (position - rotation == 0<\/span> ? 1<\/span> : 0<\/span>);\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Ich halte aber die erste, etwas l\u00e4ngere Variante f\u00fcr deutlich besser lesbar.<\/p>\n\n\n\n
Zum Schluss m\u00fcssen wir die Position wieder auf den Zahlenbereich 0\u201399 \u201enormalisieren\u201c:<\/p>\n\n\n
position = Math.floorMod(position, DIAL_SIZE);<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Die vollst\u00e4ndige L\u00f6sung findest du hier: Advent of Code 2025 \u2013 Tag 1 Java-L\u00f6sung<\/a><\/p>\n\n\n\n
Advent of Code 2025 \u2013 Tag 2 Java-L\u00f6sung<\/h2>\n\n\n\n
Aufgabe: Advent of Code 2025 \u2013 Tag 2 Aufgabe<\/a><\/p>\n\n\n\n
F\u00fcr Tag 2 schreibe ich zun\u00e4chst einen Range<\/code>-Klasse, die eine Zeile der Eingabe parsen und einen Stream aller Zahlen des Zahlenbereichs zur\u00fcckgeben kann (diese Klasse werden wir praktischerweise an sp\u00e4teren Tagen wiederverwenden k\u00f6nnen):<\/p>\n\n\n
public<\/span> record Range<\/span>(long<\/span> from, long<\/span> to)<\/span> <\/span>{\n  public<\/span> static<\/span> Range parse<\/span>(String s)<\/span> <\/span>{\n    String[] split = s.split(\"-\"<\/span>);\n    return<\/span> new<\/span> Range(Long.parseLong(split[0<\/span>]), Long.parseLong(split[1<\/span>]));\n  }\n\n  public<\/span> LongStream ids<\/span>()<\/span> <\/span>{\n    return<\/span> LongStream.rangeClosed(from, to);\n  }\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Teil 1 und 2 unterscheiden sich durch die maximale Anzahl Wiederholungen innerhalb einer ID. Bei Teil 1 sind es zwei Wiederholungen, bei Teil 2 gibt es keine Begrenzung \u2013 ich verwende Integer.MAX_VALUE<\/code>.<\/p>\n\n\n\n
Damit kann ich schon mal eine Hauptfunktion schreiben:<\/p>\n\n\n
static<\/span> long<\/span> solve<\/span>(String input, int<\/span> maxRepetitions)<\/span> <\/span>{\n  return<\/span> Stream.of(input.split(\",\"<\/span>))\n      .map(Range::parse)\n      .flatMapToLong(Range::ids)\n      .filter(id -> isInvalidId(id, maxRepetitions))\n      .sum();\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Jetzt brauchen wir nur noch eine isInvalidId(...)<\/code>-Methode. <\/p>\n\n\n\n
Ich zeige sie dir zun\u00e4chst und erkl\u00e4re sie danach:<\/p>\n\n\n
private<\/span> static<\/span> boolean<\/span> isInvalidId<\/span>(long<\/span> id, int<\/span> maxRepetitions)<\/span> <\/span>{\n  String idString = Long.toString(id);\n  int<\/span> idLength = idString.length();\n  int<\/span> minSequenceLength = Math.ceilDiv(idLength, maxRepetitions);\n  int<\/span> maxSequenceLength = idLength \/ 2<\/span>;\n\n  for<\/span> (int<\/span> sequenceLength = minSequenceLength; \n       sequenceLength <= maxSequenceLength; \n       sequenceLength++) {\n    if<\/span> (containsOnlyRepetitions(idString, idLength, sequenceLength)) {\n      return<\/span> true<\/span>;\n    }\n  }\n\n  return<\/span> false<\/span>;\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Zun\u00e4chst wird hier die minmale und maximale L\u00e4nge der sich wiederholenden Teilsequenz berechnet:<\/p>\n\n\n\n