Refactor partA and partB to use a common solve function

Author: akdemironur

13/sol.exs

@@ -13,57 +13,41 @@ defmodule Day13 do
   end
 
   def partA(file_path) do
-    file_path
-    |> read_input()
-    |> Enum.map(&find_mirror(&1, 0))
-    |> Enum.map(&mirror_point/1)
-    |> Enum.sum()
+    solve(file_path, 0)
   end
 
   def partB(file_path) do
+    solve(file_path, 1)
+  end
+
+  def solve(file_path, target) do
     file_path
     |> read_input()
-    |> Enum.map(&find_mirror(&1, 1))
+    |> Enum.map(&find_mirror(&1, target))
     |> Enum.map(&mirror_point/1)
     |> Enum.sum()
   end
 
-  def pairs(mirror_loc, offset), do: {mirror_loc - 1 - offset, mirror_loc + offset}
-  def get_row(arr, row_id), do: arr |> Enum.at(row_id)
-  def get_col(arr, col_id), do: arr |> Enum.map(&Enum.at(&1, col_id)) |> List.flatten()
-
-  def number_of_mismatches_at_offset(pattern, mirror_loc, offset, get_fun) do
-    {p1, p2} = pairs(mirror_loc, offset)
-    slice1 = get_fun.(pattern, p1)
-    slice2 = get_fun.(pattern, p2)
+  def number_of_mismatches_at_offset(pattern, mirror_loc, offset, type) do
+    {p1, p2} = pairs_at_offset(mirror_loc, offset)
+    slice1 = get_f(type).(pattern, p1)
+    slice2 = get_f(type).(pattern, p2)
 
     Enum.zip(slice1, slice2)
     |> Enum.filter(fn {a, b} -> a != b end)
     |> length()
   end
 
   def valid_mirror?(pattern, mirror_loc, type, target) do
-    {get_fun, lim_fun} =
-      case type do
-        :row -> {&get_row/2, &get_col/2}
-        :col -> {&get_col/2, &get_row/2}
-      end
-
-    0..(min(mirror_loc, length(lim_fun.(pattern, 0)) - mirror_loc) - 1)
-    |> Enum.map(&number_of_mismatches_at_offset(pattern, mirror_loc, &1, get_fun))
+    0..(min(mirror_loc, length(lim_f(type).(pattern, 0)) - mirror_loc) - 1)
+    |> Enum.map(&number_of_mismatches_at_offset(pattern, mirror_loc, &1, type))
     |> Enum.sum()
     |> Kernel.==(target)
   end
 
   def find_mirrorH(pattern, type, target) do
-    lim_fun =
-      case type do
-        :row -> &get_col/2
-        :col -> &get_row/2
-      end
-
     Enum.reduce(
-      1..(length(lim_fun.(pattern, 0)) - 1),
+      1..(length(lim_f(type).(pattern, 0)) - 1),
       nil,
       fn mirror_loc, acc ->
         case acc do
@@ -83,6 +67,13 @@ defmodule Day13 do
 
   def mirror_point({:row, x}), do: 100 * x
   def mirror_point({:col, x}), do: x
+  def get_f(:row), do: &get_row/2
+  def get_f(:col), do: &get_col/2
+  def lim_f(:row), do: &get_col/2
+  def lim_f(:col), do: &get_row/2
+  def pairs_at_offset(mirror_loc, offset), do: {mirror_loc - 1 - offset, mirror_loc + offset}
+  def get_row(arr, row_id), do: arr |> Enum.at(row_id)
+  def get_col(arr, col_id), do: arr |> Enum.map(&Enum.at(&1, col_id)) |> List.flatten()
 end
 
 IO.puts(Day13.partA("./input"))