day02 for AoC 2023 (refactoring)

Took 10 minutes

Author: albertominetti

src/main/java/aminetti/adventofcode2024/day02/Day02.java

@@ -10,19 +10,14 @@
 
 public class Day02 {
     private static final Logger LOGGER = LoggerFactory.getLogger(Day02.class);
-    private List<String> input;
+    private List<List<Long>> allLists;
 
     public Day02() {
     }
 
     public void parseInput(List<String> input) {
-        this.input = input;
-    }
-
-    public long solvePart1() {
         Pattern p = Pattern.compile("(\\d+)");
-
-        List<List<Long>> allLists = new ArrayList<>(input.size());
+        allLists = new ArrayList<>(input.size());
 
         for (String s : input) {
             Matcher matcher = p.matcher(s);
@@ -36,16 +31,16 @@ public long solvePart1() {
 
             allLists.add(list);
         }
+    }
 
+    public long solvePart1() {
         return allLists.stream()
                 .filter(this::isSafe)
                 .count();
-
     }
 
     private boolean isSafe(List<Long> l) {
-
-        LOGGER.info("Checking {}", l);
+        LOGGER.debug("Checking {}", l);
         Long prev = null;
         Boolean ascending = null;
         for (Long i : l) {
@@ -54,68 +49,52 @@ private boolean isSafe(List<Long> l) {
                 continue;
             }
 
-            if (prev == i) {
-                LOGGER.info(" has 2 same values {}", i);
+            if (prev.compareTo(i) == 0) {
+                LOGGER.debug(" has 2 same values {}", i);
                 return false;
             }
 
             if (ascending == null) {
-                ascending = prev < i;
-                LOGGER.info(" is {}", ascending ? "ascending" : "descending");
+                ascending = prev.compareTo(i) < 0;
+                LOGGER.debug(" is {}", ascending ? "ascending" : "descending");
             } else {
 
-                if (ascending && prev >= i) {
-                    LOGGER.info(" started as ascending, but is not!");
+                if (ascending && prev.compareTo(i) > 0) {
+                    LOGGER.debug(" started as ascending, but is not!");
                     return false;
                 }
-                if (!ascending && prev <= i) {
-                    LOGGER.info(" started as descending, but is not!");
+                if (!ascending && prev.compareTo(i) < 0) {
+                    LOGGER.debug(" started as descending, but is not!");
                     return false;
                 }
             }
 
-            if (Math.abs(prev - i) > 3 && Math.abs(prev - i) > 0) {
-                LOGGER.info(" has too big gap between {} and {}", prev, i);
+            long absDiff = Math.abs(prev - i);
+            if (absDiff > 3) {
+                LOGGER.debug(" has too big gap between {} and {}", prev, i);
                 return false;
             }
 
             prev = i;
         }
 
-        LOGGER.info(" is safe");
+        LOGGER.debug(" is safe");
         return true;
     }
 
     public long solvePart2() {
-        Pattern p = Pattern.compile("(\\d+)");
-
-        List<List<Long>> allLists = new ArrayList<>(input.size());
-
-        for (String s : input) {
-            Matcher matcher = p.matcher(s);
-            List<Long> list = new ArrayList<>();
-
-            while (matcher.find()) {
-                Long a = Long.valueOf(matcher.group(1));
-                LOGGER.debug("Reading: {}", a);
-                list.add(a);
-            }
-
-            allLists.add(list);
-        }
-
         return allLists.stream()
                 .filter(this::isSafeWithoutOneLevel)
                 .count();
     }
 
     private boolean isSafeWithoutOneLevel(List<Long> l) {
-        List<List<Long>> possibleCombinations = new ArrayList<>();
+        List<List<Long>> orderedSelectionWithOneElement = new ArrayList<>(l.size());
         for (int i = 0; i < l.size(); i++) {
             List<Long> l1 = new ArrayList<>(l);
             l1.remove(i);
-            possibleCombinations.add(l1);
+            orderedSelectionWithOneElement.add(l1);
         }
-        return possibleCombinations.stream().anyMatch(this::isSafe);
+        return orderedSelectionWithOneElement.stream().anyMatch(this::isSafe);
     }
 }