2021/day1.livemd 2021/day01.livemd

2021/day1.txt 2021/day01.txt

+19 -6

2021/day19.livemd

··· 28 28 length(input) 29 29 ``` 30 30 31 31 - ```output 31 31 + <!-- livebook:{"output":true} --> 32 32 + 33 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 110 + $$ 108 111 109 112 ```elixir 110 113 defmodule Day19 do ··· 204 207 end 205 208 ``` 206 209 207 207 - ```output 210 210 + <!-- livebook:{"output":true} --> 211 211 + 212 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 228 - ```output 233 233 + <!-- livebook:{"output":true} --> 234 234 + 235 235 + ``` 229 236 {3, 30} 230 237 ``` 231 238 ··· 272 279 MapSet.size(points_set) 273 280 ``` 274 281 275 275 - ```output 282 282 + <!-- livebook:{"output":true} --> 283 283 + 284 284 + ``` 276 285 0.002822 277 286 1: {5, 25} 278 287 0.017052 ··· 290 299 0.071942 291 300 ``` 292 301 293 293 - ```output 302 302 + <!-- livebook:{"output":true} --> 303 303 + 304 304 + ``` 294 305 396 295 306 ``` 296 307 ··· 303 314 |> Enum.max() 304 315 ``` 305 316 306 306 - ```output 317 317 + <!-- livebook:{"output":true} --> 318 318 + 319 319 + ``` 307 320 11828 308 321 ```

2021/day2.livemd 2021/day02.livemd

2021/day2.txt 2021/day02.txt

+149

2021/day23.livemd

··· 1 1 + <!-- vim:ft=markdown --> 2 2 + 3 3 + <!-- livebook:{"persist_outputs":true} --> 4 4 + 5 5 + # Day 23 6 6 + 7 7 + ## Section 8 8 + 9 9 + ```elixir 10 10 + input = 11 11 + File.stream!("day23.txt") 12 12 + |> Enum.map(fn line -> 13 13 + for <<c <- line>>, c in 'ABCD', do: String.to_atom(<<c + 32>>) 14 14 + end) 15 15 + |> Enum.reject(&(&1 == [])) 16 16 + |> Enum.zip() 17 17 + |> Enum.map(&Tuple.to_list/1) 18 18 + |> Enum.zip_with(~w[a b c d]a, &{&2, &1}) 19 19 + |> Map.new() 20 20 + ``` 21 21 + 22 22 + ```output 23 23 + %{a: [:d, :b], b: [:d, :a], c: [:c, :b], d: [:c, :a]} 24 24 + ``` 25 25 + 26 26 + Graph of the possible movements. `--` and `|` have multiply 1 and `---`, `\`, and `/` have 27 27 + multiply 2. 28 28 + 29 29 + ``` 30 30 + .--.---.---.---.---.--. 31 31 + \ / \ / \ / \ / 32 32 + . . . . 33 33 + | | | | 34 34 + . . . . 35 35 + ``` 36 36 + 37 37 + ```elixir 38 38 + defmodule Day23 do 39 39 + @costs %{a: 1, b: 10, c: 100, d: 1000} 40 40 + @rooms %{a: -3, b: -1, c: 1, d: 3} 41 41 + 42 42 + # - - - - - + + + + + 43 43 + # 5 4 3 2 1 0 1 2 3 4 5 44 44 + # A B C D 45 45 + # A B C D 46 46 + 47 47 + defp memoize(tid, args, func) do 48 48 + case :ets.lookup(tid, args) do 49 49 + [{^args, value}] -> 50 50 + value 51 51 + 52 52 + [] -> 53 53 + value = func.() 54 54 + :ets.insert(tid, {args, value}) 55 55 + value 56 56 + end 57 57 + end 58 58 + 59 59 + def process(stacks) do 60 60 + tid = :ets.new(:memoize, [:public, :set]) 61 61 + depth = length(stacks[:a]) 62 62 + 63 63 + try do 64 64 + do_process(stacks, %{}, target(depth), depth, tid) 65 65 + after 66 66 + :ets.delete(tid) 67 67 + end 68 68 + end 69 69 + 70 70 + defp do_process(target, _, target, _depth, _tid), do: 0 71 71 + 72 72 + defp do_process(stacks, hall, target, depth, tid) do 73 73 + memoize(tid, [stacks, hall], fn -> 74 74 + possible_moves(stacks, hall, depth) 75 75 + |> Enum.map(fn {new_stack, new_hall, cost} -> 76 76 + cost + do_process(new_stack, new_hall, target, depth, tid) 77 77 + end) 78 78 + |> Enum.min(&<=/2, fn -> :inf end) 79 79 + end) 80 80 + end 81 81 + 82 82 + defp possible_moves(stacks, hall, depth) do 83 83 + hall_to_room(stacks, hall, depth) ++ room_to_hall(stacks, hall, depth) 84 84 + end 85 85 + 86 86 + defp hall_to_room(stacks, hall, depth) do 87 87 + # IO.inspect({stacks, hall, depth}, label: elem(__ENV__.function, 0)) 88 88 + for {pos, t} <- hall, 89 89 + clear_path_to_room?(t, pos, hall), 90 90 + accepts?(t, stacks), 91 91 + {size, new_stacks} = into_room(t, stacks), 92 92 + do: {new_stacks, Map.delete(hall, pos), cost(t, pos, @rooms[t], depth - size)} 93 93 + end 94 94 + 95 95 + defp room_to_hall(stacks, hall, depth) do 96 96 + [] 97 97 + end 98 98 + 99 99 + defp clear_path_to_room?(t, pos, hall) do 100 100 + hall 101 101 + |> Map.keys() 102 102 + |> Enum.find(&(&1 in min(pos, @rooms[t])..max(pos, @rooms[t]))) 103 103 + |> case do 104 104 + nil -> true 105 105 + _ -> false 106 106 + end 107 107 + end 108 108 + 109 109 + defp accepts?(t, stacks), do: Enum.all?(stacks[t], &(&1 == t)) 110 110 + 111 111 + defp into_room(t, stacks) do 112 112 + Map.get_and_update!(stacks, t, &{length(&1), [t | &1]}) 113 113 + end 114 114 + 115 115 + defp target(depth) do 116 116 + for v <- ~w[a b c d]a, 117 117 + into: %{}, 118 118 + do: {v, List.duplicate(v, depth)} 119 119 + end 120 120 + 121 121 + def cost(elem, from, to, depth) do 122 122 + @costs[elem] * (depth + abs(to - from)) 123 123 + end 124 124 + end 125 125 + ``` 126 126 + 127 127 + ```output 128 128 + warning: variable "depth" is unused (if the variable is not meant to be used, prefix it with an underscore) 129 129 + day23.livemd#cell:58: Day23.room_to_hall/3 130 130 + 131 131 + warning: variable "hall" is unused (if the variable is not meant to be used, prefix it with an underscore) 132 132 + day23.livemd#cell:58: Day23.room_to_hall/3 133 133 + 134 134 + warning: variable "stacks" is unused (if the variable is not meant to be used, prefix it with an underscore) 135 135 + day23.livemd#cell:58: Day23.room_to_hall/3 136 136 + 137 137 + ``` 138 138 + 139 139 + ```output 140 140 + {:module, Day23, <<70, 79, 82, 49, 0, 0, 23, ...>>, {:cost, 4}} 141 141 + ``` 142 142 + 143 143 + ```elixir 144 144 + Day23.process(input) 145 145 + ``` 146 146 + 147 147 + ```output 148 148 + :inf 149 149 + ```

+5

2021/day23.txt

··· 1 1 + ############# 2 2 + #...........# 3 3 + ###D#D#C#C### 4 4 + #B#A#B#A# 5 5 + #########

+351

2021/day24.livemd

··· 1 1 + <!-- livebook:{"persist_outputs":true} --> 2 2 + 3 3 + # Day 24 4 4 + 5 5 + ## Section 6 6 + 7 7 + ```elixir 8 8 + defmodule Day24 do 9 9 + def parse("inp " <> reg), do: {:inp, String.to_atom(reg)} 10 10 + 11 11 + def parse(<<op::binary-size(3)>> <> " " <> <<reg>> <> " " <> arg) do 12 12 + {String.to_atom(op), String.to_atom(<<reg>>), parse_arg(arg)} 13 13 + end 14 14 + 15 15 + defp parse_arg(arg) do 16 16 + case Integer.parse(arg) do 17 17 + {num, ""} -> num 18 18 + :error -> String.to_atom(arg) 19 19 + end 20 20 + end 21 21 + 22 22 + def evaluate(ops, input), do: evaluate(ops, Integer.digits(input), %{w: 0, x: 0, y: 0, z: 0}) 23 23 + 24 24 + defp evaluate([], _, regs), do: regs 25 25 + 26 26 + defp evaluate([:nop | rest], input, regs), do: evaluate(rest, input, regs) 27 27 + 28 28 + defp evaluate([{:inp, reg} | rest], [v | input], regs), 29 29 + do: evaluate(rest, input, %{regs | reg => v}) 30 30 + 31 31 + defp evaluate([{:eql, reg, v} | rest], input, regs) do 32 32 + val = if get(reg, regs) == get(v, regs), do: 1, else: 0 33 33 + 34 34 + evaluate(rest, input, %{regs | reg => val}) 35 35 + end 36 36 + 37 37 + defp evaluate([{:add, reg, v} | rest], input, regs), 38 38 + do: evaluate(rest, input, %{regs | reg => get(reg, regs) + get(v, regs)}) 39 39 + 40 40 + defp evaluate([{:mul, reg, v} | rest], input, regs), 41 41 + do: evaluate(rest, input, %{regs | reg => get(reg, regs) * get(v, regs)}) 42 42 + 43 43 + defp evaluate([{:div, reg, v} | rest], input, regs), 44 44 + do: evaluate(rest, input, %{regs | reg => div(get(reg, regs), get(v, regs))}) 45 45 + 46 46 + defp evaluate([{:mod, reg, v} | rest], input, regs), 47 47 + do: evaluate(rest, input, %{regs | reg => rem(get(reg, regs), get(v, regs))}) 48 48 + 49 49 + defp get(imm, _regs) when is_integer(imm), do: imm 50 50 + defp get(reg, regs) when is_atom(reg), do: Map.get(regs, reg, 0) 51 51 + end 52 52 + 53 53 + input = 54 54 + File.stream!("day24.txt") 55 55 + |> Stream.map(&String.trim/1) 56 56 + |> Enum.map(&Day24.parse/1) 57 57 + |> IO.inspect(limit: :infinity) 58 58 + 59 59 + length(input) 60 60 + ``` 61 61 + 62 62 + <!-- livebook:{"output":true} --> 63 63 + 64 64 + ``` 65 65 + [ 66 66 + {:inp, :w}, 67 67 + {:mul, :x, 0}, 68 68 + {:add, :x, :z}, 69 69 + {:mod, :x, 26}, 70 70 + {:div, :z, 1}, 71 71 + {:add, :x, 11}, 72 72 + {:eql, :x, :w}, 73 73 + {:eql, :x, 0}, 74 74 + {:mul, :y, 0}, 75 75 + {:add, :y, 25}, 76 76 + {:mul, :y, :x}, 77 77 + {:add, :y, 1}, 78 78 + {:mul, :z, :y}, 79 79 + {:mul, :y, 0}, 80 80 + {:add, :y, :w}, 81 81 + {:add, :y, 16}, 82 82 + {:mul, :y, :x}, 83 83 + {:add, :z, :y}, 84 84 + {:inp, :w}, 85 85 + {:mul, :x, 0}, 86 86 + {:add, :x, :z}, 87 87 + {:mod, :x, 26}, 88 88 + {:div, :z, 1}, 89 89 + {:add, :x, 12}, 90 90 + {:eql, :x, :w}, 91 91 + {:eql, :x, 0}, 92 92 + {:mul, :y, 0}, 93 93 + {:add, :y, 25}, 94 94 + {:mul, :y, :x}, 95 95 + {:add, :y, 1}, 96 96 + {:mul, :z, :y}, 97 97 + {:mul, :y, 0}, 98 98 + {:add, :y, :w}, 99 99 + {:add, :y, 11}, 100 100 + {:mul, :y, :x}, 101 101 + {:add, :z, :y}, 102 102 + {:inp, :w}, 103 103 + {:mul, :x, 0}, 104 104 + {:add, :x, :z}, 105 105 + {:mod, :x, 26}, 106 106 + {:div, :z, 1}, 107 107 + {:add, :x, 13}, 108 108 + {:eql, :x, :w}, 109 109 + {:eql, :x, 0}, 110 110 + {:mul, :y, 0}, 111 111 + {:add, :y, 25}, 112 112 + {:mul, :y, :x}, 113 113 + {:add, :y, 1}, 114 114 + {:mul, :z, :y}, 115 115 + {:mul, :y, 0}, 116 116 + {:add, :y, :w}, 117 117 + {:add, :y, 12}, 118 118 + {:mul, :y, :x}, 119 119 + {:add, :z, :y}, 120 120 + {:inp, :w}, 121 121 + {:mul, :x, 0}, 122 122 + {:add, :x, :z}, 123 123 + {:mod, :x, 26}, 124 124 + {:div, :z, 26}, 125 125 + {:add, :x, -5}, 126 126 + {:eql, :x, :w}, 127 127 + {:eql, :x, 0}, 128 128 + {:mul, :y, 0}, 129 129 + {:add, :y, 25}, 130 130 + {:mul, :y, :x}, 131 131 + {:add, :y, 1}, 132 132 + {:mul, :z, :y}, 133 133 + {:mul, :y, 0}, 134 134 + {:add, :y, :w}, 135 135 + {:add, :y, 12}, 136 136 + {:mul, :y, :x}, 137 137 + {:add, :z, :y}, 138 138 + {:inp, :w}, 139 139 + {:mul, :x, 0}, 140 140 + {:add, :x, :z}, 141 141 + {:mod, :x, 26}, 142 142 + {:div, :z, 26}, 143 143 + {:add, :x, -3}, 144 144 + {:eql, :x, :w}, 145 145 + {:eql, :x, 0}, 146 146 + {:mul, :y, 0}, 147 147 + {:add, :y, 25}, 148 148 + {:mul, :y, :x}, 149 149 + {:add, :y, 1}, 150 150 + {:mul, :z, :y}, 151 151 + {:mul, :y, 0}, 152 152 + {:add, :y, :w}, 153 153 + {:add, :y, 12}, 154 154 + {:mul, :y, :x}, 155 155 + {:add, :z, :y}, 156 156 + {:inp, :w}, 157 157 + {:mul, :x, 0}, 158 158 + {:add, :x, :z}, 159 159 + {:mod, :x, 26}, 160 160 + {:div, :z, 1}, 161 161 + {:add, :x, 14}, 162 162 + {:eql, :x, :w}, 163 163 + {:eql, :x, 0}, 164 164 + {:mul, :y, 0}, 165 165 + {:add, :y, 25}, 166 166 + {:mul, :y, :x}, 167 167 + {:add, :y, 1}, 168 168 + {:mul, :z, :y}, 169 169 + {:mul, :y, 0}, 170 170 + {:add, :y, :w}, 171 171 + {:add, :y, 2}, 172 172 + {:mul, :y, :x}, 173 173 + {:add, :z, :y}, 174 174 + {:inp, :w}, 175 175 + {:mul, :x, 0}, 176 176 + {:add, :x, :z}, 177 177 + {:mod, :x, 26}, 178 178 + {:div, :z, 1}, 179 179 + {:add, :x, 15}, 180 180 + {:eql, :x, :w}, 181 181 + {:eql, :x, 0}, 182 182 + {:mul, :y, 0}, 183 183 + {:add, :y, 25}, 184 184 + {:mul, :y, :x}, 185 185 + {:add, :y, 1}, 186 186 + {:mul, :z, :y}, 187 187 + {:mul, :y, 0}, 188 188 + {:add, :y, :w}, 189 189 + {:add, :y, 11}, 190 190 + {:mul, :y, :x}, 191 191 + {:add, :z, :y}, 192 192 + {:inp, :w}, 193 193 + {:mul, :x, 0}, 194 194 + {:add, :x, :z}, 195 195 + {:mod, :x, 26}, 196 196 + {:div, :z, 26}, 197 197 + {:add, :x, -16}, 198 198 + {:eql, :x, :w}, 199 199 + {:eql, :x, 0}, 200 200 + {:mul, :y, 0}, 201 201 + {:add, :y, 25}, 202 202 + {:mul, :y, :x}, 203 203 + {:add, :y, 1}, 204 204 + {:mul, :z, :y}, 205 205 + {:mul, :y, 0}, 206 206 + {:add, :y, :w}, 207 207 + {:add, :y, 4}, 208 208 + {:mul, :y, :x}, 209 209 + {:add, :z, :y}, 210 210 + {:inp, :w}, 211 211 + {:mul, :x, 0}, 212 212 + {:add, :x, :z}, 213 213 + {:mod, :x, 26}, 214 214 + {:div, :z, 1}, 215 215 + {:add, :x, 14}, 216 216 + {:eql, :x, :w}, 217 217 + {:eql, :x, 0}, 218 218 + {:mul, :y, 0}, 219 219 + {:add, :y, 25}, 220 220 + {:mul, :y, :x}, 221 221 + {:add, :y, 1}, 222 222 + {:mul, :z, :y}, 223 223 + {:mul, :y, 0}, 224 224 + {:add, :y, :w}, 225 225 + {:add, :y, 12}, 226 226 + {:mul, :y, :x}, 227 227 + {:add, :z, :y}, 228 228 + {:inp, :w}, 229 229 + {:mul, :x, 0}, 230 230 + {:add, :x, :z}, 231 231 + {:mod, :x, 26}, 232 232 + {:div, :z, 1}, 233 233 + {:add, :x, 15}, 234 234 + {:eql, :x, :w}, 235 235 + {:eql, :x, 0}, 236 236 + {:mul, :y, 0}, 237 237 + {:add, :y, 25}, 238 238 + {:mul, :y, :x}, 239 239 + {:add, :y, 1}, 240 240 + {:mul, :z, :y}, 241 241 + {:mul, :y, 0}, 242 242 + {:add, :y, :w}, 243 243 + {:add, :y, 9}, 244 244 + {:mul, :y, :x}, 245 245 + {:add, :z, :y}, 246 246 + {:inp, :w}, 247 247 + {:mul, :x, 0}, 248 248 + {:add, :x, :z}, 249 249 + {:mod, :x, 26}, 250 250 + {:div, :z, 26}, 251 251 + {:add, :x, -7}, 252 252 + {:eql, :x, :w}, 253 253 + {:eql, :x, 0}, 254 254 + {:mul, :y, 0}, 255 255 + {:add, :y, 25}, 256 256 + {:mul, :y, :x}, 257 257 + {:add, :y, 1}, 258 258 + {:mul, :z, :y}, 259 259 + {:mul, :y, 0}, 260 260 + {:add, :y, :w}, 261 261 + {:add, :y, 10}, 262 262 + {:mul, :y, :x}, 263 263 + {:add, :z, :y}, 264 264 + {:inp, :w}, 265 265 + {:mul, :x, 0}, 266 266 + {:add, :x, :z}, 267 267 + {:mod, :x, 26}, 268 268 + {:div, :z, 26}, 269 269 + {:add, :x, -11}, 270 270 + {:eql, :x, :w}, 271 271 + {:eql, :x, 0}, 272 272 + {:mul, :y, 0}, 273 273 + {:add, :y, 25}, 274 274 + {:mul, :y, :x}, 275 275 + {:add, :y, 1}, 276 276 + {:mul, :z, :y}, 277 277 + {:mul, :y, 0}, 278 278 + {:add, :y, :w}, 279 279 + {:add, :y, 11}, 280 280 + {:mul, :y, :x}, 281 281 + {:add, :z, :y}, 282 282 + {:inp, :w}, 283 283 + {:mul, :x, 0}, 284 284 + {:add, :x, :z}, 285 285 + {:mod, :x, 26}, 286 286 + {:div, :z, 26}, 287 287 + {:add, :x, -6}, 288 288 + {:eql, :x, :w}, 289 289 + {:eql, :x, 0}, 290 290 + {:mul, :y, 0}, 291 291 + {:add, :y, 25}, 292 292 + {:mul, :y, :x}, 293 293 + {:add, :y, 1}, 294 294 + {:mul, :z, :y}, 295 295 + {:mul, :y, 0}, 296 296 + {:add, :y, :w}, 297 297 + {:add, :y, 6}, 298 298 + {:mul, :y, :x}, 299 299 + {:add, :z, :y}, 300 300 + {:inp, :w}, 301 301 + {:mul, :x, 0}, 302 302 + {:add, :x, :z}, 303 303 + {:mod, :x, 26}, 304 304 + {:div, :z, 26}, 305 305 + {:add, :x, -11}, 306 306 + {:eql, :x, :w}, 307 307 + {:eql, :x, 0}, 308 308 + {:mul, :y, 0}, 309 309 + {:add, :y, 25}, 310 310 + {:mul, :y, :x}, 311 311 + {:add, :y, 1}, 312 312 + {:mul, :z, :y}, 313 313 + {:mul, :y, 0}, 314 314 + {:add, :y, :w}, 315 315 + {:add, :y, 15}, 316 316 + {:mul, :y, :x}, 317 317 + {:add, :z, :y} 318 318 + ] 319 319 + ``` 320 320 + 321 321 + <!-- livebook:{"output":true} --> 322 322 + 323 323 + ``` 324 324 + 252 325 325 + ``` 326 326 + 327 327 + ```elixir 328 328 + 44..52 |> Enum.map(&rem(&1, 26)) 329 329 + ``` 330 330 + 331 331 + <!-- livebook:{"output":true} --> 332 332 + 333 333 + ``` 334 334 + [18, 19, 20, 21, 22, 23, 24, 25, 0] 335 335 + ``` 336 336 + 337 337 + ```elixir 338 338 + IO.inspect(Day24.evaluate(input, 11_111_111_111_161)) 339 339 + ``` 340 340 + 341 341 + <!-- livebook:{"output":true} --> 342 342 + 343 343 + ``` 344 344 + %{w: 1, x: 1, y: 16, z: 207697766} 345 345 + ``` 346 346 + 347 347 + <!-- livebook:{"output":true} --> 348 348 + 349 349 + ``` 350 350 + %{w: 1, x: 1, y: 16, z: 207697766} 351 351 + ```

+252

2021/day24.txt

··· 1 1 + inp w 2 2 + mul x 0 3 3 + add x z 4 4 + mod x 26 5 5 + div z 1 6 6 + add x 11 7 7 + eql x w 8 8 + eql x 0 9 9 + mul y 0 10 10 + add y 25 11 11 + mul y x 12 12 + add y 1 13 13 + mul z y 14 14 + mul y 0 15 15 + add y w 16 16 + add y 16 17 17 + mul y x 18 18 + add z y 19 19 + inp w 20 20 + mul x 0 21 21 + add x z 22 22 + mod x 26 23 23 + div z 1 24 24 + add x 12 25 25 + eql x w 26 26 + eql x 0 27 27 + mul y 0 28 28 + add y 25 29 29 + mul y x 30 30 + add y 1 31 31 + mul z y 32 32 + mul y 0 33 33 + add y w 34 34 + add y 11 35 35 + mul y x 36 36 + add z y 37 37 + inp w 38 38 + mul x 0 39 39 + add x z 40 40 + mod x 26 41 41 + div z 1 42 42 + add x 13 43 43 + eql x w 44 44 + eql x 0 45 45 + mul y 0 46 46 + add y 25 47 47 + mul y x 48 48 + add y 1 49 49 + mul z y 50 50 + mul y 0 51 51 + add y w 52 52 + add y 12 53 53 + mul y x 54 54 + add z y 55 55 + inp w 56 56 + mul x 0 57 57 + add x z 58 58 + mod x 26 59 59 + div z 26 60 60 + add x -5 61 61 + eql x w 62 62 + eql x 0 63 63 + mul y 0 64 64 + add y 25 65 65 + mul y x 66 66 + add y 1 67 67 + mul z y 68 68 + mul y 0 69 69 + add y w 70 70 + add y 12 71 71 + mul y x 72 72 + add z y 73 73 + inp w 74 74 + mul x 0 75 75 + add x z 76 76 + mod x 26 77 77 + div z 26 78 78 + add x -3 79 79 + eql x w 80 80 + eql x 0 81 81 + mul y 0 82 82 + add y 25 83 83 + mul y x 84 84 + add y 1 85 85 + mul z y 86 86 + mul y 0 87 87 + add y w 88 88 + add y 12 89 89 + mul y x 90 90 + add z y 91 91 + inp w 92 92 + mul x 0 93 93 + add x z 94 94 + mod x 26 95 95 + div z 1 96 96 + add x 14 97 97 + eql x w 98 98 + eql x 0 99 99 + mul y 0 100 100 + add y 25 101 101 + mul y x 102 102 + add y 1 103 103 + mul z y 104 104 + mul y 0 105 105 + add y w 106 106 + add y 2 107 107 + mul y x 108 108 + add z y 109 109 + inp w 110 110 + mul x 0 111 111 + add x z 112 112 + mod x 26 113 113 + div z 1 114 114 + add x 15 115 115 + eql x w 116 116 + eql x 0 117 117 + mul y 0 118 118 + add y 25 119 119 + mul y x 120 120 + add y 1 121 121 + mul z y 122 122 + mul y 0 123 123 + add y w 124 124 + add y 11 125 125 + mul y x 126 126 + add z y 127 127 + inp w 128 128 + mul x 0 129 129 + add x z 130 130 + mod x 26 131 131 + div z 26 132 132 + add x -16 133 133 + eql x w 134 134 + eql x 0 135 135 + mul y 0 136 136 + add y 25 137 137 + mul y x 138 138 + add y 1 139 139 + mul z y 140 140 + mul y 0 141 141 + add y w 142 142 + add y 4 143 143 + mul y x 144 144 + add z y 145 145 + inp w 146 146 + mul x 0 147 147 + add x z 148 148 + mod x 26 149 149 + div z 1 150 150 + add x 14 151 151 + eql x w 152 152 + eql x 0 153 153 + mul y 0 154 154 + add y 25 155 155 + mul y x 156 156 + add y 1 157 157 + mul z y 158 158 + mul y 0 159 159 + add y w 160 160 + add y 12 161 161 + mul y x 162 162 + add z y 163 163 + inp w 164 164 + mul x 0 165 165 + add x z 166 166 + mod x 26 167 167 + div z 1 168 168 + add x 15 169 169 + eql x w 170 170 + eql x 0 171 171 + mul y 0 172 172 + add y 25 173 173 + mul y x 174 174 + add y 1 175 175 + mul z y 176 176 + mul y 0 177 177 + add y w 178 178 + add y 9 179 179 + mul y x 180 180 + add z y 181 181 + inp w 182 182 + mul x 0 183 183 + add x z 184 184 + mod x 26 185 185 + div z 26 186 186 + add x -7 187 187 + eql x w 188 188 + eql x 0 189 189 + mul y 0 190 190 + add y 25 191 191 + mul y x 192 192 + add y 1 193 193 + mul z y 194 194 + mul y 0 195 195 + add y w 196 196 + add y 10 197 197 + mul y x 198 198 + add z y 199 199 + inp w 200 200 + mul x 0 201 201 + add x z 202 202 + mod x 26 203 203 + div z 26 204 204 + add x -11 205 205 + eql x w 206 206 + eql x 0 207 207 + mul y 0 208 208 + add y 25 209 209 + mul y x 210 210 + add y 1 211 211 + mul z y 212 212 + mul y 0 213 213 + add y w 214 214 + add y 11 215 215 + mul y x 216 216 + add z y 217 217 + inp w 218 218 + mul x 0 219 219 + add x z 220 220 + mod x 26 221 221 + div z 26 222 222 + add x -6 223 223 + eql x w 224 224 + eql x 0 225 225 + mul y 0 226 226 + add y 25 227 227 + mul y x 228 228 + add y 1 229 229 + mul z y 230 230 + mul y 0 231 231 + add y w 232 232 + add y 6 233 233 + mul y x 234 234 + add z y 235 235 + inp w 236 236 + mul x 0 237 237 + add x z 238 238 + mod x 26 239 239 + div z 26 240 240 + add x -11 241 241 + eql x w 242 242 + eql x 0 243 243 + mul y 0 244 244 + add y 25 245 245 + mul y x 246 246 + add y 1 247 247 + mul z y 248 248 + mul y 0 249 249 + add y w 250 250 + add y 15 251 251 + mul y x 252 252 + 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