feat: day 12 new idea wip

Author: Flashky

src/main/java/com/adventofcode/flashk/day12/GardenGroups.java

@@ -5,6 +5,7 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 
 public class GardenGroups {
@@ -15,6 +16,7 @@ public class GardenGroups {
     private final Map<Integer, Integer> regionAreas = new HashMap<>();
     private final Map<Integer, Integer> regionSides = new HashMap<>();
     private final Map<Integer, Set<GardenPlot>> regionPlots = new HashMap<>();
+    private GardenPlot noPlot;
 
     public GardenGroups(char[][] inputs) {
 
@@ -28,6 +30,9 @@ public GardenGroups(char[][] inputs) {
             }
         }
 
+        noPlot = new GardenPlot('.', new Vector2(-1,-1));
+        noPlot.setRegionId(-1);
+
     }
 
     public long solveA() {
@@ -55,73 +60,156 @@ public long solveB() {
 
         // Posibles casos eje: la primera celda y la última de cada fila/columna, ¿cuántos lados hay que contar?
 
-        countHorizontalSides(); // TODO descomentar
+        countHorizontalSides();
         countVerticalSides();
+
+        return calculatePriceB();
+    }
+
+    private int calculatePriceB() {
+        int price = 0;
+        for(Map.Entry<Integer,Integer> regionArea : regionAreas.entrySet()) {
+            System.out.println("Region: " + regionArea.getKey() + " - Area: " + regionArea.getValue() + " - Sides: "+ regionSides.get(regionArea.getKey()));
+            price += regionArea.getValue() * regionSides.get(regionArea.getKey());
+        }
+
         return price;
     }
 
     private void countHorizontalSides() {
-        GardenPlot[] previousRow = null;
-       
+
         for(int row = 0; row < rows; row++) {
-            GardenPlot leftPlot = null;
             for(int col = 0; col < cols; col++) {
 
-                GardenPlot plot = map[row][col];
-
-                if(leftPlot != null && leftPlot.getRegionId() == plot.getRegionId()) {
-                    // Left is same region
-                    continue;
-                }
+                GardenPlot currentPlot = map[row][col];
+                GardenPlot leftPlot = getLeftPlot(row, col).orElse(noPlot());
 
-                GardenPlot topPlot = previousRow != null ? previousRow[col] : null;
+                // Search horizontal sides up
+                GardenPlot topPlot =  getUpPlot(row, col).orElse(noPlot());
+                GardenPlot topLeftPlot = getUpLeftPlot(row,col).orElse(noPlot());
 
-                if(topPlot != null && topPlot.getRegionId() == plot.getRegionId()) {
-                    // Top is same region
-                    continue;
+                if(checkAdjacents(leftPlot, topPlot, currentPlot)
+                        || checkAdjacentsAndDiagonal(leftPlot, topPlot, topLeftPlot, currentPlot)) {
+                    addSides(currentPlot);
                 }
 
-                int sides = regionSides.getOrDefault(plot.getRegionId(),0);
-                regionSides.put(plot.getRegionId(), sides+1);
+                // Search horizontal sides down
+                GardenPlot downPlot = getDownPlot(row,col).orElse(noPlot());
+                GardenPlot downLeftPlot = getDownLeftPlot(row, col).orElse(noPlot);
 
-                leftPlot = plot;
+                if(checkAdjacents(leftPlot, downPlot, currentPlot) ||
+                checkAdjacentsAndDiagonal(leftPlot, downPlot, downLeftPlot, currentPlot))  {
+                    addSides(currentPlot);
+                }
             }
-            previousRow = map[row];
         }
     }
 
+    private boolean checkAdjacents(GardenPlot left, GardenPlot topDown, GardenPlot current) {
 
-    private void countVerticalSides() {
+        // Cases:
+        // XX    AX
+        // XA<   XA<
 
-        GardenPlot[] previousCol = null;
+        // XA<  XA<
+        // XX   AX
 
-        for(int col = 0; col < cols; col++) {
-            GardenPlot topPlot = null;
-            GardenPlot[] currentCol = new GardenPlot[cols];
+        return (left.getRegionId() != current.getRegionId() && topDown.getRegionId() != current.getRegionId());
+    }
 
-            for(int row = 0; row < rows; row++) {
+    private boolean checkAdjacentsAndDiagonal(GardenPlot left, GardenPlot topDown, GardenPlot diagonal, GardenPlot current) {
 
-                GardenPlot plot = map[row][col];
-                currentCol[row] = plot;
+        // Cases:
 
-                if(topPlot != null && topPlot.getRegionId() == plot.getRegionId()) {
-                    // Top is same region
-                    continue;
-                }
+        // AX
+        //  -
+        // AA <
+
+        // AA<
+        //  -
+        // AX
+
+        return (left.getRegionId() == current.getRegionId() &&
+                topDown.getRegionId() != current.getRegionId() &&
+                diagonal.getRegionId() == current.getRegionId());
+    }
 
-                GardenPlot leftPlot = previousCol != null ? previousCol[row] : null;
+    private boolean checkAdjacentsAndDiagonalV(GardenPlot top, GardenPlot left, GardenPlot upLeft, GardenPlot current) {
+        // Cases:
+
+        // A A
+        // X|A <
+
+        return top.getRegionId() == current.getRegionId() &&
+                left.getRegionId() != current.getRegionId() &&
+                upLeft.getRegionId() == current.getRegionId();
+
+    }
+
+    private void addSides(GardenPlot gardenPlot) {
+        int sides = regionSides.getOrDefault(gardenPlot.getRegionId(),0);
+        regionSides.put(gardenPlot.getRegionId(), sides+1);
+    }
 
-                if(leftPlot != null && leftPlot.getRegionId() == plot.getRegionId()) {
-                    // Top is same region
-                    continue;
+    private GardenPlot noPlot() {
+        return noPlot;
+    }
+
+    private Optional<GardenPlot> getLeftPlot(int row, int col) {
+        return (col > 0) ? Optional.of(map[row][col-1]) : Optional.empty();
+    }
+
+    private Optional<GardenPlot> getRightPlot(int row, int col) {
+        return (col+1 < cols) ? Optional.of(map[row][col+1]) : Optional.empty();
+    }
+
+    private Optional<GardenPlot> getUpPlot(int row, int col) {
+        return (row > 0) ? Optional.of(map[row-1][col]) : Optional.empty();
+    }
+
+    private Optional<GardenPlot> getDownPlot(int row, int col) {
+        return (row+1 < rows) ? Optional.of(map[row+1][col]) : Optional.empty();
+    }
+
+    private Optional<GardenPlot> getUpLeftPlot(int row, int col) {
+        return (row > 0 && col > 0) ? Optional.of(map[row-1][col-1]) : Optional.empty();
+    }
+
+    private Optional<GardenPlot> getUpRightPlot(int row, int col) {
+        return (row > 0 && col+1 < cols) ? Optional.of(map[row-1][col+1]) : Optional.empty();
+    }
+
+    private Optional<GardenPlot> getDownLeftPlot(int row, int col) {
+        return (row+1 < rows && col > 0) ? Optional.of(map[row+1][col-1]) : Optional.empty();
+    }
+
+
+    private void countVerticalSides() {
+
+        for(int col = 0; col < cols; col++) {
+            for(int row = 0; row < rows; row++) {
+
+                GardenPlot currentPlot = map[row][col];
+                GardenPlot topPlot =  getUpPlot(row, col).orElse(noPlot());
+
+                // Search vertical sides right
+                GardenPlot rightPlot = getRightPlot(row, col).orElse(noPlot());
+                GardenPlot topRightPlot = getUpRightPlot(row,col).orElse(noPlot());
+
+                if(checkAdjacents(rightPlot, topPlot, currentPlot)
+                        || checkAdjacentsAndDiagonal(rightPlot, topPlot, topRightPlot, currentPlot)) {
+                    addSides(currentPlot);
                 }
 
-                int sides = regionSides.getOrDefault(plot.getRegionId(),0);
-                regionSides.put(plot.getRegionId(), sides+1);
+                // Search vertical sides left
+                GardenPlot leftPlot = getLeftPlot(row,col).orElse(noPlot());
+                GardenPlot topLeftPlot = getUpLeftPlot(row, col).orElse(noPlot);
 
-                topPlot = plot;
+                if(checkAdjacents(leftPlot, topPlot, currentPlot) ||
+                        checkAdjacentsAndDiagonalV(topPlot, leftPlot, topLeftPlot, currentPlot))  {
+                    addSides(currentPlot);
+                }
             }
-            previousCol = currentCol;
         }
     }
 

src/test/java/com/adventofcode/flashk/day12/Day12Test.java

@@ -67,6 +67,10 @@ public void testSolvePart2Sample() {
 		GardenGroups gardenGroups = new GardenGroups(inputs);
 
 		assertEquals(1206L,gardenGroups.solveB());
+
+		// Falla en:
+		// Region C-3 (22, y sale 21 sides)
+		// Región V-5 (10 y sale 9 sides)
 	}
 
 	@Test
@@ -197,6 +201,7 @@ public void testSolvePart2Input() {
 
 		// 875718 -> Too high
 		// 871792 -> Too high (tras ajustar lógica para los convexos internos.
+		// 868050 -> Too low (con el nuevo algoritmo
 		assertEquals(0L,0L);
 
 	}