day 7 part 2

Author: maco

elixir/2024/lib/advent_of_code/day_07.ex

@@ -9,22 +9,31 @@ defmodule AdventOfCode.Day07 do
     |> Enum.reduce(0, fn [test, _], acc -> acc + test end)
   end
 
-  def part2(_args) do
+  def part2(input) do
+    data = parse(input)
+
+    Enum.filter(data, fn [test, nums] ->
+      possible = possible_results(Enum.reverse(nums), [&Kernel.+/2, &Kernel.*/2, &concatenate/2])
+      test in possible
+    end)
+    |> Enum.reduce(0, fn [test, _], acc -> acc + test end)
+  end
+
+  defp concatenate(x, y) do
+    Enum.join(Integer.digits(y) ++ Integer.digits(x)) |> String.to_integer()
   end
 
-  def possible_results([x], _), do: [x]
+  defp possible_results([x], _), do: [x]
 
-  def possible_results([head | tail], operators) do
+  defp possible_results([head | tail], operators) do
     subresults = possible_results(tail, operators)
 
     Enum.flat_map(subresults, fn sub ->
-      Enum.map(operators, fn op ->
-        op.(head, sub)
-      end)
+      Enum.map(operators, fn op -> op.(head, sub) end)
     end)
   end
 
-  def parse(input) do
+  defp parse(input) do
     input
     |> String.split("\n", trim: true)
     |> Enum.map(fn line ->

elixir/2024/test/advent_of_code/day_07_test.exs

@@ -15,14 +15,25 @@ defmodule AdventOfCode.Day07Test do
     21037: 9 7 18 13
     292: 11 6 16 20
     """
+
     3749 = part1(input)
   end
 
-  @tag :skip
   test "part2" do
-    input = nil
-    result = part2(input)
-
-    assert result
+    input = """
+    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
+    """
+    # input = "156: 15 6"
+    # result = part2(input)
+    # assert result == 156
+    11387 = part2(input)
   end
 end

python/solutions/2024/day_07/solution.py

@@ -12,21 +12,36 @@ class Solution(StrSplitSolution):
     _day = 7
 
     # @answer((1234, 4567))
-    def solve(self) -> tuple[int, int]:
+    def part_1(self) -> int:
+        lines = self._parse()
+
+        return sum(
+            line[0]
+            for line in lines
+            if line[0] in self._possible_results(line[1], [operator.add, operator.mul])
+        )
+
+    def part_2(self) -> int:
+        lines = self._parse()
+
+        return sum(
+            line[0]
+            for line in lines
+            if line[0] in self._possible_results(line[1], [operator.add, operator.mul, self._concatenate])
+        )
+
+    def _parse(self):
         lines = []
         for line in self.input:
             [test, num_str] = line.split(":")
             nums = []
-            for index, num in enumerate(num_str.split()):
+            for num in num_str.split():
                 nums.append(int(num))
             lines.append((int(test), nums))
+        return lines
 
-        total = sum(
-            line[0]
-            for line in lines
-            if line[0] in self._possible_results(line[1], [operator.add, operator.mul])
-        )
-        return (total, 0)
+    def _concatenate(self, x: int, y: int) -> int:
+        return int(str(x) + str(y))
 
     def _possible_results(self, nums: list[int], ops: list[Callable]) -> list[int]:
         current = nums.pop()
@@ -35,7 +50,7 @@ def _possible_results(self, nums: list[int], ops: list[Callable]) -> list[int]:
             new_results = []
             for sub in subresults:
                 for op in ops:
-                    new_results.append(op(current, sub))
+                    new_results.append(op(sub, current))
             return new_results
         else:
             return [current]