day 18

Author: cicaleseandrea

src/main/java/com/adventofcode/aoc2024/AoC182024.java

@@ -0,0 +1,71 @@
+package com.adventofcode.aoc2024;
+
+import static com.adventofcode.utils.Utils.itoa;
+import static java.util.stream.Collectors.toCollection;
+
+import com.adventofcode.Solution;
+import com.adventofcode.utils.Direction;
+import com.adventofcode.utils.GraphUtils;
+import com.adventofcode.utils.Point;
+import com.adventofcode.utils.Utils;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Stream;
+
+class AoC182024 implements Solution {
+
+  private static final int EXAMPLE_SIZE = 7;
+  private static final int INPUT_SIZE = 71;
+
+  @Override
+  public String solveFirstPart(final Stream<String> input) {
+    return solve( input, true );
+  }
+
+  @Override
+  public String solveSecondPart(final Stream<String> input) {
+    return solve( input, false );
+  }
+
+  private String solve(final Stream<String> input, final boolean first) {
+    List<String> lines = input.toList();
+    boolean isExample = lines.size() < INPUT_SIZE;
+    int maxCorruption = isExample ? 12 : 1024;
+    int size = isExample ? EXAMPLE_SIZE : INPUT_SIZE;
+    Point start = new Point( 0, 0 );
+    Point end = new Point( size - 1, size - 1 );
+    Set<Point> corruptedPoints = lines.stream()
+        .limit( maxCorruption - 1 )
+        .map( this::getCorrupted )
+        .collect( toCollection( HashSet::new ) );
+    for ( int i = maxCorruption - 1; i < lines.size(); i++ ) {
+      Point corrupted = getCorrupted( lines.get( i ) );
+      corruptedPoints.add( corrupted );
+      Map<Point, Long> distances = GraphUtils.computeShortestPaths( start, n -> n.equals( end ),
+          (Point n) -> getNeighbours( n, corruptedPoints, size ) );
+      if ( first ) {
+        return itoa( distances.get( end ) );
+      } else if ( !distances.containsKey( end ) ) {
+        return corrupted.i() + "," + corrupted.j();
+      }
+    }
+    throw new IllegalArgumentException();
+  }
+
+  private Point getCorrupted(final String line) {
+    List<Long> numbers = Utils.toLongList( line );
+    return new Point( numbers.get( 0 ).intValue(), numbers.get( 1 ).intValue() );
+  }
+
+  private Collection<Point> getNeighbours(final Point curr, final Set<Point> corruptedPoints,
+      final int size) {
+    return Stream.of( Direction.values() )
+        .map( curr::move )
+        .filter( n -> 0 <= n.i() && n.i() < size && 0 <= n.j() && n.j() < size )
+        .filter( n -> !corruptedPoints.contains( n ) )
+        .toList();
+  }
+}

src/test/java/com/adventofcode/aoc2024/AoC182024Test.java

@@ -0,0 +1,83 @@
+package com.adventofcode.aoc2024;
+
+import static com.adventofcode.AbstractSolutionTest.Type.FIRST;
+import static com.adventofcode.AbstractSolutionTest.Type.SECOND;
+
+import com.adventofcode.AbstractSolutionTest;
+import com.adventofcode.Solution;
+import java.util.List;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class AoC182024Test extends AbstractSolutionTest {
+
+  private static final Solution INSTANCE = new AoC182024();
+
+  public AoC182024Test(final Type type, final String input, final String result) {
+    super( INSTANCE, type, input, result );
+  }
+
+  @Parameters(name = PARAMETERS_MESSAGE)
+  public static Iterable<Object[]> data() {
+    return List.of( new Object[][]{
+        {FIRST, """
+                5,4
+                4,2
+                4,5
+                3,0
+                2,1
+                6,3
+                2,4
+                1,5
+                0,6
+                3,3
+                2,6
+                5,1
+                1,2
+                5,5
+                2,5
+                6,5
+                1,4
+                0,4
+                6,4
+                1,1
+                6,1
+                1,0
+                0,5
+                1,6
+                2,0
+                """, "22"},
+        {FIRST, getInput( INSTANCE ), "268"},
+        {SECOND, """
+                5,4
+                4,2
+                4,5
+                3,0
+                2,1
+                6,3
+                2,4
+                1,5
+                0,6
+                3,3
+                2,6
+                5,1
+                1,2
+                5,5
+                2,5
+                6,5
+                1,4
+                0,4
+                6,4
+                1,1
+                6,1
+                1,0
+                0,5
+                1,6
+                2,0
+                """, "6,1"},
+        {SECOND, getInput( INSTANCE ), "64,11"}
+    } );
+  }
+}