redo day 1 (...then make it beautiful)

Author: maco

elixir/2024/lib/advent_of_code/day_01.ex

@@ -2,24 +2,17 @@ defmodule AdventOfCode.Day01 do
   import AdventOfCode.Parsing
 
   def part1(input) do
-    [list1, list2] =
-      input
-      |> parse_columns_ints()
-      |> Enum.map(fn list -> Enum.sort(list) end)
-
-    Enum.zip_with(list1, list2, fn first, second -> abs(first - second) end)
+    input
+    |> parse_columns_ints
+    |> Enum.map(&Enum.sort/1)
+    |> Enum.zip_with(fn [num1, num2] -> abs(num1 - num2) end)
     |> Enum.sum()
   end
 
   def part2(input) do
-    [list1, list2] =
-      input
-      |> parse_columns_ints()
-
-    list2_freqs = Enum.frequencies(list2)
+    [list1, list2] = parse_columns_ints(input)
+    freqs = Enum.frequencies(list2)
 
-    Enum.reduce(list1, 0, fn num, acc ->
-      acc + num * Map.get(list2_freqs, num, 0)
-    end)
+    Enum.reduce(list1, 0, fn val, acc -> val * Map.get(freqs, val, 0) + acc end)
   end
 end

elixir/2024/lib/advent_of_code/parsing.ex

@@ -1,24 +1,15 @@
 defmodule AdventOfCode.Parsing do
   def parse_columns_ints(input) do
+    input
+    |> parse_rows_ints
+    # transpose matrix
+    |> Enum.zip_with(&Function.identity/1)
+  end
+
+  def parse_rows_ints(input) do
     input
     |> String.trim()
     |> String.split("\n")
-    |> Enum.reduce(
-      [],
-      fn
-        line, [] ->
-          # first time through, set up acc
-          String.split(line)
-          |> Enum.map(fn val -> [String.to_integer(val)] end)
-
-        line, accs ->
-          values = String.split(line)
-
-          Enum.zip_with(values, accs, fn val, acc ->
-            [String.to_integer(val) | acc]
-          end)
-      end
-    )
-    |> Enum.map(fn list -> Enum.reverse(list) end)
+    |> Enum.map(fn row -> row |> String.split() |> Enum.map(&String.to_integer/1) end)
   end
 end

elixir/2024/test/advent_of_code/parsing_test.exs

@@ -3,7 +3,7 @@ defmodule AdventOfCode.Day01Test do
 
   import AdventOfCode.Parsing
 
-  test "two columns" do
+  test "two columns of ints" do
     input = """
     1   2
     3   4
@@ -15,7 +15,7 @@ defmodule AdventOfCode.Day01Test do
     assert expected == parse_columns_ints(input)
   end
 
-  test "three columns" do
+  test "three columns of ints" do
     input = """
     1   2   6
     3   4   7
@@ -26,4 +26,26 @@ defmodule AdventOfCode.Day01Test do
 
     assert expected == parse_columns_ints(input)
   end
+
+  test "rows of ints" do
+    input = """
+    7 6 4 2 1
+    1 2 7 8 9
+    9 7 6 2 1
+    1 3 2 4 5
+    8 6 4 4 1
+    1 3 6 7 9
+    """
+
+    expected = [
+      [7, 6, 4, 2, 1],
+      [1, 2, 7, 8, 9],
+      [9, 7, 6, 2, 1],
+      [1, 3, 2, 4, 5],
+      [8, 6, 4, 4, 1],
+      [1, 3, 6, 7, 9]
+    ]
+
+    assert expected == parse_rows_ints(input)
+  end
 end

python/solutions/2024/day_01/solution.py

@@ -4,41 +4,25 @@
 
 from ...base import StrSplitSolution, answer
 from ...utils.parsing import parse_column_ints
-
+from collections import Counter
 
 class Solution(StrSplitSolution):
     _year = 2024
     _day = 1
 
     @answer(2264607)
     def part_1(self) -> int:
-        [list1, list2] = parse_column_ints(self.input)
-        total: int = 0
-
-        list1.sort()
-        list2.sort()
-
-        for (first, second) in zip(list1, list2):
-            total = total + abs(first - second)
-
+        locations = map(sorted, parse_column_ints(self.input))
+        total = 0
+        for val1, val2 in zip(*locations):
+            total += abs(val1 - val2)
         return total
 
-    # @answer(1234)
+    @answer(19457120)
     def part_2(self) -> int:
         [list1, list2] = parse_column_ints(self.input)
-        total: int = 0
-
-        list2_freqs = {}
-        for num in list2:
-            if num in list2_freqs:
-                list2_freqs[num] += 1
-            else:
-                list2_freqs[num] = 1
-
-        for num in list1:
-            total += num * list2_freqs.get(num, 0)
+        freqs = Counter(list2)
+        total = 0
+        for val in list1:
+            total += val * freqs.get(val, 0)
         return total
-
-    # @answer((1234, 4567))
-    # def solve(self) -> tuple[int, int]:
-    #     pass

python/solutions/utils/parsing.py

@@ -1,16 +1,10 @@
-# add whatever utilities you'll find useful across multiple solutions
-# import them in a solution using:
-# from ...utils.example import add
-
-
 def parse_column_ints(input: list[str]):
-    columns: list[int] = []
-
-    for line_num, line in enumerate(input):
-        fields = line.split()
-        for index, field in enumerate(fields):
-            if line_num == 0:
-                columns.append([int(field)])
+    result = []
+    for row_num, row in enumerate(input):
+        values = map(int, row.split())
+        for col_num, val in enumerate(values):
+            if row_num == 0:
+                result.append([val])
             else:
-                columns[index].append(int(field))
-    return columns
+                result[col_num].append(val)
+    return result