2024 Day 7

2024/day22.exs

@@ -1,5 +1,7 @@
 #!/usr/bin/env elixir
 defmodule Day22 do
+  import Bitwise
+
   def part1(input) do
     Enum.sum_by(input, fn secret ->
       Enum.reduce(1..2000, secret, fn _, secret -> next(secret) end)
@@ -8,14 +10,11 @@ defmodule Day22 do
 
   def next(secret) do
     secret
-    |> then(fn secret -> (secret * 64) |> mix(secret) |> prune() end)
+    |> then(fn secret -> bxor(secret <<< 6, secret) &&& 16_777_21 end)
-    |> then(fn secret -> div(secret, 32) |> mix(secret) |> prune() end)
+    |> then(fn secret -> bxor(secret >>> 5, secret) &&& 16_777_21 end)
-    |> then(fn secret -> (secret * 2048) |> mix(secret) |> prune() end)
+    |> then(fn secret -> bxor(secret <<< 11, secret) &&& 16_777_21 end)
   end
 
-  def mix(num, secret), do: Bitwise.bxor(secret, num)
-  def prune(secret), do: rem(secret, 16_777_216)
-
   def part2(input) do
     input
     |> Enum.map(fn secret ->

2024/day7.exs

@@ -0,0 +1,77 @@
+#!/usr/bin/env elixir
+defmodule Day7 do
+  def part1(input) do
+    Enum.sum_by(input, fn {answer, values} ->
+      if solvable?(answer, values), do: answer, else: 0
+    end)
+  end
+
+  def solvable?(answer, [result]), do: answer == result
+
+  def solvable?(answer, [a, b | rest]) do
+    solvable?(answer, [a * b | rest]) or solvable?(answer, [a + b | rest])
+  end
+
+  def part2(input) do
+    Enum.sum_by(input, fn {answer, values} ->
+      if solvable2?(answer, values), do: answer, else: 0
+    end)
+  end
+
+  def solvable2?(answer, [result]), do: answer == result
+
+  def solvable2?(answer, [a, b | rest]) do
+    solvable2?(answer, [a * b | rest]) or solvable2?(answer, [a + b | rest]) or
+      solvable2?(answer, [String.to_integer("#{a}#{b}") | rest])
+  end
+
+  def input do
+    with [input_filename] <- System.argv(),
+         {:ok, input} <- File.read(input_filename) do
+      input
+      |> String.split("\n", trim: true)
+      |> Enum.map(fn line ->
+        [result | values] =
+          line
+          |> String.split([":", " "], trim: true)
+          |> Enum.map(&String.to_integer/1)
+
+        {result, values}
+      end)
+    else
+      _ -> :error
+    end
+  end
+
+  #######################
+  # HERE BE BOILERPLATE #
+  #######################
+
+  def run do
+    case input() do
+      :error -> print_usage()
+      input -> run_parts_with_timer(input)
+    end
+  end
+
+  defp run_parts_with_timer(input) do
+    run_with_timer(1, fn -> part1(input) end)
+    run_with_timer(2, fn -> part2(input) end)
+  end
+
+  defp run_with_timer(part, fun) do
+    {time, result} = :timer.tc(fun)
+    IO.puts("Part #{part} (completed in #{format_time(time)}):\n")
+    IO.puts("#{inspect(result)}\n")
+  end
+
+  defp format_time(μsec) when μsec < 1_000, do: "#{μsec}μs"
+  defp format_time(μsec) when μsec < 1_000_000, do: "#{μsec / 1000}ms"
+  defp format_time(μsec), do: "#{μsec / 1_000_000}s"
+
+  defp print_usage do
+    IO.puts("Usage: elixir day7.exs input_filename")
+  end
+end
+
+Day7.run()