···

       
838
       
838
       
 
       
{:module, Day10, <<70, 79, 82, 49, 0, 0, 7, ...>>, {:parse, 2}}

     

       
839
       
839
       
 
       
```

     

       
840
       
840
       
 
       


     

       
841
       
841
       
+
       
### Task 1

     

       
842
       
842
       
+
       


     

       
841
       
843
       
 
       
```elixir

     

       
842
       
844
       
 
       
points = %{

     

       
843
       
845
       
 
       
  ?) => 3,

     
···

       
858
       
860
       
 
       
```output

     

       
859
       
861
       
 
       
288291

     

       
860
       
862
       
 
       
```

     

       
863
       
863
       
+
       


     

       
864
       
864
       
+
       
### Task 2

     

       
861
       
865
       
 
       


     

       
862
       
866
       
 
       
```elixir

     

       
863
       
867
       
 
       
points = %{

     
···

       
919
       
923
       
 
       


     

       
920
       
924
       
 
       
  @diffs for dx <- -1..1, dy <- -1..1, dx != 0 or dy != 0, do: {dx, dy}

     

       
921
       
925
       
 
       


     

       
922
       
922
       
-
       
  IO.inspect(@diffs)

     

       
923
       
923
       
-
       


     

       
924
       
926
       
 
       
  def lightup(map, n) do

     

       
925
       
927
       
 
       
    map

     

       
926
       
928
       
 
       
    |> Enum.reduce({map, 0}, fn

     
···

       
951
       
953
       
 
       
```

     

       
952
       
954
       
 
       


     

       
953
       
955
       
 
       
```output

     

       
954
       
954
       
-
       
[{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}]

     

       
956
       
956
       
+
       
{:module, Day11, <<70, 79, 82, 49, 0, 0, 11, ...>>, {:lightup, 2}}

     

       
955
       
957
       
 
       
```

     

       
956
       
958
       
 
       


     

       
957
       
957
       
-
       
```output

     

       
958
       
958
       
-
       
{:module, Day11, <<70, 79, 82, 49, 0, 0, 11, ...>>, {:lightup, 2}}

     

       
959
       
959
       
-
       
```

     

       
959
       
959
       
+
       
### Task 1

     

       
960
       
960
       
 
       


     

       
961
       
961
       
 
       
```elixir

     

       
962
       
962
       
 
       
draw = fn map ->

     
···

       
978
       
978
       
 
       
```output

     

       
979
       
979
       
 
       
1688

     

       
980
       
980
       
 
       
```

     

       
981
       
981
       
+
       


     

       
982
       
982
       
+
       
### Task 2

     

       
981
       
983
       
 
       


     

       
982
       
984
       
 
       
```elixir

     

       
983
       
985
       
 
       
Stream.unfold(1, &{&1, &1 + 1})

     
···

       
1052
       
1054
       
 
       
{:module, Day12, <<70, 79, 82, 49, 0, 0, 15, ...>>, {:small?, 1}}

     

       
1053
       
1055
       
 
       
```

     

       
1054
       
1056
       
 
       


     

       
1057
       
1057
       
+
       
### Task 1

     

       
1058
       
1058
       
+
       


     

       
1055
       
1059
       
 
       
```elixir

     

       
1056
       
1060
       
 
       
Day12.dfs(graph, "start", "end")

     

       
1057
       
1061
       
 
       
```

     
···

       
1059
       
1063
       
 
       
```output

     

       
1060
       
1064
       
 
       
4167

     

       
1061
       
1065
       
 
       
```

     

       
1066
       
1066
       
+
       


     

       
1067
       
1067
       
+
       
### Task 2

     

       
1062
       
1068
       
 
       


     

       
1063
       
1069
       
 
       
```elixir

     

       
1064
       
1070
       
 
       
Day12.dfs2(graph, "start", "end")

     
···

       
1131
       
1137
       
 
       
{:module, Day13, <<70, 79, 82, 49, 0, 0, 13, ...>>, {:draw, 1}}

     

       
1132
       
1138
       
 
       
```

     

       
1133
       
1139
       
 
       


     

       
1140
       
1140
       
+
       
### Task 1

     

       
1141
       
1141
       
+
       


     

       
1134
       
1142
       
 
       
```elixir

     

       
1135
       
1143
       
 
       
Day13.fold(hd(folds), input) |> MapSet.size()

     

       
1136
       
1144
       
 
       
```

     
···

       
1138
       
1146
       
 
       
```output

     

       
1139
       
1147
       
 
       
802

     

       
1140
       
1148
       
 
       
```

     

       
1149
       
1149
       
+
       


     

       
1150
       
1150
       
+
       
### Task 2

     

       
1141
       
1151
       
 
       


     

       
1142
       
1152
       
 
       
```elixir

     

       
1143
       
1153
       
 
       
Enum.reduce(folds, input, &Day13.fold/2)

     
···

       
1219
       
1229
       
 
       
{:module, Day14, <<70, 79, 82, 49, 0, 0, 13, ...>>, {:frequencies, 1}}

     

       
1220
       
1230
       
 
       
```

     

       
1221
       
1231
       
 
       


     

       
1232
       
1232
       
+
       
### Task 1

     

       
1233
       
1233
       
+
       


     

       
1222
       
1234
       
 
       
```elixir

     

       
1223
       
1235
       
 
       
{{_, min}, {_, max}} =

     

       
1224
       
1236
       
 
       
  1..10

     
···

       
1235
       
1247
       
 
       
```output

     

       
1236
       
1248
       
 
       
2768

     

       
1237
       
1249
       
 
       
```

     

       
1250
       
1250
       
+
       


     

       
1251
       
1251
       
+
       
### Task 2

     

       
1238
       
1252
       
 
       


     

       
1239
       
1253
       
 
       
```elixir

     

       
1240
       
1254
       
 
       
{{_, min}, {_, max}} =

     
···

       
1275
       
1289
       
 
       
{99, 99}

     

       
1276
       
1290
       
 
       
```

     

       
1277
       
1291
       
 
       


     

       
1292
       
1292
       
+
       
### Task 1

     

       
1293
       
1293
       
+
       


     

       
1278
       
1294
       
 
       
```elixir

     

       
1279
       
1295
       
 
       
shortest_paths =

     

       
1280
       
1296
       
 
       
  for y <- height..0//-1,

     
···

       
1299
       
1315
       
 
       
```output

     

       
1300
       
1316
       
 
       
429

     

       
1301
       
1317
       
 
       
```

     

       
1318
       
1318
       
+
       


     

       
1319
       
1319
       
+
       
### Task 2

     

       
1302
       
1320
       
 
       


     

       
1303
       
1321
       
 
       
```elixir

     

       
1304
       
1322
       
 
       
defmodule Day15.Task2 do

     
···

       
1913
       
1931
       
 
       
}

     

       
1914
       
1932
       
 
       
```

     

       
1915
       
1933
       
 
       


     

       
1934
       
1934
       
+
       
### Task 1

     

       
1935
       
1935
       
+
       


     

       
1916
       
1936
       
 
       
```elixir

     

       
1917
       
1937
       
 
       
defmodule Day16.Task1 do

     

       
1918
       
1938
       
 
       
  alias Day16.Packet

     
···

       
1930
       
1950
       
 
       
```output

     

       
1931
       
1951
       
 
       
949

     

       
1932
       
1952
       
 
       
```

     

       
1953
       
1953
       
+
       


     

       
1954
       
1954
       
+
       
### Task 2

     

       
1933
       
1955
       
 
       


     

       
1934
       
1956
       
 
       
```elixir

     

       
1935
       
1957
       
 
       
defmodule Day16.Task2 do