[Year 2024 Day 22 Part 2] ok

Author: Viinyard

solutions/src/main/java/dev/vinyard/adventofcode/soluce/year2023/day22/ASD.java

@@ -7,8 +7,11 @@
 import org.apache.commons.geometry.euclidean.threed.Bounds3D;
 import org.apache.commons.geometry.euclidean.threed.Vector3D;
 
+import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 public class ASD {
 
@@ -24,6 +27,15 @@ public long fall() {
             bricks.forEach(Brick::fall);
             return bricks.stream().filter(b -> b.getFallingOnBricks().isEmpty()).count();
         }
+
+        public Long part2() {
+            bricks.forEach(Brick::fall);
+            return bricks.stream().mapToLong(b -> {
+                Set<Brick> brickSet = new HashSet<>();
+                brickSet.add(b);
+                return b.getAllFallingOnBricks(brickSet).size();
+            }).sum();
+        }
     }
 
     // Classe proxy pour Brick avec cache Caffeine
@@ -101,6 +113,14 @@ public List<Brick> getFallingOnBricks() {
                     .toList();
         }
 
+        public Set<Brick> getAllFallingOnBricks(Set<Brick> bricks) {
+            Set<Brick> supportingBricks = new HashSet<>(getSupportingBricks());
+            Set<Brick> fallingOnBricks = supportingBricks.stream().filter(s -> bricks.containsAll(s.getSupportedByBricks())).collect(Collectors.toSet());
+            bricks.addAll(fallingOnBricks);
+            fallingOnBricks.addAll(fallingOnBricks.stream().map(b -> b.getAllFallingOnBricks(bricks)).flatMap(Set::stream).collect(Collectors.toSet()));
+            return fallingOnBricks;
+        }
+
         public Brick(Bounds3D bounds, LinkedList<Brick> bricks) {
             this.bounds = bounds;
             this.bricks = bricks;

solutions/src/main/java/dev/vinyard/adventofcode/soluce/year2023/day22/Day22Part2Solution.java

@@ -0,0 +1,36 @@
+package dev.vinyard.adventofcode.soluce.year2023.day22;
+
+import dev.vinyard.aoc.plugins.solution.api.Solution;
+import dev.vinyard.aoc.plugins.solution.api.annotation.AdventOfCodeSolution;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+
+@AdventOfCodeSolution(year = 2023, day = 22, part = 2, description = "Sand Slabs", link = "https://adventofcode.com/2023/day/22", tags = "unsolved")
+public class Day22Part2Solution implements Solution<Long> {
+
+    /**
+    * <h2>--- Part Two ---</h2>
+    * <p>Disintegrating bricks one at a time isn't going to be fast enough. While it might sound dangerous, what you really need is a <b>chain reaction</b>.</p>
+    * <p>You'll need to figure out the best brick to disintegrate. For each brick, determine how many <b>other bricks would fall</b> if that brick were disintegrated.</p>
+    * <p>Using the same example as above:</p>
+    * <ul>
+    *  <li>Disintegrating brick A would cause all <b>6</b> other bricks to fall.</li>
+    *  <li>Disintegrating brick F would cause only <b>1</b> other brick, G, to fall.</li>
+    * </ul>
+    * <p>Disintegrating any other brick would cause <b>no other bricks</b> to fall. So, in this example, the sum of <b>the number of other bricks that would fall</b> as a result of disintegrating each brick is <b>7</b>.</p>
+    * <p>For each brick, determine how many <b>other bricks</b> would fall if that brick were disintegrated. <b>What is the sum of the number of other bricks that would fall?</b></p>
+    */
+    @Override
+    public Long solve(String input) {
+        CharStream charStream = CharStreams.fromString(input);
+
+        SolutionLexer lexer = new SolutionLexer(charStream);
+        CommonTokenStream tokens = new CommonTokenStream(lexer);
+        SolutionParser parser = new SolutionParser(tokens);
+
+        ASD.Root root = parser.root().out;
+
+        return root.part2();
+    }
+}

solutions/src/test/java/dev/vinyard/adventofcode/soluce/year2023/day22/Day22Part1SolutionTest.java

@@ -16,7 +16,7 @@ public Solution<Long> getSolution() {
     @Override
     public Stream<Arguments> testSolution() {
         return Stream.of(
-            Arguments.of("soluce/year2023/day22/part1/test.txt", 5L, null, null),
+            Arguments.of("soluce/year2023/day22/test.txt", 5L, null, null),
             Arguments.of("soluce/year2023/day22/input.txt", 443L, null, null)
         );
     }

solutions/src/test/java/dev/vinyard/adventofcode/soluce/year2023/day22/Day22Part2SolutionTest.java

@@ -0,0 +1,23 @@
+package dev.vinyard.adventofcode.soluce.year2023.day22;
+
+import dev.vinyard.adventofcode.common.BaseTest;
+import dev.vinyard.aoc.plugins.solution.api.Solution;
+import org.junit.jupiter.params.provider.Arguments;
+
+import java.util.stream.Stream;
+
+public class Day22Part2SolutionTest extends BaseTest<Long> {
+
+    @Override
+    public Solution<Long> getSolution() {
+        return new Day22Part2Solution();
+    }
+
+    @Override
+    public Stream<Arguments> testSolution() {
+        return Stream.of(
+            Arguments.of("soluce/year2023/day22/test.txt", 7L, null, null),
+            Arguments.of("soluce/year2023/day22/input.txt", 69915L, null, null)
+        );
+    }
+}