format elixir code

23/elixir/lib/days/day7.ex

@@ -45,28 +45,34 @@ defmodule AOC.Day7 do
   end
 
   def best_joker_replacement(hand) do
-    freqs = Enum.frequencies(hand)
+    freqs =
+      Enum.frequencies(hand)
       |> Enum.reject(fn {card, _count} -> card == ?J end)
 
     cond do
       Enum.any?(freqs, fn {_card, count} -> count == 4 end) ->
         {card, _} = Enum.find(freqs, fn {_card, count} -> count == 4 end)
         card
+
       Enum.any?(freqs, fn {_card, count} -> count == 3 end) ->
         {card, _} = Enum.find(freqs, fn {_card, count} -> count == 3 end)
         card
+
       Enum.any?(freqs, fn {_card, count} -> count == 2 end) ->
         doubles = Enum.filter(freqs, fn {_card, count} -> count == 2 end)
+
         if length(doubles) == 1 do
           hd(doubles) |> elem(0)
         else
           [{double1, _}, {double2, _}] = doubles
+
           if Map.fetch!(@card_to_power, double1) >= Map.fetch!(@card_to_power, double2) do
             double1
           else
             double2
           end
         end
+
       true ->
         freqs
         |> Enum.map(fn {card, _count} -> card end)
@@ -82,8 +88,12 @@ defmodule AOC.Day7 do
     joker_count = Map.get(freqs, ?J, 0)
 
     case joker_count do
-      0 -> hand
+      0 ->
-      5 -> 'AAAAA'
+        hand
+
+      5 ->
+        ~c"AAAAA"
+
       _ ->
         joker_replacement = best_joker_replacement(hand)
 
@@ -92,7 +102,8 @@ defmodule AOC.Day7 do
   end
 
   def hand_to_type(hand, joker_rule) do
-    freqs = hand
+    freqs =
+      hand
       |> String.to_charlist()
       |> then(fn hand ->
         if joker_rule do
@@ -109,7 +120,7 @@ defmodule AOC.Day7 do
       Enum.member?(freqs, 4) -> :four_of_a_kind
       Enum.member?(freqs, 3) and Enum.member?(freqs, 2) -> :full_house
       Enum.member?(freqs, 3) -> :three_of_a_kind
-      Enum.count(freqs, & &1==2) == 2 -> :two_pair
+      Enum.count(freqs, &(&1 == 2)) == 2 -> :two_pair
       Enum.member?(freqs, 2) -> :one_pair
       true -> :high_card
     end

23/elixir/lib/days/day8.ex

@@ -9,8 +9,14 @@ defmodule AOC.Day8 do
 
   def parse_input([instructions, _ | nodes]) do
     instructions = instructions |> String.to_charlist() |> Stream.cycle()
-    nodes = Enum.map(nodes, fn s ->
+
-      %{"id" => id, "left" => left, "right" => right} = Regex.named_captures(~r/^(?<id>[[:alnum:]]{3}) = \((?<left>[[:alnum:]]{3}), (?<right>[[:alnum:]]{3})\)$/, s)
+    nodes =
+      Enum.map(nodes, fn s ->
+        %{"id" => id, "left" => left, "right" => right} =
+          Regex.named_captures(
+            ~r/^(?<id>[[:alnum:]]{3}) = \((?<left>[[:alnum:]]{3}), (?<right>[[:alnum:]]{3})\)$/,
+            s
+          )
 
         {id, {left, right}}
       end)
@@ -25,7 +31,9 @@ defmodule AOC.Day8 do
         {:halt, step_count}
       else
         {left, right} = Map.fetch!(nodes, current_node)
-        next_node = case instruction do
+
+        next_node =
+          case instruction do
             ?L -> left
             ?R -> right
           end
@@ -40,13 +48,18 @@ defmodule AOC.Day8 do
   end
 
   def find_cycle(instructions, nodes, start) do
-    Enum.reduce_while(instructions, {start, 0, nil}, fn instruction, {current_node, step_count, last_end_count}->
+    Enum.reduce_while(instructions, {start, 0, nil}, fn instruction,
+                                                        {current_node, step_count, last_end_count} ->
       if String.ends_with?(current_node, "Z") and last_end_count != nil do
         {:halt, {last_end_count, step_count - last_end_count}}
       else
-        last_end_count = if String.ends_with?(current_node, "Z"), do: step_count, else: last_end_count
+        last_end_count =
+          if String.ends_with?(current_node, "Z"), do: step_count, else: last_end_count
+
         {left, right} = Map.fetch!(nodes, current_node)
-        next_node = case instruction do
+
+        next_node =
+          case instruction do
             ?L -> left
             ?R -> right
           end
@@ -57,7 +70,8 @@ defmodule AOC.Day8 do
   end
 
   def brute_force_find_cycle(cycles) do
-    Stream.repeatedly(fn -> nil end) |> Enum.reduce_while(cycles, fn _, cycles ->
+    Stream.repeatedly(fn -> nil end)
+    |> Enum.reduce_while(cycles, fn _, cycles ->
       all_ended = cycles |> Enum.map(&elem(&1, 0)) |> Enum.uniq() |> length() == 1
 
       if all_ended do
@@ -72,6 +86,7 @@ defmodule AOC.Day8 do
 
   def part2({instructions, nodes}) do
     IO.puts("Use LCM for the following numbers :)")
+
     Enum.filter(nodes, fn {k, _v} -> String.ends_with?(k, "A") end)
     |> Enum.map(fn {k, _v} -> find_cycle(instructions, nodes, k) end)
     |> Enum.map(&elem(&1, 0))