day07 for AoC 2024 (part 1)

Took 1 hour 28 minutes

Author: albertominetti

src/main/java/aminetti/adventofcode2024/day07/Day07.java

@@ -0,0 +1,108 @@
+package aminetti.adventofcode2024.day07;
+
+import com.google.common.collect.Iterables;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static aminetti.adventofcode2024.day07.Day07.Op.MULT;
+import static com.google.common.collect.Lists.newArrayList;
+
+public class Day07 {
+    private static final Logger LOGGER = LoggerFactory.getLogger(Day07.class);
+    private List<String> input;
+    private final List<Long> results = new ArrayList<>();
+    private final List<List<Long>> components = new ArrayList<>();
+
+    public Day07() {
+    }
+
+    public void parseInput(List<String> input) {
+        this.input = input;
+
+        for (String s : input) {
+            String[] split = s.split(":");
+            results.add(Long.parseLong(split[0]));
+            String[] split1 = split[1].split("\\s+");
+            components.add(Arrays.stream(split1).filter(StringUtils::isNotBlank).map(Long::parseLong).toList());
+        }
+    }
+
+    public long solvePart1() {
+        long sum = 0;
+        for (int i = 0; i < results.size(); i++) {
+            Long result = results.get(i);
+            long count = countOfCorrectOperators(result, components.get(i), List.of(), newArrayList());
+            LOGGER.debug("count for {}: {}", result, count);
+            if (count > 0) {
+                sum += result;
+            }
+        }
+        return sum;
+    }
+
+    public enum Op {
+        SUM, MULT;
+
+        public String print() {
+            return this == SUM ? "+" : "*";
+        }
+    }
+
+
+    private long countOfCorrectOperators(long result, List<Long> longs, List<Op> operators, List<Long> components) {
+        if (longs.size() == 1) {
+            Long lastEl = Iterables.getOnlyElement(longs);
+            if (result == lastEl) {
+
+                String fullOperation = "(".repeat(operators.size()) + lastEl;
+
+                ArrayList<Op> mutableOps = newArrayList(operators);
+                ArrayList<Long> mutableComponents = newArrayList(components);
+                while (!mutableOps.isEmpty()) {
+                    fullOperation += mutableOps.removeLast().print() + "" + mutableComponents.removeLast() + ")";
+                }
+
+                LOGGER.debug("Operation: {}", fullOperation);
+                LOGGER.info("Found correct operators");
+                return 1;
+            }
+
+            return 0;
+
+        }
+
+        if (result <= 0 || longs.isEmpty()) {
+            return 0;
+        }
+
+
+        ArrayList<Op> opsForSum = newArrayList(operators);
+        opsForSum.add(Op.SUM);
+
+        ArrayList<Op> opsForMult = newArrayList(operators);
+        opsForMult.add(MULT);
+
+        ArrayList<Long> next = newArrayList(longs);
+        Long component = next.removeLast();
+
+        ArrayList<Long> nextComponents = newArrayList(components);
+        nextComponents.add(component);
+
+        long sumMult = 0;
+        if (result % component == 0) {
+            sumMult += countOfCorrectOperators(result / component, next, opsForMult, nextComponents);
+        }
+        return sumMult
+                + countOfCorrectOperators(result - component, next, opsForSum, nextComponents);
+    }
+
+    public long solvePart2() {
+
+        return 0;
+    }
+}

src/test/java/aminetti/adventofcode2024/day07/Day07Test.java

@@ -0,0 +1,77 @@
+package aminetti.adventofcode2024.day07;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledIf;
+
+import java.io.IOException;
+import java.util.List;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.apache.commons.io.IOUtils.readLines;
+import static org.apache.commons.io.IOUtils.resourceToString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+class Day07Test {
+
+    @Test @EnabledIf("inputExists")
+    void actualInputPart1() throws IOException {
+        // given
+        List<String> input = readLines(resourceToString("/day07/day07_input.txt", UTF_8));
+
+        // when
+        Day07 solver = new Day07();
+        solver.parseInput(input);
+        long l = solver.solvePart1();
+
+        // then
+        assertThat(l, is(lessThan(15766644995031L)));
+        assertThat(l, is(14711933466277L));
+    }
+
+    @Test
+    void testInputPart1() throws IOException {
+        // given
+        List<String> input = readLines(resourceToString("/day07/day07_input_test.txt", UTF_8));
+
+        // when
+        Day07 solver = new Day07();
+        solver.parseInput(input);
+        long l = solver.solvePart1();
+
+        // then
+        assertThat(l, is(3749L));
+    }
+
+    @Test @EnabledIf("inputExists")
+    void actualInputPart2() throws IOException {
+        // given
+        List<String> input = readLines(resourceToString("/day07/day07_input.txt", UTF_8));
+
+        // when
+        Day07 solver = new Day07();
+        solver.parseInput(input);
+        long l = solver.solvePart2();
+
+        // then
+        assertThat(l, is(0L));
+    }
+
+    @Test
+    void testInputPart2() throws IOException {
+        // given
+        List<String> input = readLines(resourceToString("/day07/day07_input_test.txt", UTF_8));
+
+        // when
+        Day07 solver = new Day07();
+        solver.parseInput(input);
+        long l = solver.solvePart2();
+
+        // then
+        assertThat(l, is(0L));
+    }
+
+    public static boolean inputExists() {
+        return Day07Test.class.getResource("/day07/day07_input.txt") != null;
+    }
+}

src/test/resources/day07/day07_input_test.txt

@@ -0,0 +1,9 @@
+190: 10 19
+3267: 81 40 27
+83: 17 5
+156: 15 6
+7290: 6 8 6 15
+161011: 16 10 13
+192: 17 8 14
+21037: 9 7 18 13
+292: 11 6 16 20