this repo has no description

ft: add day 23 and 24

2021/day1.livemd 2021/day01.livemd
2021/day1.txt 2021/day01.txt
+19 -6
2021/day19.livemd
···
length(input)
```
-
```output
34
```
···
{a_2}_d & 1
\end{vmatrix}
} = \frac{{a_1}_d {b_2}_d - {b_1}_d {a_2}_d}{{a_1}_d - {a_2}_d}
```elixir
defmodule Day19 do
···
end
```
-
```output
{:module, Day19, <<70, 79, 82, 49, 0, 0, 26, ...>>, {:pairs, 1}}
```
···
{length(joinable), length(later)}
```
-
```output
{3, 30}
```
···
MapSet.size(points_set)
```
-
```output
0.002822
1: {5, 25}
0.017052
···
0.071942
```
-
```output
396
```
···
|> Enum.max()
```
-
```output
11828
```
···
length(input)
```
+
<!-- livebook:{"output":true} -->
+
+
```
34
```
···
{a_2}_d & 1
\end{vmatrix}
} = \frac{{a_1}_d {b_2}_d - {b_1}_d {a_2}_d}{{a_1}_d - {a_2}_d}
+
$$
```elixir
defmodule Day19 do
···
end
```
+
<!-- livebook:{"output":true} -->
+
+
```
{:module, Day19, <<70, 79, 82, 49, 0, 0, 26, ...>>, {:pairs, 1}}
```
···
{length(joinable), length(later)}
```
+
<!-- livebook:{"output":true} -->
+
+
```
{3, 30}
```
···
MapSet.size(points_set)
```
+
<!-- livebook:{"output":true} -->
+
+
```
0.002822
1: {5, 25}
0.017052
···
0.071942
```
+
<!-- livebook:{"output":true} -->
+
+
```
396
```
···
|> Enum.max()
```
+
<!-- livebook:{"output":true} -->
+
+
```
11828
```
2021/day2.livemd 2021/day02.livemd
2021/day2.txt 2021/day02.txt
+149
2021/day23.livemd
···
···
+
<!-- vim:ft=markdown -->
+
+
<!-- livebook:{"persist_outputs":true} -->
+
+
# Day 23
+
+
## Section
+
+
```elixir
+
input =
+
File.stream!("day23.txt")
+
|> Enum.map(fn line ->
+
for <<c <- line>>, c in 'ABCD', do: String.to_atom(<<c + 32>>)
+
end)
+
|> Enum.reject(&(&1 == []))
+
|> Enum.zip()
+
|> Enum.map(&Tuple.to_list/1)
+
|> Enum.zip_with(~w[a b c d]a, &{&2, &1})
+
|> Map.new()
+
```
+
+
```output
+
%{a: [:d, :b], b: [:d, :a], c: [:c, :b], d: [:c, :a]}
+
```
+
+
Graph of the possible movements. `--` and `|` have multiply 1 and `---`, `\`, and `/` have
+
multiply 2.
+
+
```
+
.--.---.---.---.---.--.
+
\ / \ / \ / \ /
+
. . . .
+
| | | |
+
. . . .
+
```
+
+
```elixir
+
defmodule Day23 do
+
@costs %{a: 1, b: 10, c: 100, d: 1000}
+
@rooms %{a: -3, b: -1, c: 1, d: 3}
+
+
# - - - - - + + + + +
+
# 5 4 3 2 1 0 1 2 3 4 5
+
# A B C D
+
# A B C D
+
+
defp memoize(tid, args, func) do
+
case :ets.lookup(tid, args) do
+
[{^args, value}] ->
+
value
+
+
[] ->
+
value = func.()
+
:ets.insert(tid, {args, value})
+
value
+
end
+
end
+
+
def process(stacks) do
+
tid = :ets.new(:memoize, [:public, :set])
+
depth = length(stacks[:a])
+
+
try do
+
do_process(stacks, %{}, target(depth), depth, tid)
+
after
+
:ets.delete(tid)
+
end
+
end
+
+
defp do_process(target, _, target, _depth, _tid), do: 0
+
+
defp do_process(stacks, hall, target, depth, tid) do
+
memoize(tid, [stacks, hall], fn ->
+
possible_moves(stacks, hall, depth)
+
|> Enum.map(fn {new_stack, new_hall, cost} ->
+
cost + do_process(new_stack, new_hall, target, depth, tid)
+
end)
+
|> Enum.min(&<=/2, fn -> :inf end)
+
end)
+
end
+
+
defp possible_moves(stacks, hall, depth) do
+
hall_to_room(stacks, hall, depth) ++ room_to_hall(stacks, hall, depth)
+
end
+
+
defp hall_to_room(stacks, hall, depth) do
+
# IO.inspect({stacks, hall, depth}, label: elem(__ENV__.function, 0))
+
for {pos, t} <- hall,
+
clear_path_to_room?(t, pos, hall),
+
accepts?(t, stacks),
+
{size, new_stacks} = into_room(t, stacks),
+
do: {new_stacks, Map.delete(hall, pos), cost(t, pos, @rooms[t], depth - size)}
+
end
+
+
defp room_to_hall(stacks, hall, depth) do
+
[]
+
end
+
+
defp clear_path_to_room?(t, pos, hall) do
+
hall
+
|> Map.keys()
+
|> Enum.find(&(&1 in min(pos, @rooms[t])..max(pos, @rooms[t])))
+
|> case do
+
nil -> true
+
_ -> false
+
end
+
end
+
+
defp accepts?(t, stacks), do: Enum.all?(stacks[t], &(&1 == t))
+
+
defp into_room(t, stacks) do
+
Map.get_and_update!(stacks, t, &{length(&1), [t | &1]})
+
end
+
+
defp target(depth) do
+
for v <- ~w[a b c d]a,
+
into: %{},
+
do: {v, List.duplicate(v, depth)}
+
end
+
+
def cost(elem, from, to, depth) do
+
@costs[elem] * (depth + abs(to - from))
+
end
+
end
+
```
+
+
```output
+
warning: variable "depth" is unused (if the variable is not meant to be used, prefix it with an underscore)
+
day23.livemd#cell:58: Day23.room_to_hall/3
+
+
warning: variable "hall" is unused (if the variable is not meant to be used, prefix it with an underscore)
+
day23.livemd#cell:58: Day23.room_to_hall/3
+
+
warning: variable "stacks" is unused (if the variable is not meant to be used, prefix it with an underscore)
+
day23.livemd#cell:58: Day23.room_to_hall/3
+
+
```
+
+
```output
+
{:module, Day23, <<70, 79, 82, 49, 0, 0, 23, ...>>, {:cost, 4}}
+
```
+
+
```elixir
+
Day23.process(input)
+
```
+
+
```output
+
:inf
+
```
+5
2021/day23.txt
···
···
+
#############
+
#...........#
+
###D#D#C#C###
+
#B#A#B#A#
+
#########
+351
2021/day24.livemd
···
···
+
<!-- livebook:{"persist_outputs":true} -->
+
+
# Day 24
+
+
## Section
+
+
```elixir
+
defmodule Day24 do
+
def parse("inp " <> reg), do: {:inp, String.to_atom(reg)}
+
+
def parse(<<op::binary-size(3)>> <> " " <> <<reg>> <> " " <> arg) do
+
{String.to_atom(op), String.to_atom(<<reg>>), parse_arg(arg)}
+
end
+
+
defp parse_arg(arg) do
+
case Integer.parse(arg) do
+
{num, ""} -> num
+
:error -> String.to_atom(arg)
+
end
+
end
+
+
def evaluate(ops, input), do: evaluate(ops, Integer.digits(input), %{w: 0, x: 0, y: 0, z: 0})
+
+
defp evaluate([], _, regs), do: regs
+
+
defp evaluate([:nop | rest], input, regs), do: evaluate(rest, input, regs)
+
+
defp evaluate([{:inp, reg} | rest], [v | input], regs),
+
do: evaluate(rest, input, %{regs | reg => v})
+
+
defp evaluate([{:eql, reg, v} | rest], input, regs) do
+
val = if get(reg, regs) == get(v, regs), do: 1, else: 0
+
+
evaluate(rest, input, %{regs | reg => val})
+
end
+
+
defp evaluate([{:add, reg, v} | rest], input, regs),
+
do: evaluate(rest, input, %{regs | reg => get(reg, regs) + get(v, regs)})
+
+
defp evaluate([{:mul, reg, v} | rest], input, regs),
+
do: evaluate(rest, input, %{regs | reg => get(reg, regs) * get(v, regs)})
+
+
defp evaluate([{:div, reg, v} | rest], input, regs),
+
do: evaluate(rest, input, %{regs | reg => div(get(reg, regs), get(v, regs))})
+
+
defp evaluate([{:mod, reg, v} | rest], input, regs),
+
do: evaluate(rest, input, %{regs | reg => rem(get(reg, regs), get(v, regs))})
+
+
defp get(imm, _regs) when is_integer(imm), do: imm
+
defp get(reg, regs) when is_atom(reg), do: Map.get(regs, reg, 0)
+
end
+
+
input =
+
File.stream!("day24.txt")
+
|> Stream.map(&String.trim/1)
+
|> Enum.map(&Day24.parse/1)
+
|> IO.inspect(limit: :infinity)
+
+
length(input)
+
```
+
+
<!-- livebook:{"output":true} -->
+
+
```
+
[
+
{:inp, :w},
+
{:mul, :x, 0},
+
{:add, :x, :z},
+
{:mod, :x, 26},
+
{:div, :z, 1},
+
{:add, :x, 11},
+
{:eql, :x, :w},
+
{:eql, :x, 0},
+
{:mul, :y, 0},
+
{:add, :y, 25},
+
{:mul, :y, :x},
+
{:add, :y, 1},
+
{:mul, :z, :y},
+
{:mul, :y, 0},
+
{:add, :y, :w},
+
{:add, :y, 16},
+
{:mul, :y, :x},
+
{:add, :z, :y},
+
{:inp, :w},
+
{:mul, :x, 0},
+
{:add, :x, :z},
+
{:mod, :x, 26},
+
{:div, :z, 1},
+
{:add, :x, 12},
+
{:eql, :x, :w},
+
{:eql, :x, 0},
+
{:mul, :y, 0},
+
{:add, :y, 25},
+
{:mul, :y, :x},
+
{:add, :y, 1},
+
{:mul, :z, :y},
+
{:mul, :y, 0},
+
{:add, :y, :w},
+
{:add, :y, 11},
+
{:mul, :y, :x},
+
{:add, :z, :y},
+
{:inp, :w},
+
{:mul, :x, 0},
+
{:add, :x, :z},
+
{:mod, :x, 26},
+
{:div, :z, 1},
+
{:add, :x, 13},
+
{:eql, :x, :w},
+
{:eql, :x, 0},
+
{:mul, :y, 0},
+
{:add, :y, 25},
+
{:mul, :y, :x},
+
{:add, :y, 1},
+
{:mul, :z, :y},
+
{:mul, :y, 0},
+
{:add, :y, :w},
+
{:add, :y, 12},
+
{:mul, :y, :x},
+
{:add, :z, :y},
+
{:inp, :w},
+
{:mul, :x, 0},
+
{:add, :x, :z},
+
{:mod, :x, 26},
+
{:div, :z, 26},
+
{:add, :x, -5},
+
{:eql, :x, :w},
+
{:eql, :x, 0},
+
{:mul, :y, 0},
+
{:add, :y, 25},
+
{:mul, :y, :x},
+
{:add, :y, 1},
+
{:mul, :z, :y},
+
{:mul, :y, 0},
+
{:add, :y, :w},
+
{:add, :y, 12},
+
{:mul, :y, :x},
+
{:add, :z, :y},
+
{:inp, :w},
+
{:mul, :x, 0},
+
{:add, :x, :z},
+
{:mod, :x, 26},
+
{:div, :z, 26},
+
{:add, :x, -3},
+
{:eql, :x, :w},
+
{:eql, :x, 0},
+
{:mul, :y, 0},
+
{:add, :y, 25},
+
{:mul, :y, :x},
+
{:add, :y, 1},
+
{:mul, :z, :y},
+
{:mul, :y, 0},
+
{:add, :y, :w},
+
{:add, :y, 12},
+
{:mul, :y, :x},
+
{:add, :z, :y},
+
{:inp, :w},
+
{:mul, :x, 0},
+
{:add, :x, :z},
+
{:mod, :x, 26},
+
{:div, :z, 1},
+
{:add, :x, 14},
+
{:eql, :x, :w},
+
{:eql, :x, 0},
+
{:mul, :y, 0},
+
{:add, :y, 25},
+
{:mul, :y, :x},
+
{:add, :y, 1},
+
{:mul, :z, :y},
+
{:mul, :y, 0},
+
{:add, :y, :w},
+
{:add, :y, 2},
+
{:mul, :y, :x},
+
{:add, :z, :y},
+
{:inp, :w},
+
{:mul, :x, 0},
+
{:add, :x, :z},
+
{:mod, :x, 26},
+
{:div, :z, 1},
+
{:add, :x, 15},
+
{:eql, :x, :w},
+
{:eql, :x, 0},
+
{:mul, :y, 0},
+
{:add, :y, 25},
+
{:mul, :y, :x},
+
{:add, :y, 1},
+
{:mul, :z, :y},
+
{:mul, :y, 0},
+
{:add, :y, :w},
+
{:add, :y, 11},
+
{:mul, :y, :x},
+
{:add, :z, :y},
+
{:inp, :w},
+
{:mul, :x, 0},
+
{:add, :x, :z},
+
{:mod, :x, 26},
+
{:div, :z, 26},
+
{:add, :x, -16},
+
{:eql, :x, :w},
+
{:eql, :x, 0},
+
{:mul, :y, 0},
+
{:add, :y, 25},
+
{:mul, :y, :x},
+
{:add, :y, 1},
+
{:mul, :z, :y},
+
{:mul, :y, 0},
+
{:add, :y, :w},
+
{:add, :y, 4},
+
{:mul, :y, :x},
+
{:add, :z, :y},
+
{:inp, :w},
+
{:mul, :x, 0},
+
{:add, :x, :z},
+
{:mod, :x, 26},
+
{:div, :z, 1},
+
{:add, :x, 14},
+
{:eql, :x, :w},
+
{:eql, :x, 0},
+
{:mul, :y, 0},
+
{:add, :y, 25},
+
{:mul, :y, :x},
+
{:add, :y, 1},
+
{:mul, :z, :y},
+
{:mul, :y, 0},
+
{:add, :y, :w},
+
{:add, :y, 12},
+
{:mul, :y, :x},
+
{:add, :z, :y},
+
{:inp, :w},
+
{:mul, :x, 0},
+
{:add, :x, :z},
+
{:mod, :x, 26},
+
{:div, :z, 1},
+
{:add, :x, 15},
+
{:eql, :x, :w},
+
{:eql, :x, 0},
+
{:mul, :y, 0},
+
{:add, :y, 25},
+
{:mul, :y, :x},
+
{:add, :y, 1},
+
{:mul, :z, :y},
+
{:mul, :y, 0},
+
{:add, :y, :w},
+
{:add, :y, 9},
+
{:mul, :y, :x},
+
{:add, :z, :y},
+
{:inp, :w},
+
{:mul, :x, 0},
+
{:add, :x, :z},
+
{:mod, :x, 26},
+
{:div, :z, 26},
+
{:add, :x, -7},
+
{:eql, :x, :w},
+
{:eql, :x, 0},
+
{:mul, :y, 0},
+
{:add, :y, 25},
+
{:mul, :y, :x},
+
{:add, :y, 1},
+
{:mul, :z, :y},
+
{:mul, :y, 0},
+
{:add, :y, :w},
+
{:add, :y, 10},
+
{:mul, :y, :x},
+
{:add, :z, :y},
+
{:inp, :w},
+
{:mul, :x, 0},
+
{:add, :x, :z},
+
{:mod, :x, 26},
+
{:div, :z, 26},
+
{:add, :x, -11},
+
{:eql, :x, :w},
+
{:eql, :x, 0},
+
{:mul, :y, 0},
+
{:add, :y, 25},
+
{:mul, :y, :x},
+
{:add, :y, 1},
+
{:mul, :z, :y},
+
{:mul, :y, 0},
+
{:add, :y, :w},
+
{:add, :y, 11},
+
{:mul, :y, :x},
+
{:add, :z, :y},
+
{:inp, :w},
+
{:mul, :x, 0},
+
{:add, :x, :z},
+
{:mod, :x, 26},
+
{:div, :z, 26},
+
{:add, :x, -6},
+
{:eql, :x, :w},
+
{:eql, :x, 0},
+
{:mul, :y, 0},
+
{:add, :y, 25},
+
{:mul, :y, :x},
+
{:add, :y, 1},
+
{:mul, :z, :y},
+
{:mul, :y, 0},
+
{:add, :y, :w},
+
{:add, :y, 6},
+
{:mul, :y, :x},
+
{:add, :z, :y},
+
{:inp, :w},
+
{:mul, :x, 0},
+
{:add, :x, :z},
+
{:mod, :x, 26},
+
{:div, :z, 26},
+
{:add, :x, -11},
+
{:eql, :x, :w},
+
{:eql, :x, 0},
+
{:mul, :y, 0},
+
{:add, :y, 25},
+
{:mul, :y, :x},
+
{:add, :y, 1},
+
{:mul, :z, :y},
+
{:mul, :y, 0},
+
{:add, :y, :w},
+
{:add, :y, 15},
+
{:mul, :y, :x},
+
{:add, :z, :y}
+
]
+
```
+
+
<!-- livebook:{"output":true} -->
+
+
```
+
252
+
```
+
+
```elixir
+
44..52 |> Enum.map(&rem(&1, 26))
+
```
+
+
<!-- livebook:{"output":true} -->
+
+
```
+
[18, 19, 20, 21, 22, 23, 24, 25, 0]
+
```
+
+
```elixir
+
IO.inspect(Day24.evaluate(input, 11_111_111_111_161))
+
```
+
+
<!-- livebook:{"output":true} -->
+
+
```
+
%{w: 1, x: 1, y: 16, z: 207697766}
+
```
+
+
<!-- livebook:{"output":true} -->
+
+
```
+
%{w: 1, x: 1, y: 16, z: 207697766}
+
```
+252
2021/day24.txt
···
···
+
inp w
+
mul x 0
+
add x z
+
mod x 26
+
div z 1
+
add x 11
+
eql x w
+
eql x 0
+
mul y 0
+
add y 25
+
mul y x
+
add y 1
+
mul z y
+
mul y 0
+
add y w
+
add y 16
+
mul y x
+
add z y
+
inp w
+
mul x 0
+
add x z
+
mod x 26
+
div z 1
+
add x 12
+
eql x w
+
eql x 0
+
mul y 0
+
add y 25
+
mul y x
+
add y 1
+
mul z y
+
mul y 0
+
add y w
+
add y 11
+
mul y x
+
add z y
+
inp w
+
mul x 0
+
add x z
+
mod x 26
+
div z 1
+
add x 13
+
eql x w
+
eql x 0
+
mul y 0
+
add y 25
+
mul y x
+
add y 1
+
mul z y
+
mul y 0
+
add y w
+
add y 12
+
mul y x
+
add z y
+
inp w
+
mul x 0
+
add x z
+
mod x 26
+
div z 26
+
add x -5
+
eql x w
+
eql x 0
+
mul y 0
+
add y 25
+
mul y x
+
add y 1
+
mul z y
+
mul y 0
+
add y w
+
add y 12
+
mul y x
+
add z y
+
inp w
+
mul x 0
+
add x z
+
mod x 26
+
div z 26
+
add x -3
+
eql x w
+
eql x 0
+
mul y 0
+
add y 25
+
mul y x
+
add y 1
+
mul z y
+
mul y 0
+
add y w
+
add y 12
+
mul y x
+
add z y
+
inp w
+
mul x 0
+
add x z
+
mod x 26
+
div z 1
+
add x 14
+
eql x w
+
eql x 0
+
mul y 0
+
add y 25
+
mul y x
+
add y 1
+
mul z y
+
mul y 0
+
add y w
+
add y 2
+
mul y x
+
add z y
+
inp w
+
mul x 0
+
add x z
+
mod x 26
+
div z 1
+
add x 15
+
eql x w
+
eql x 0
+
mul y 0
+
add y 25
+
mul y x
+
add y 1
+
mul z y
+
mul y 0
+
add y w
+
add y 11
+
mul y x
+
add z y
+
inp w
+
mul x 0
+
add x z
+
mod x 26
+
div z 26
+
add x -16
+
eql x w
+
eql x 0
+
mul y 0
+
add y 25
+
mul y x
+
add y 1
+
mul z y
+
mul y 0
+
add y w
+
add y 4
+
mul y x
+
add z y
+
inp w
+
mul x 0
+
add x z
+
mod x 26
+
div z 1
+
add x 14
+
eql x w
+
eql x 0
+
mul y 0
+
add y 25
+
mul y x
+
add y 1
+
mul z y
+
mul y 0
+
add y w
+
add y 12
+
mul y x
+
add z y
+
inp w
+
mul x 0
+
add x z
+
mod x 26
+
div z 1
+
add x 15
+
eql x w
+
eql x 0
+
mul y 0
+
add y 25
+
mul y x
+
add y 1
+
mul z y
+
mul y 0
+
add y w
+
add y 9
+
mul y x
+
add z y
+
inp w
+
mul x 0
+
add x z
+
mod x 26
+
div z 26
+
add x -7
+
eql x w
+
eql x 0
+
mul y 0
+
add y 25
+
mul y x
+
add y 1
+
mul z y
+
mul y 0
+
add y w
+
add y 10
+
mul y x
+
add z y
+
inp w
+
mul x 0
+
add x z
+
mod x 26
+
div z 26
+
add x -11
+
eql x w
+
eql x 0
+
mul y 0
+
add y 25
+
mul y x
+
add y 1
+
mul z y
+
mul y 0
+
add y w
+
add y 11
+
mul y x
+
add z y
+
inp w
+
mul x 0
+
add x z
+
mod x 26
+
div z 26
+
add x -6
+
eql x w
+
eql x 0
+
mul y 0
+
add y 25
+
mul y x
+
add y 1
+
mul z y
+
mul y 0
+
add y w
+
add y 6
+
mul y x
+
add z y
+
inp w
+
mul x 0
+
add x z
+
mod x 26
+
div z 26
+
add x -11
+
eql x w
+
eql x 0
+
mul y 0
+
add y 25
+
mul y x
+
add y 1
+
mul z y
+
mul y 0
+
add y w
+
add y 15
+
mul y x
+
add z y
2021/day3.livemd 2021/day03.livemd
2021/day3.txt 2021/day03.txt
2021/day4.livemd 2021/day04.livemd
2021/day4.txt 2021/day04.txt
2021/day5.livemd 2021/day05.livemd
2021/day5.txt 2021/day05.txt
2021/day6.livemd 2021/day06.livemd
2021/day6.txt 2021/day06.txt
2021/day7.livemd 2021/day07.livemd
2021/day7.txt 2021/day07.txt
2021/day8.livemd 2021/day08.livemd
2021/day8.txt 2021/day08.txt
2021/day9.livemd 2021/day09.livemd
2021/day9.txt 2021/day09.txt