mix format

lib/day1.ex

@@ -1,11 +1,14 @@
 defmodule Day1 do
   def get_answer(state) do
     {_, total, part} = state
-    total |>
+
-      then(fn total -> case part do 
+    total
+    |> then(fn total ->
+      case part do
         :part1 -> total
         :part2 -> total |> Enum.reduce(0, fn i, acc -> i + acc end)
-      end end)
+      end
+    end)
   end
 
   def init_state(part) do
@@ -18,7 +21,8 @@ defmodule Day1 do
   def execute(line, state) do
     apply_command(
       line |> to_command(),
-      state)
+      state
+    )
   end
 
   defp apply_command(command, state) do
@@ -38,19 +42,27 @@ defmodule Day1 do
 
   defp apply_add(n, state) do
     {current, total, part} = state
-    new_current = n + if is_nil(current) do 0 else current end
+
+    new_current =
+      n +
+        if is_nil(current) do
+          0
+        else
+          current
+        end
 
     {new_current, total, part}
   end
 
   defp take_top_three(n, list) do
-    [ n | list ] |>
+    [n | list]
-      Enum.sort(:desc) |>
+    |> Enum.sort(:desc)
-      Enum.take(3)
+    |> Enum.take(3)
   end
 
   defp apply_reset(state) do
     {current, total, part} = state
+
     if !is_nil(current) do
       case part do
         :part1 -> {nil, max(total, current), part}
@@ -61,4 +73,3 @@ defmodule Day1 do
     end
   end
 end
-

lib/day10.ex

@@ -4,11 +4,11 @@ defmodule Day10 do
   @behaviour Solution
 
   def init_state(p) when p == :part1 do
-    %{ vm: VirtualMachine.new(), acc: 0, p: p }
+    %{vm: VirtualMachine.new(), acc: 0, p: p}
   end
 
   def init_state(p) when p == :part2 do
-    %{ vm: VirtualMachine.new(), crt: "", p: p}
+    %{vm: VirtualMachine.new(), crt: "", p: p}
   end
 
   def execute(line, state) when line == "" do
@@ -16,42 +16,48 @@ defmodule Day10 do
   end
 
   def execute(line, state) when state.p == :part1 do
-    VirtualMachine.plan_execute(line) |>
+    VirtualMachine.plan_execute(line)
-    Enum.reduce(
+    |> Enum.reduce(
       state,
-      fn (tock, %{vm: vm, acc: acc}) ->
+      fn tock, %{vm: vm, acc: acc} ->
         next_tick = vm.tick + 1
-        acc = if (next_tick - 20 |> mod(40)) === 0, do: acc + (next_tick) * vm.x, else: acc
+        acc = if (next_tick - 20) |> mod(40) === 0, do: acc + next_tick * vm.x, else: acc
         vm = tock.(vm)
-        %{ vm: vm, acc: acc}
+        %{vm: vm, acc: acc}
       end
-    ) |> Map.put(:p, state.p)
+    )
+    |> Map.put(:p, state.p)
   end
 
   def execute(line, state) when state.p == :part2 do
-    VirtualMachine.plan_execute(line) |>
+    VirtualMachine.plan_execute(line)
-    Enum.reduce(
+    |> Enum.reduce(
       state,
-      fn (tock, %{vm: vm, crt: crt}) ->
+      fn tock, %{vm: vm, crt: crt} ->
         next_tick = vm.tick + 1
 
-        char = case mod(vm.tick, 40) do
+        char =
-          x when x >= (vm.x - 1) and x <= (vm.x + 1) -> "#"
+          case mod(vm.tick, 40) do
+            x when x >= vm.x - 1 and x <= vm.x + 1 -> "#"
             _ -> "."
           end
 
         crt = crt <> char
 
-        crt = crt <> if mod(next_tick, 40) == 0 do
+        crt =
+          crt <>
+            if mod(next_tick, 40) == 0 do
               "\n"
-        else ""
+            else
+              ""
             end
 
         vm = tock.(vm)
 
-        %{ vm: vm, crt: crt}
+        %{vm: vm, crt: crt}
       end
-    ) |> Map.put(:p, state.p)
+    )
+    |> Map.put(:p, state.p)
   end
 
   def get_answer(state) when state.p == :part1 do
@@ -65,11 +71,12 @@ end
 
 defmodule VirtualMachine do
   def new() do
-    %{ x: 1, tick: 0 }
+    %{x: 1, tick: 0}
   end
 
   def plan_execute(instruction) do
-    [instruction, args] = if instruction == "noop" do 
+    [instruction, args] =
+      if instruction == "noop" do
         [instruction, nil]
       else
         String.split(instruction, " ")
@@ -79,25 +86,27 @@ defmodule VirtualMachine do
   end
 
   def plan_execute(instruction, args) when instruction == "addx" do
-    args = case Integer.parse(args) do
+    args =
+      case Integer.parse(args) do
         {args, _} -> args
         :error -> 0
       end
+
     if is_integer(args) do
       plan_execute("noop", nil) ++
         [
-        fn (vm) -> 
+          fn vm ->
-          vm |> 
+            vm
-            Map.update(:tick, 2, &(&1 + 1)) |>
+            |> Map.update(:tick, 2, &(&1 + 1))
-            Map.update(:x, args, &(&1 + args))
+            |> Map.update(:x, args, &(&1 + args))
           end
         ]
-    else []
+    else
+      []
     end
   end
 
   def plan_execute(instruction, _) when instruction == "noop" do
-    [fn (vm) -> Map.update(vm, :tick, 1, &(&1 + 1)) end]
+    [fn vm -> Map.update(vm, :tick, 1, &(&1 + 1)) end]
   end
 end
-

lib/day2.ex

@@ -8,7 +8,7 @@ defmodule Day2 do
   end
 
   def execute(line, state) do
-    if line |> String.trim() |> String.length == 0 do
+    if line |> String.trim() |> String.length() == 0 do
       state
     else
       {_, player, outcome} = parse_moves(line, state.part)
@@ -17,7 +17,8 @@ defmodule Day2 do
         state.score +
           points_for_move(player) +
           points_from_outcome(outcome),
-        state.part)
+        state.part
+      )
     end
   end
 
@@ -48,15 +49,20 @@ defmodule Day2 do
       opposing_move
     else
       case opposing_move do
-        :rock -> case outcome do
+        :rock ->
+          case outcome do
             :win -> :paper
             :loss -> :scissors
           end
-        :paper -> case outcome do
+
+        :paper ->
+          case outcome do
             :win -> :scissors
             :loss -> :rock
           end
-        :scissors -> case outcome do
+
+        :scissors ->
+          case outcome do
             :win -> :rock
             :loss -> :paper
           end
@@ -64,15 +70,17 @@ defmodule Day2 do
     end
   end
 
-  
   defp parse_move(move, side) do
     case side do
-      :left -> case move do
+      :left ->
+        case move do
           "A" -> :rock
           "B" -> :paper
           "C" -> :scissors
         end
-      :right -> case move do
+
+      :right ->
+        case move do
           "X" -> :rock
           "Y" -> :paper
           "Z" -> :scissors
@@ -93,15 +101,20 @@ defmodule Day2 do
       0
     else
       case a do
-        :rock -> case b do
+        :rock ->
+          case b do
             :paper -> -1
             :scissors -> 1
           end
-        :paper -> case b do
+
+        :paper ->
+          case b do
             :rock -> 1
             :scissors -> -1
           end
-        :scissors -> case b do
+
+        :scissors ->
+          case b do
             :rock -> -1
             :paper -> 1
           end
@@ -111,6 +124,7 @@ defmodule Day2 do
 
   defp outcome?(match) when is_tuple(match) and tuple_size(match) == 2 do
     {opponent, player} = match
+
     case sort_(player, opponent) do
       1 -> :win
       0 -> :draw

lib/day3.ex

@@ -4,16 +4,24 @@ defmodule Day3 do
   end
 
   defp find_duplicates(line) do
-    line |>
+    line
-      String.to_charlist() |>
+    |> String.to_charlist()
-      Enum.chunk_every(Integer.floor_div(String.length(line), 2)) |>
+    |> Enum.chunk_every(Integer.floor_div(String.length(line), 2))
-      Enum.map(&MapSet.new/1) |>
+    |> Enum.map(&MapSet.new/1)
-      then(fn [a,b] -> MapSet.intersection(a,b) end) |>
+    |> then(fn [a, b] -> MapSet.intersection(a, b) end)
-      MapSet.to_list()
+    |> MapSet.to_list()
   end
 
   defp to_priority(c) do
-    if is_nil(c) do 0 else if c < 97 do c - 38 else c - 96 end end
+    if is_nil(c) do
+      0
+    else
+      if c < 97 do
+        c - 38
+      else
+        c - 96
+      end
+    end
   end
 
   def execute(line, state) do
@@ -22,11 +30,11 @@ defmodule Day3 do
     trimmed = line |> String.trim()
 
     unless String.length(trimmed) == 0 do
-      trimmed |>
+      trimmed
-        find_duplicates() |>
+      |> find_duplicates()
-        Enum.map(&to_priority(&1)) |>
+      |> Enum.map(&to_priority(&1))
-        Enum.reduce(&(&1 + &2)) |>
+      |> Enum.reduce(&(&1 + &2))
-        increment_sum.()
+      |> increment_sum.()
     else
       state
     end
@@ -36,4 +44,3 @@ defmodule Day3 do
     state.sum
   end
 end
-

lib/day9.ex

@@ -1,10 +1,11 @@
 defmodule Day9 do
   def init_state(p) when p == :part1 do
-    { [ {0,0}, {0,0} ], MapSet.new() }
+    {[{0, 0}, {0, 0}], MapSet.new()}
   end
 
   def init_state(p) when p == :part2 do
-    { [ {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}], MapSet.new() }
+    {[{0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}],
+     MapSet.new()}
   end
 
   def execute(line, state) when line == "" do
@@ -12,29 +13,32 @@ defmodule Day9 do
   end
 
   def execute(line, state) do
-    [ movement, count] = line |> String.split(" ");
+    [movement, count] = line |> String.split(" ")
-    { count, _ } = Integer.parse(count);
+    {count, _} = Integer.parse(count)
 
     Enum.reduce(
       1..count,
       state,
-      fn (_, state) -> 
+      fn _, state ->
-        { rope, tail_positions } = state
+        {rope, tail_positions} = state
-        rope = movement 
+
+        rope =
+          movement
           |> string_to_movement_direction()
           |> move_rope_by_head(rope)
-        { rope, MapSet.put(tail_positions, List.last(rope)) }
+
+        {rope, MapSet.put(tail_positions, List.last(rope))}
       end
-    );  
+    )
   end
 
   def get_answer(state) do
-    {_, tail_positions } = state
+    {_, tail_positions} = state
     MapSet.size(tail_positions)
   end
 
   defp move_rope_by_head(direction, rope) do
-    [head | tail ] = rope
+    [head | tail] = rope
     reconcile_tail([add_2_tuple(head, direction)], tail)
   end
 
@@ -44,7 +48,7 @@ defmodule Day9 do
 
   defp reconcile_tail(head, tail) do
     leader = head |> List.last()
-    [ follower | tail ] = tail
+    [follower | tail] = tail
 
     reconcile_tail(head ++ [keep_min_distance(follower, leader, 1)], tail)
   end
@@ -83,16 +87,15 @@ defmodule Day9 do
   end
 
   defp add_2_tuple(x, y) do
-    { elem(x,0) + elem(y,0), elem(x,1) + elem(y,1) }
+    {elem(x, 0) + elem(y, 0), elem(x, 1) + elem(y, 1)}
   end
 
   defp distance_vector(x, y) do
-    { elem(y,0) - elem(x,0), elem(y,1) - elem(x,1) }
+    {elem(y, 0) - elem(x, 0), elem(y, 1) - elem(x, 1)}
   end
 
   defp max_coord_difference(x, y) do
-    {a, b} = { abs(elem(x,0)-elem(y,0)), abs(elem(x,1)-elem(y,1)) }
+    {a, b} = {abs(elem(x, 0) - elem(y, 0)), abs(elem(x, 1) - elem(y, 1))}
     max(a, b)
   end
 end
-