day14

Author: akdemironur

14/sample_input

@@ -0,0 +1,10 @@
+O....#....
+O.OO#....#
+.....##...
+OO.#O....O
+.O.....O#.
+O.#..O.#.#
+..O..#O..O
+.......O..
+#....###..
+#OO..#....

14/sol.exs

@@ -0,0 +1,82 @@
+defmodule Day14 do
+  def read_input(file_path) do
+    case File.read(file_path) do
+      {:ok, content} ->
+        content
+        |> String.split("\n", trim: true)
+        |> Enum.map(&String.graphemes/1)
+
+      {:error, reason} ->
+        raise "Oh no! #{reason}"
+    end
+  end
+
+  def partA(file_path) do
+    file_path
+    |> read_input()
+    |> tilt_and_rotate()
+    |> calc_all_loads()
+  end
+
+  def partB(file_path) do
+    file_path
+    |> read_input()
+    |> tilt_n_cycle(1_000_000_000)
+    |> rotate()
+    |> calc_all_loads()
+  end
+
+  def tilt_insert(x, []), do: [x]
+  def tilt_insert("O", ["." | t]), do: ["." | tilt_insert("O", t)]
+  def tilt_insert("O", ["#" | t]), do: ["O" | ["#" | t]]
+  def tilt_insert(x, t), do: [x | t]
+
+  def tilt(l) do
+    Enum.reduce(l, [], fn x, acc -> tilt_insert(x, acc) end)
+  end
+
+  def tilt_and_rotate(ll), do: tilt_and_rotate(ll, [])
+  def tilt_and_rotate([[] | _], acc), do: acc
+
+  def tilt_and_rotate(l, acc) do
+    heads = l |> Enum.map(&hd/1)
+    tails = l |> Enum.map(&tl/1)
+    tilt_and_rotate(tails, acc ++ [tilt(heads)])
+  end
+
+  def rotate(l), do: rotate(l, [])
+
+  def rotate([[] | _], acc), do: acc
+
+  def rotate(l, acc) do
+    heads = l |> Enum.map(&hd/1)
+    tails = l |> Enum.map(&tl/1)
+    rotate(tails, acc ++ [Enum.reverse(heads)])
+  end
+
+  def calc_load([], _, acc), do: acc
+  def calc_load(["O" | t], i, acc), do: calc_load(t, i + 1, acc + i)
+  def calc_load([_ | t], i, acc), do: calc_load(t, i + 1, acc)
+  def calc_load(l), do: calc_load(l, 1, 0)
+  def calc_all_loads(ll), do: Enum.map(ll, &calc_load/1) |> Enum.sum()
+
+  def tilt_1_cycle(ll) do
+    ll |> tilt_and_rotate() |> tilt_and_rotate() |> tilt_and_rotate() |> tilt_and_rotate()
+  end
+
+  def tilt_n_cycle(ll, n), do: tilt_n_cycle(ll, n, %{n: n})
+  def tilt_n_cycle(ll, 0, _), do: ll
+
+  def tilt_n_cycle(ll, m, memo) do
+    new_m =
+      case is_map_key(memo, ll) do
+        true -> Integer.mod(m, memo[ll] - m) - 1
+        false -> m - 1
+      end
+
+    tilt_n_cycle(ll |> tilt_1_cycle(), new_m, Map.put(memo, ll, m))
+  end
+end
+
+IO.puts(Day14.partA("./input"))
+IO.puts(Day14.partB("./input"))