Compare commits

..

2 commits

Author SHA1 Message Date
Adam Millerchip 7f9e61c347 Update readme image 2022-12-12 22:57:40 +09:00
Adam Millerchip f80444d913 2022 Day 11 part 1 2022-12-12 22:34:44 +09:00
2 changed files with 189 additions and 1 deletions

View file

@ -2,7 +2,7 @@
My (attempted) solutions to [Advent of Code 2022](https://adventofcode.com/2022) in Elixir.
<img width="869" alt="image" src="https://user-images.githubusercontent.com/498229/206862407-902d0162-93b1-46c6-8bf1-1e7ec7e7f819.png">
<img width="869" alt="image" src="https://user-images.githubusercontent.com/498229/207063420-9e176055-d40c-4b33-a826-368c04a7b75d.png">
## Running:

188
2022/day11.exs Normal file
View file

@ -0,0 +1,188 @@
defmodule Monkey do
use GenServer
defstruct [
:num,
:items_caught,
:operation,
:divisor,
:true_monkey,
:false_monkey,
:inspected_count
]
# Server
#########
def init(%Monkey{} = monkey) do
{:ok, {monkey, _monkeys = %{}}}
end
def handle_cast({:catch, item}, {monkey, monkies}) do
monkey = catch_item(monkey, item)
{:noreply, {monkey, monkies}}
end
def handle_call({:register, monkies}, _from, {monkey, _monkies}) do
{:reply, :ok, {monkey, monkies}}
end
def handle_call(:turn, _from, {monkey, monkies}) do
monkey = do_business(monkey, monkies)
{:reply, :done, {%Monkey{monkey | items_caught: []}, monkies}}
end
def handle_call(:get_count, _from, {monkey, monkies}) do
{:reply, monkey.inspected_count, {monkey, monkies}}
end
# Client
#########
def throw(monkey, item), do: GenServer.cast(monkey, {:catch, item})
def register(monkey, monkeys), do: GenServer.call(monkey, {:register, monkeys})
def take_turn(monkey), do: GenServer.call(monkey, :turn)
def report_count(monkey), do: GenServer.call(monkey, :get_count)
# Monkey business
##################
defp catch_item(monkey, item), do: %Monkey{monkey | items_caught: [item | monkey.items_caught]}
defp do_business(monkey, monkies) do
count =
for item <- Enum.reverse(monkey.items_caught), reduce: 0 do
count ->
item = monkey.operation.(item) |> div(3)
to_monkey =
if rem(item, monkey.divisor) == 0 do
monkey.true_monkey
else
monkey.false_monkey
end
throw(monkies[to_monkey], item)
count + 1
end
%Monkey{monkey | items_caught: [], inspected_count: monkey.inspected_count + count}
end
end
defmodule Day11 do
def part1(input) do
monkies = setup_monkies(input)
order = monkies |> Map.keys() |> Enum.sort()
run_rounds(20, monkies, order)
order
|> Enum.map(&Monkey.report_count(monkies[&1]))
|> Enum.sort(:desc)
|> Enum.take(2)
|> Enum.reduce(&Kernel.*/2)
end
def setup_monkies(input) do
monkies =
input
|> Enum.with_index()
|> Map.new(fn {monkey, idx} ->
{:ok, pid} = GenServer.start_link(Monkey, monkey)
{idx, pid}
end)
Enum.each(monkies, fn {_k, monkey} -> Monkey.register(monkey, monkies) end)
monkies
end
defp run_rounds(0, _monkies, _order), do: :ok
defp run_rounds(rounds, monkies, order) do
Enum.each(order, &Monkey.take_turn(monkies[&1]))
run_rounds(rounds - 1, monkies, order)
end
def part2(_input) do
:ok
end
def input do
with [input_filename] <- System.argv(),
{:ok, input} <- File.read(input_filename) do
input
|> String.split("\n\n")
|> Enum.map(fn monkey ->
[
<<"Monkey ", monkey_num::binary-1, ":">>,
"Starting items: " <> starting_items,
<<"Operation: new = old ", op::binary-1, " ", operand::binary>>,
"Test: divisible by " <> divisor,
"If true: throw to monkey " <> true_monkey,
"If false: throw to monkey " <> false_monkey
] = monkey |> String.trim() |> String.split("\n") |> Enum.map(&String.trim/1)
starting_items = String.split(starting_items, ", ")
[monkey_num, divisor, true_monkey, false_monkey | starting_items] =
Enum.map(
[monkey_num, divisor, true_monkey, false_monkey] ++ starting_items,
&String.to_integer/1
)
operation =
case {op, operand} do
{"+", "old"} -> fn old -> old + old end
{"*", "old"} -> fn old -> old * old end
{"+", operand} -> fn old -> old + String.to_integer(operand) end
{"*", operand} -> fn old -> old * String.to_integer(operand) end
end
%Monkey{
num: monkey_num,
items_caught: Enum.reverse(starting_items),
operation: operation,
divisor: divisor,
true_monkey: true_monkey,
false_monkey: false_monkey,
inspected_count: 0
}
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("#{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 day11.exs input_filename")
end
end
# Day11.run()