hauleth.dev
2021/day1.livemd
2021/day01.livemd
2021/day1.livemd
2021/day01.livemd
2021/day1.txt
2021/day01.txt
2021/day1.txt
2021/day01.txt
+19
-6
2021/day19.livemd
+19
-6
2021/day19.livemd
···
28
28
length(input)
29
29
```
30
30
31
-
```output
31
+
<!-- livebook:{"output":true} -->
32
+
33
+
```
32
34
34
33
35
```
34
36
···
105
107
{a_2}_d & 1
106
108
\end{vmatrix}
107
109
} = \frac{{a_1}_d {b_2}_d - {b_1}_d {a_2}_d}{{a_1}_d - {a_2}_d}
110
+
$$
108
111
109
112
```elixir
110
113
defmodule Day19 do
···
204
207
end
205
208
```
206
209
207
-
```output
210
+
<!-- livebook:{"output":true} -->
211
+
212
+
```
208
213
{:module, Day19, <<70, 79, 82, 49, 0, 0, 26, ...>>, {:pairs, 1}}
209
214
```
210
215
···
225
230
{length(joinable), length(later)}
226
231
```
227
232
228
-
```output
233
+
<!-- livebook:{"output":true} -->
234
+
235
+
```
229
236
{3, 30}
230
237
```
231
238
···
272
279
MapSet.size(points_set)
273
280
```
274
281
275
-
```output
282
+
<!-- livebook:{"output":true} -->
283
+
284
+
```
276
285
0.002822
277
286
1: {5, 25}
278
287
0.017052
···
290
299
0.071942
291
300
```
292
301
293
-
```output
302
+
<!-- livebook:{"output":true} -->
303
+
304
+
```
294
305
396
295
306
```
296
307
···
303
314
|> Enum.max()
304
315
```
305
316
306
-
```output
317
+
<!-- livebook:{"output":true} -->
318
+
319
+
```
307
320
11828
308
321
```
2021/day2.livemd
2021/day02.livemd
2021/day2.livemd
2021/day02.livemd
2021/day2.txt
2021/day02.txt
2021/day2.txt
2021/day02.txt
+149
2021/day23.livemd
+149
2021/day23.livemd
···
1
+
<!-- vim:ft=markdown -->
2
+
3
+
<!-- livebook:{"persist_outputs":true} -->
4
+
5
+
# Day 23
6
+
7
+
## Section
8
+
9
+
```elixir
10
+
input =
11
+
File.stream!("day23.txt")
12
+
|> Enum.map(fn line ->
13
+
for <<c <- line>>, c in 'ABCD', do: String.to_atom(<<c + 32>>)
14
+
end)
15
+
|> Enum.reject(&(&1 == []))
16
+
|> Enum.zip()
17
+
|> Enum.map(&Tuple.to_list/1)
18
+
|> Enum.zip_with(~w[a b c d]a, &{&2, &1})
19
+
|> Map.new()
20
+
```
21
+
22
+
```output
23
+
%{a: [:d, :b], b: [:d, :a], c: [:c, :b], d: [:c, :a]}
24
+
```
25
+
26
+
Graph of the possible movements. `--` and `|` have multiply 1 and `---`, `\`, and `/` have
27
+
multiply 2.
28
+
29
+
```
30
+
.--.---.---.---.---.--.
31
+
\ / \ / \ / \ /
32
+
. . . .
33
+
| | | |
34
+
. . . .
35
+
```
36
+
37
+
```elixir
38
+
defmodule Day23 do
39
+
@costs %{a: 1, b: 10, c: 100, d: 1000}
40
+
@rooms %{a: -3, b: -1, c: 1, d: 3}
41
+
42
+
# - - - - - + + + + +
43
+
# 5 4 3 2 1 0 1 2 3 4 5
44
+
# A B C D
45
+
# A B C D
46
+
47
+
defp memoize(tid, args, func) do
48
+
case :ets.lookup(tid, args) do
49
+
[{^args, value}] ->
50
+
value
51
+
52
+
[] ->
53
+
value = func.()
54
+
:ets.insert(tid, {args, value})
55
+
value
56
+
end
57
+
end
58
+
59
+
def process(stacks) do
60
+
tid = :ets.new(:memoize, [:public, :set])
61
+
depth = length(stacks[:a])
62
+
63
+
try do
64
+
do_process(stacks, %{}, target(depth), depth, tid)
65
+
after
66
+
:ets.delete(tid)
67
+
end
68
+
end
69
+
70
+
defp do_process(target, _, target, _depth, _tid), do: 0
71
+
72
+
defp do_process(stacks, hall, target, depth, tid) do
73
+
memoize(tid, [stacks, hall], fn ->
74
+
possible_moves(stacks, hall, depth)
75
+
|> Enum.map(fn {new_stack, new_hall, cost} ->
76
+
cost + do_process(new_stack, new_hall, target, depth, tid)
77
+
end)
78
+
|> Enum.min(&<=/2, fn -> :inf end)
79
+
end)
80
+
end
81
+
82
+
defp possible_moves(stacks, hall, depth) do
83
+
hall_to_room(stacks, hall, depth) ++ room_to_hall(stacks, hall, depth)
84
+
end
85
+
86
+
defp hall_to_room(stacks, hall, depth) do
87
+
# IO.inspect({stacks, hall, depth}, label: elem(__ENV__.function, 0))
88
+
for {pos, t} <- hall,
89
+
clear_path_to_room?(t, pos, hall),
90
+
accepts?(t, stacks),
91
+
{size, new_stacks} = into_room(t, stacks),
92
+
do: {new_stacks, Map.delete(hall, pos), cost(t, pos, @rooms[t], depth - size)}
93
+
end
94
+
95
+
defp room_to_hall(stacks, hall, depth) do
96
+
[]
97
+
end
98
+
99
+
defp clear_path_to_room?(t, pos, hall) do
100
+
hall
101
+
|> Map.keys()
102
+
|> Enum.find(&(&1 in min(pos, @rooms[t])..max(pos, @rooms[t])))
103
+
|> case do
104
+
nil -> true
105
+
_ -> false
106
+
end
107
+
end
108
+
109
+
defp accepts?(t, stacks), do: Enum.all?(stacks[t], &(&1 == t))
110
+
111
+
defp into_room(t, stacks) do
112
+
Map.get_and_update!(stacks, t, &{length(&1), [t | &1]})
113
+
end
114
+
115
+
defp target(depth) do
116
+
for v <- ~w[a b c d]a,
117
+
into: %{},
118
+
do: {v, List.duplicate(v, depth)}
119
+
end
120
+
121
+
def cost(elem, from, to, depth) do
122
+
@costs[elem] * (depth + abs(to - from))
123
+
end
124
+
end
125
+
```
126
+
127
+
```output
128
+
warning: variable "depth" is unused (if the variable is not meant to be used, prefix it with an underscore)
129
+
day23.livemd#cell:58: Day23.room_to_hall/3
130
+
131
+
warning: variable "hall" is unused (if the variable is not meant to be used, prefix it with an underscore)
132
+
day23.livemd#cell:58: Day23.room_to_hall/3
133
+
134
+
warning: variable "stacks" is unused (if the variable is not meant to be used, prefix it with an underscore)
135
+
day23.livemd#cell:58: Day23.room_to_hall/3
136
+
137
+
```
138
+
139
+
```output
140
+
{:module, Day23, <<70, 79, 82, 49, 0, 0, 23, ...>>, {:cost, 4}}
141
+
```
142
+
143
+
```elixir
144
+
Day23.process(input)
145
+
```
146
+
147
+
```output
148
+
:inf
149
+
```
+5
2021/day23.txt
+5
2021/day23.txt
+351
2021/day24.livemd
+351
2021/day24.livemd
···
1
+
<!-- livebook:{"persist_outputs":true} -->
2
+
3
+
# Day 24
4
+
5
+
## Section
6
+
7
+
```elixir
8
+
defmodule Day24 do
9
+
def parse("inp " <> reg), do: {:inp, String.to_atom(reg)}
10
+
11
+
def parse(<<op::binary-size(3)>> <> " " <> <<reg>> <> " " <> arg) do
12
+
{String.to_atom(op), String.to_atom(<<reg>>), parse_arg(arg)}
13
+
end
14
+
15
+
defp parse_arg(arg) do
16
+
case Integer.parse(arg) do
17
+
{num, ""} -> num
18
+
:error -> String.to_atom(arg)
19
+
end
20
+
end
21
+
22
+
def evaluate(ops, input), do: evaluate(ops, Integer.digits(input), %{w: 0, x: 0, y: 0, z: 0})
23
+
24
+
defp evaluate([], _, regs), do: regs
25
+
26
+
defp evaluate([:nop | rest], input, regs), do: evaluate(rest, input, regs)
27
+
28
+
defp evaluate([{:inp, reg} | rest], [v | input], regs),
29
+
do: evaluate(rest, input, %{regs | reg => v})
30
+
31
+
defp evaluate([{:eql, reg, v} | rest], input, regs) do
32
+
val = if get(reg, regs) == get(v, regs), do: 1, else: 0
33
+
34
+
evaluate(rest, input, %{regs | reg => val})
35
+
end
36
+
37
+
defp evaluate([{:add, reg, v} | rest], input, regs),
38
+
do: evaluate(rest, input, %{regs | reg => get(reg, regs) + get(v, regs)})
39
+
40
+
defp evaluate([{:mul, reg, v} | rest], input, regs),
41
+
do: evaluate(rest, input, %{regs | reg => get(reg, regs) * get(v, regs)})
42
+
43
+
defp evaluate([{:div, reg, v} | rest], input, regs),
44
+
do: evaluate(rest, input, %{regs | reg => div(get(reg, regs), get(v, regs))})
45
+
46
+
defp evaluate([{:mod, reg, v} | rest], input, regs),
47
+
do: evaluate(rest, input, %{regs | reg => rem(get(reg, regs), get(v, regs))})
48
+
49
+
defp get(imm, _regs) when is_integer(imm), do: imm
50
+
defp get(reg, regs) when is_atom(reg), do: Map.get(regs, reg, 0)
51
+
end
52
+
53
+
input =
54
+
File.stream!("day24.txt")
55
+
|> Stream.map(&String.trim/1)
56
+
|> Enum.map(&Day24.parse/1)
57
+
|> IO.inspect(limit: :infinity)
58
+
59
+
length(input)
60
+
```
61
+
62
+
<!-- livebook:{"output":true} -->
63
+
64
+
```
65
+
[
66
+
{:inp, :w},
67
+
{:mul, :x, 0},
68
+
{:add, :x, :z},
69
+
{:mod, :x, 26},
70
+
{:div, :z, 1},
71
+
{:add, :x, 11},
72
+
{:eql, :x, :w},
73
+
{:eql, :x, 0},
74
+
{:mul, :y, 0},
75
+
{:add, :y, 25},
76
+
{:mul, :y, :x},
77
+
{:add, :y, 1},
78
+
{:mul, :z, :y},
79
+
{:mul, :y, 0},
80
+
{:add, :y, :w},
81
+
{:add, :y, 16},
82
+
{:mul, :y, :x},
83
+
{:add, :z, :y},
84
+
{:inp, :w},
85
+
{:mul, :x, 0},
86
+
{:add, :x, :z},
87
+
{:mod, :x, 26},
88
+
{:div, :z, 1},
89
+
{:add, :x, 12},
90
+
{:eql, :x, :w},
91
+
{:eql, :x, 0},
92
+
{:mul, :y, 0},
93
+
{:add, :y, 25},
94
+
{:mul, :y, :x},
95
+
{:add, :y, 1},
96
+
{:mul, :z, :y},
97
+
{:mul, :y, 0},
98
+
{:add, :y, :w},
99
+
{:add, :y, 11},
100
+
{:mul, :y, :x},
101
+
{:add, :z, :y},
102
+
{:inp, :w},
103
+
{:mul, :x, 0},
104
+
{:add, :x, :z},
105
+
{:mod, :x, 26},
106
+
{:div, :z, 1},
107
+
{:add, :x, 13},
108
+
{:eql, :x, :w},
109
+
{:eql, :x, 0},
110
+
{:mul, :y, 0},
111
+
{:add, :y, 25},
112
+
{:mul, :y, :x},
113
+
{:add, :y, 1},
114
+
{:mul, :z, :y},
115
+
{:mul, :y, 0},
116
+
{:add, :y, :w},
117
+
{:add, :y, 12},
118
+
{:mul, :y, :x},
119
+
{:add, :z, :y},
120
+
{:inp, :w},
121
+
{:mul, :x, 0},
122
+
{:add, :x, :z},
123
+
{:mod, :x, 26},
124
+
{:div, :z, 26},
125
+
{:add, :x, -5},
126
+
{:eql, :x, :w},
127
+
{:eql, :x, 0},
128
+
{:mul, :y, 0},
129
+
{:add, :y, 25},
130
+
{:mul, :y, :x},
131
+
{:add, :y, 1},
132
+
{:mul, :z, :y},
133
+
{:mul, :y, 0},
134
+
{:add, :y, :w},
135
+
{:add, :y, 12},
136
+
{:mul, :y, :x},
137
+
{:add, :z, :y},
138
+
{:inp, :w},
139
+
{:mul, :x, 0},
140
+
{:add, :x, :z},
141
+
{:mod, :x, 26},
142
+
{:div, :z, 26},
143
+
{:add, :x, -3},
144
+
{:eql, :x, :w},
145
+
{:eql, :x, 0},
146
+
{:mul, :y, 0},
147
+
{:add, :y, 25},
148
+
{:mul, :y, :x},
149
+
{:add, :y, 1},
150
+
{:mul, :z, :y},
151
+
{:mul, :y, 0},
152
+
{:add, :y, :w},
153
+
{:add, :y, 12},
154
+
{:mul, :y, :x},
155
+
{:add, :z, :y},
156
+
{:inp, :w},
157
+
{:mul, :x, 0},
158
+
{:add, :x, :z},
159
+
{:mod, :x, 26},
160
+
{:div, :z, 1},
161
+
{:add, :x, 14},
162
+
{:eql, :x, :w},
163
+
{:eql, :x, 0},
164
+
{:mul, :y, 0},
165
+
{:add, :y, 25},
166
+
{:mul, :y, :x},
167
+
{:add, :y, 1},
168
+
{:mul, :z, :y},
169
+
{:mul, :y, 0},
170
+
{:add, :y, :w},
171
+
{:add, :y, 2},
172
+
{:mul, :y, :x},
173
+
{:add, :z, :y},
174
+
{:inp, :w},
175
+
{:mul, :x, 0},
176
+
{:add, :x, :z},
177
+
{:mod, :x, 26},
178
+
{:div, :z, 1},
179
+
{:add, :x, 15},
180
+
{:eql, :x, :w},
181
+
{:eql, :x, 0},
182
+
{:mul, :y, 0},
183
+
{:add, :y, 25},
184
+
{:mul, :y, :x},
185
+
{:add, :y, 1},
186
+
{:mul, :z, :y},
187
+
{:mul, :y, 0},
188
+
{:add, :y, :w},
189
+
{:add, :y, 11},
190
+
{:mul, :y, :x},
191
+
{:add, :z, :y},
192
+
{:inp, :w},
193
+
{:mul, :x, 0},
194
+
{:add, :x, :z},
195
+
{:mod, :x, 26},
196
+
{:div, :z, 26},
197
+
{:add, :x, -16},
198
+
{:eql, :x, :w},
199
+
{:eql, :x, 0},
200
+
{:mul, :y, 0},
201
+
{:add, :y, 25},
202
+
{:mul, :y, :x},
203
+
{:add, :y, 1},
204
+
{:mul, :z, :y},
205
+
{:mul, :y, 0},
206
+
{:add, :y, :w},
207
+
{:add, :y, 4},
208
+
{:mul, :y, :x},
209
+
{:add, :z, :y},
210
+
{:inp, :w},
211
+
{:mul, :x, 0},
212
+
{:add, :x, :z},
213
+
{:mod, :x, 26},
214
+
{:div, :z, 1},
215
+
{:add, :x, 14},
216
+
{:eql, :x, :w},
217
+
{:eql, :x, 0},
218
+
{:mul, :y, 0},
219
+
{:add, :y, 25},
220
+
{:mul, :y, :x},
221
+
{:add, :y, 1},
222
+
{:mul, :z, :y},
223
+
{:mul, :y, 0},
224
+
{:add, :y, :w},
225
+
{:add, :y, 12},
226
+
{:mul, :y, :x},
227
+
{:add, :z, :y},
228
+
{:inp, :w},
229
+
{:mul, :x, 0},
230
+
{:add, :x, :z},
231
+
{:mod, :x, 26},
232
+
{:div, :z, 1},
233
+
{:add, :x, 15},
234
+
{:eql, :x, :w},
235
+
{:eql, :x, 0},
236
+
{:mul, :y, 0},
237
+
{:add, :y, 25},
238
+
{:mul, :y, :x},
239
+
{:add, :y, 1},
240
+
{:mul, :z, :y},
241
+
{:mul, :y, 0},
242
+
{:add, :y, :w},
243
+
{:add, :y, 9},
244
+
{:mul, :y, :x},
245
+
{:add, :z, :y},
246
+
{:inp, :w},
247
+
{:mul, :x, 0},
248
+
{:add, :x, :z},
249
+
{:mod, :x, 26},
250
+
{:div, :z, 26},
251
+
{:add, :x, -7},
252
+
{:eql, :x, :w},
253
+
{:eql, :x, 0},
254
+
{:mul, :y, 0},
255
+
{:add, :y, 25},
256
+
{:mul, :y, :x},
257
+
{:add, :y, 1},
258
+
{:mul, :z, :y},
259
+
{:mul, :y, 0},
260
+
{:add, :y, :w},
261
+
{:add, :y, 10},
262
+
{:mul, :y, :x},
263
+
{:add, :z, :y},
264
+
{:inp, :w},
265
+
{:mul, :x, 0},
266
+
{:add, :x, :z},
267
+
{:mod, :x, 26},
268
+
{:div, :z, 26},
269
+
{:add, :x, -11},
270
+
{:eql, :x, :w},
271
+
{:eql, :x, 0},
272
+
{:mul, :y, 0},
273
+
{:add, :y, 25},
274
+
{:mul, :y, :x},
275
+
{:add, :y, 1},
276
+
{:mul, :z, :y},
277
+
{:mul, :y, 0},
278
+
{:add, :y, :w},
279
+
{:add, :y, 11},
280
+
{:mul, :y, :x},
281
+
{:add, :z, :y},
282
+
{:inp, :w},
283
+
{:mul, :x, 0},
284
+
{:add, :x, :z},
285
+
{:mod, :x, 26},
286
+
{:div, :z, 26},
287
+
{:add, :x, -6},
288
+
{:eql, :x, :w},
289
+
{:eql, :x, 0},
290
+
{:mul, :y, 0},
291
+
{:add, :y, 25},
292
+
{:mul, :y, :x},
293
+
{:add, :y, 1},
294
+
{:mul, :z, :y},
295
+
{:mul, :y, 0},
296
+
{:add, :y, :w},
297
+
{:add, :y, 6},
298
+
{:mul, :y, :x},
299
+
{:add, :z, :y},
300
+
{:inp, :w},
301
+
{:mul, :x, 0},
302
+
{:add, :x, :z},
303
+
{:mod, :x, 26},
304
+
{:div, :z, 26},
305
+
{:add, :x, -11},
306
+
{:eql, :x, :w},
307
+
{:eql, :x, 0},
308
+
{:mul, :y, 0},
309
+
{:add, :y, 25},
310
+
{:mul, :y, :x},
311
+
{:add, :y, 1},
312
+
{:mul, :z, :y},
313
+
{:mul, :y, 0},
314
+
{:add, :y, :w},
315
+
{:add, :y, 15},
316
+
{:mul, :y, :x},
317
+
{:add, :z, :y}
318
+
]
319
+
```
320
+
321
+
<!-- livebook:{"output":true} -->
322
+
323
+
```
324
+
252
325
+
```
326
+
327
+
```elixir
328
+
44..52 |> Enum.map(&rem(&1, 26))
329
+
```
330
+
331
+
<!-- livebook:{"output":true} -->
332
+
333
+
```
334
+
[18, 19, 20, 21, 22, 23, 24, 25, 0]
335
+
```
336
+
337
+
```elixir
338
+
IO.inspect(Day24.evaluate(input, 11_111_111_111_161))
339
+
```
340
+
341
+
<!-- livebook:{"output":true} -->
342
+
343
+
```
344
+
%{w: 1, x: 1, y: 16, z: 207697766}
345
+
```
346
+
347
+
<!-- livebook:{"output":true} -->
348
+
349
+
```
350
+
%{w: 1, x: 1, y: 16, z: 207697766}
351
+
```
+252
2021/day24.txt
+252
2021/day24.txt
···
1
+
inp w
2
+
mul x 0
3
+
add x z
4
+
mod x 26
5
+
div z 1
6
+
add x 11
7
+
eql x w
8
+
eql x 0
9
+
mul y 0
10
+
add y 25
11
+
mul y x
12
+
add y 1
13
+
mul z y
14
+
mul y 0
15
+
add y w
16
+
add y 16
17
+
mul y x
18
+
add z y
19
+
inp w
20
+
mul x 0
21
+
add x z
22
+
mod x 26
23
+
div z 1
24
+
add x 12
25
+
eql x w
26
+
eql x 0
27
+
mul y 0
28
+
add y 25
29
+
mul y x
30
+
add y 1
31
+
mul z y
32
+
mul y 0
33
+
add y w
34
+
add y 11
35
+
mul y x
36
+
add z y
37
+
inp w
38
+
mul x 0
39
+
add x z
40
+
mod x 26
41
+
div z 1
42
+
add x 13
43
+
eql x w
44
+
eql x 0
45
+
mul y 0
46
+
add y 25
47
+
mul y x
48
+
add y 1
49
+
mul z y
50
+
mul y 0
51
+
add y w
52
+
add y 12
53
+
mul y x
54
+
add z y
55
+
inp w
56
+
mul x 0
57
+
add x z
58
+
mod x 26
59
+
div z 26
60
+
add x -5
61
+
eql x w
62
+
eql x 0
63
+
mul y 0
64
+
add y 25
65
+
mul y x
66
+
add y 1
67
+
mul z y
68
+
mul y 0
69
+
add y w
70
+
add y 12
71
+
mul y x
72
+
add z y
73
+
inp w
74
+
mul x 0
75
+
add x z
76
+
mod x 26
77
+
div z 26
78
+
add x -3
79
+
eql x w
80
+
eql x 0
81
+
mul y 0
82
+
add y 25
83
+
mul y x
84
+
add y 1
85
+
mul z y
86
+
mul y 0
87
+
add y w
88
+
add y 12
89
+
mul y x
90
+
add z y
91
+
inp w
92
+
mul x 0
93
+
add x z
94
+
mod x 26
95
+
div z 1
96
+
add x 14
97
+
eql x w
98
+
eql x 0
99
+
mul y 0
100
+
add y 25
101
+
mul y x
102
+
add y 1
103
+
mul z y
104
+
mul y 0
105
+
add y w
106
+
add y 2
107
+
mul y x
108
+
add z y
109
+
inp w
110
+
mul x 0
111
+
add x z
112
+
mod x 26
113
+
div z 1
114
+
add x 15
115
+
eql x w
116
+
eql x 0
117
+
mul y 0
118
+
add y 25
119
+
mul y x
120
+
add y 1
121
+
mul z y
122
+
mul y 0
123
+
add y w
124
+
add y 11
125
+
mul y x
126
+
add z y
127
+
inp w
128
+
mul x 0
129
+
add x z
130
+
mod x 26
131
+
div z 26
132
+
add x -16
133
+
eql x w
134
+
eql x 0
135
+
mul y 0
136
+
add y 25
137
+
mul y x
138
+
add y 1
139
+
mul z y
140
+
mul y 0
141
+
add y w
142
+
add y 4
143
+
mul y x
144
+
add z y
145
+
inp w
146
+
mul x 0
147
+
add x z
148
+
mod x 26
149
+
div z 1
150
+
add x 14
151
+
eql x w
152
+
eql x 0
153
+
mul y 0
154
+
add y 25
155
+
mul y x
156
+
add y 1
157
+
mul z y
158
+
mul y 0
159
+
add y w
160
+
add y 12
161
+
mul y x
162
+
add z y
163
+
inp w
164
+
mul x 0
165
+
add x z
166
+
mod x 26
167
+
div z 1
168
+
add x 15
169
+
eql x w
170
+
eql x 0
171
+
mul y 0
172
+
add y 25
173
+
mul y x
174
+
add y 1
175
+
mul z y
176
+
mul y 0
177
+
add y w
178
+
add y 9
179
+
mul y x
180
+
add z y
181
+
inp w
182
+
mul x 0
183
+
add x z
184
+
mod x 26
185
+
div z 26
186
+
add x -7
187
+
eql x w
188
+
eql x 0
189
+
mul y 0
190
+
add y 25
191
+
mul y x
192
+
add y 1
193
+
mul z y
194
+
mul y 0
195
+
add y w
196
+
add y 10
197
+
mul y x
198
+
add z y
199
+
inp w
200
+
mul x 0
201
+
add x z
202
+
mod x 26
203
+
div z 26
204
+
add x -11
205
+
eql x w
206
+
eql x 0
207
+
mul y 0
208
+
add y 25
209
+
mul y x
210
+
add y 1
211
+
mul z y
212
+
mul y 0
213
+
add y w
214
+
add y 11
215
+
mul y x
216
+
add z y
217
+
inp w
218
+
mul x 0
219
+
add x z
220
+
mod x 26
221
+
div z 26
222
+
add x -6
223
+
eql x w
224
+
eql x 0
225
+
mul y 0
226
+
add y 25
227
+
mul y x
228
+
add y 1
229
+
mul z y
230
+
mul y 0
231
+
add y w
232
+
add y 6
233
+
mul y x
234
+
add z y
235
+
inp w
236
+
mul x 0
237
+
add x z
238
+
mod x 26
239
+
div z 26
240
+
add x -11
241
+
eql x w
242
+
eql x 0
243
+
mul y 0
244
+
add y 25
245
+
mul y x
246
+
add y 1
247
+
mul z y
248
+
mul y 0
249
+
add y w
250
+
add y 15
251
+
mul y x
252
+
add z y
2021/day3.livemd
2021/day03.livemd
2021/day3.livemd
2021/day03.livemd
2021/day3.txt
2021/day03.txt
2021/day3.txt
2021/day03.txt
2021/day4.livemd
2021/day04.livemd
2021/day4.livemd
2021/day04.livemd
2021/day4.txt
2021/day04.txt
2021/day4.txt
2021/day04.txt
2021/day5.livemd
2021/day05.livemd
2021/day5.livemd
2021/day05.livemd
2021/day5.txt
2021/day05.txt
2021/day5.txt
2021/day05.txt
2021/day6.livemd
2021/day06.livemd
2021/day6.livemd
2021/day06.livemd
2021/day6.txt
2021/day06.txt
2021/day6.txt
2021/day06.txt
2021/day7.livemd
2021/day07.livemd
2021/day7.livemd
2021/day07.livemd
2021/day7.txt
2021/day07.txt
2021/day7.txt
2021/day07.txt
2021/day8.livemd
2021/day08.livemd
2021/day8.livemd
2021/day08.livemd
2021/day8.txt
2021/day08.txt
2021/day8.txt
2021/day08.txt
2021/day9.livemd
2021/day09.livemd
2021/day9.livemd
2021/day09.livemd
2021/day9.txt
2021/day09.txt
2021/day9.txt
2021/day09.txt