comparing cba613647cf85fd1cd5feb25b6568205d245b117 and master on hauleth.dev/advent-of-code

+187

2024/day06.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 06

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc, :arrays])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiI2Iiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjQifQ","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "6", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok,

     

       22
       22
       +
        "...#..................#...................#......................#..............................#.............................#...\n....#.......................#........#.#..............##...........#.....#..........#..........................#..................\n.............#........................................................................#.........#.#..#..#..........#..............\n..........#.......#..........#..................#........##...................#..............#....................................\n....................#..........................................................#..#.....................................#.........\n....#............................#..............................................#.....................#..........##....#..........\n.......#.............#......................................................................#.............#.........#.............\n....###......................#....#...........#.....#................................#..........................#.................\n..........#..#...........#..#........................................................#.....#...........#................#.........\n..#....#......#....#....#...................................................................#.....................................\n....................#............#............................................#......#....#...............................#.......\n..........#.......#.........#.......#.............................................................................................\n.......#...#.......................................#...................#..........................................................\n.......#........#............................#.....#.......#..............................................#..................#...#\n.....................#.................................#................#...#...............#.....#.#..........................#..\n.....#..........................................#......................#.............##..............................#........#...\n.....#......#.........................#..........................#..........................................................#..#..\n.#......#.............#......#.................................................#.....#...................##......#................\n.............................................................................##...................................................\n........................................#.......................................#........#.............................#.#.......#\n...........#.....................................#.............................#......#......#..#....................#..#.........\n.............................................#.......................#..................##....#.....#.............................\n........................#..............................................................#..........................................\n#..............#.........................#........#...#...............#..............#..................#....................##...\n...#...#.............................#.......#................................................#........................#....#.....\n.....#.........................#..#.......................#..........#.....................#..................#.#.....#...........\n..................#........#..#.......#...................................................................................#....#..\n..#...#...............................................#.#..#........................................................#....#......#.\n...............#...............#..........................#............................#..........#.............#.................\n............#.....#........#.........................................................#........#........#.....#........#......#....\n............................#.........#....#........#.....#...#.............#.................................#...................\n........#..................#....#.." <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       map =

     

       27
       27
       +
         puzzle_input

     

       28
       28
       +
         |> String.split("\n", trim: true)

     

       29
       29
       +
         |> Enum.with_index()

     

       30
       30
       +
         |> Enum.flat_map(fn {row, y} ->

     

       31
       31
       +
           row

     

       32
       32
       +
           |> String.to_charlist()

     

       33
       33
       +
           |> Enum.with_index()

     

       34
       34
       +
           |> Enum.map(fn {v, x} -> {{y, x}, v} end)

     

       35
       35
       +
         end)

     

       36
       36
       +
         |> Map.new()

     

       37
       37
       +
       ```

     

       38
       38
       +
       

     

       39
       39
       +
       <!-- livebook:{"output":true} -->

     

       40
       40
       +
       

     

       41
       41
       +
       ```

     

       42
       42
       +
       %{

     

       43
       43
       +
         {18, 103} => 46,

     

       44
       44
       +
         {76, 13} => 46,

     

       45
       45
       +
         {61, 121} => 46,

     

       46
       46
       +
         {37, 47} => 46,

     

       47
       47
       +
         {65, 63} => 46,

     

       48
       48
       +
         {77, 129} => 46,

     

       49
       49
       +
         {120, 47} => 46,

     

       50
       50
       +
         {38, 2} => 46,

     

       51
       51
       +
         {1, 26} => 46,

     

       52
       52
       +
         {116, 69} => 46,

     

       53
       53
       +
         {124, 56} => 46,

     

       54
       54
       +
         {83, 76} => 46,

     

       55
       55
       +
         {117, 125} => 46,

     

       56
       56
       +
         {32, 15} => 46,

     

       57
       57
       +
         {103, 106} => 46,

     

       58
       58
       +
         {30, 113} => 46,

     

       59
       59
       +
         {123, 104} => 46,

     

       60
       60
       +
         {124, 60} => 46,

     

       61
       61
       +
         {89, 14} => 46,

     

       62
       62
       +
         {35, 30} => 46,

     

       63
       63
       +
         {37, 53} => 46,

     

       64
       64
       +
         {4, 5} => 46,

     

       65
       65
       +
         {8, 50} => 46,

     

       66
       66
       +
         {78, 98} => 46,

     

       67
       67
       +
         {101, 62} => 46,

     

       68
       68
       +
         {95, 56} => 46,

     

       69
       69
       +
         {74, 12} => 46,

     

       70
       70
       +
         {102, 74} => 46,

     

       71
       71
       +
         {11, 39} => 46,

     

       72
       72
       +
         {65, 43} => 46,

     

       73
       73
       +
         {22, 38} => 46,

     

       74
       74
       +
         {14, 86} => 46,

     

       75
       75
       +
         {49, 117} => 46,

     

       76
       76
       +
         {20, 41} => 46,

     

       77
       77
       +
         {29, 25} => 46,

     

       78
       78
       +
         {86, 10} => 46,

     

       79
       79
       +
         {83, 36} => 46,

     

       80
       80
       +
         {29, 26} => 46,

     

       81
       81
       +
         {47, 27} => 46,

     

       82
       82
       +
         {4, 81} => 46,

     

       83
       83
       +
         {31, 42} => 46,

     

       84
       84
       +
         {9, 34} => 46,

     

       85
       85
       +
         {13, 124} => 46,

     

       86
       86
       +
         {90, 0} => 46,

     

       87
       87
       +
         {14, 122} => 46,

     

       88
       88
       +
         {120, 42} => 46,

     

       89
       89
       +
         {121, 77} => 46,

     

       90
       90
       +
         {103, 39} => 46,

     

       91
       91
       +
         {102, ...} => 46,

     

       92
       92
       +
         {...} => 46,

     

       93
       93
       +
         ...

     

       94
       94
       +
       }

     

       95
       95
       +
       ```

     

       96
       96
       +
       

     

       97
       97
       +
       ```elixir

     

       98
       98
       +
       {start_pos, _} = start = Enum.find(map, fn {_pos, v} -> v in ~c'^>v<' end)

     

       99
       99
       +
       

     

       100
       100
       +
       map = Map.replace(map, start_pos, ?.)

     

       101
       101
       +
       

     

       102
       102
       +
       start

     

       103
       103
       +
       ```

     

       104
       104
       +
       

     

       105
       105
       +
       <!-- livebook:{"output":true} -->

     

       106
       106
       +
       

     

       107
       107
       +
       ```

     

       108
       108
       +
       {{93, 71}, 94}

     

       109
       109
       +
       ```

     

       110
       110
       +
       

     

       111
       111
       +
       ```elixir

     

       112
       112
       +
       defmodule Guard do

     

       113
       113
       +
         def walk(map, start),

     

       114
       114
       +
           do: walk(map, start, MapSet.new())

     

       115
       115
       +
       

     

       116
       116
       +
         defp walk(map, {pos, dir} = curr, visited) do

     

       117
       117
       +
           if curr in visited do

     

       118
       118
       +
             :loop

     

       119
       119
       +
           else

     

       120
       120
       +
             visited = MapSet.put(visited, curr)

     

       121
       121
       +
       

     

       122
       122
       +
             case Map.fetch(map, next(pos, dir)) do

     

       123
       123
       +
               {:ok, ?#} ->

     

       124
       124
       +
                 walk(map, {pos, turn(dir)}, visited)

     

       125
       125
       +
       

     

       126
       126
       +
               {:ok, ?.} ->

     

       127
       127
       +
                 walk(map, {next(pos, dir), dir}, visited)

     

       128
       128
       +
       

     

       129
       129
       +
               :error ->

     

       130
       130
       +
                 MapSet.new(visited, fn {pos, _} -> pos end)

     

       131
       131
       +
             end

     

       132
       132
       +
           end

     

       133
       133
       +
         end

     

       134
       134
       +
       

     

       135
       135
       +
         defp next({y, x}, ?^), do: {y - 1, x}

     

       136
       136
       +
         defp next({y, x}, ?>), do: {y, x + 1}

     

       137
       137
       +
         defp next({y, x}, ?v), do: {y + 1, x}

     

       138
       138
       +
         defp next({y, x}, ?<), do: {y, x - 1}

     

       139
       139
       +
       

     

       140
       140
       +
         defp turn(?^), do: ?>

     

       141
       141
       +
         defp turn(?>), do: ?v

     

       142
       142
       +
         defp turn(?v), do: ?<

     

       143
       143
       +
         defp turn(?<), do: ?^

     

       144
       144
       +
       end

     

       145
       145
       +
       ```

     

       146
       146
       +
       

     

       147
       147
       +
       <!-- livebook:{"output":true} -->

     

       148
       148
       +
       

     

       149
       149
       +
       ```

     

       150
       150
       +
       {:module, Guard, <<70, 79, 82, 49, 0, 0, 12, ...>>, {:turn, 1}}

     

       151
       151
       +
       ```

     

       152
       152
       +
       

     

       153
       153
       +
       ## Part 1

     

       154
       154
       +
       

     

       155
       155
       +
       ```elixir

     

       156
       156
       +
       orig_path = Guard.walk(map, start)

     

       157
       157
       +
         

     

       158
       158
       +
       MapSet.size(orig_path)

     

       159
       159
       +
       ```

     

       160
       160
       +
       

     

       161
       161
       +
       <!-- livebook:{"output":true} -->

     

       162
       162
       +
       

     

       163
       163
       +
       ```

     

       164
       164
       +
       4433

     

       165
       165
       +
       ```

     

       166
       166
       +
       

     

       167
       167
       +
       ## Part 2

     

       168
       168
       +
       

     

       169
       169
       +
       ```elixir

     

       170
       170
       +
       orig_path

     

       171
       171
       +
       |> MapSet.delete(start_pos)

     

       172
       172
       +
       |> Task.async_stream(fn point ->

     

       173
       173
       +
         map

     

       174
       174
       +
         |> Map.put(point, ?#)

     

       175
       175
       +
         |> Guard.walk(start)

     

       176
       176
       +
         |> Kernel.==(:loop)

     

       177
       177
       +
         end, ordered: false)

     

       178
       178
       +
       |> Enum.count(& &1)

     

       179
       179
       +
       ```

     

       180
       180
       +
       

     

       181
       181
       +
       <!-- livebook:{"output":true} -->

     

       182
       182
       +
       

     

       183
       183
       +
       ```

     

       184
       184
       +
       4432

     

       185
       185
       +
       ```

     

       186
       186
       +
       

     

       187
       187
       +
       <!-- livebook:{"offset":7376,"stamp":{"token":"XCP.Bv-aM7sns5Kb69SQdY4giDFl6fWiJ5L3lnISxUUjGi_DgTgM_r5rl-y8sy2RLl-KbEtOmW99QQsGItLYJhKJmkOZ5pPZ_7Aw3BhkL_ap8RnW8UkOt_OsNdpqoZT7FEDtmFQ","version":2}} -->

+205

2024/day07.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 07

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiI3Iiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjQifQ","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "7", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok,

     

       22
       22
       +
        "644197722674: 5 9 46 99 1 5 9 2 22 6 74\n3424919: 67 51 7 561 358\n7160145: 9 9 7 4 8 3 91 2 3 3 5 731\n1133404163: 231 3 49 2 32 128 36\n198444: 9 77 90 347 308 46 3\n258135: 7 61 68 6 249 6\n10677865: 864 7 4 1 9 4 7 7 1 5 367\n1134: 54 7 3\n28760910: 1 6 627 9 752 831\n6740: 82 236 356 10\n983873830: 977 6 267 606 830\n101904: 5 71 29 2 264\n8536122: 5 3 7 388 120\n818217: 8 27 21 484 92 5 214\n9221: 219 23 270 18 5\n216699547: 2 24 46 9 1 55 6 61 9 88\n19040: 434 4 5 2 41 713 28 54\n113740483608: 52 951 38 417 23 17\n1837300: 627 46 5 1 91 6 6 4\n21564: 6 143 330 9 5 9\n100992468: 4 4 2 9 7 69 3 24 92 8 6 8\n522672: 5 226 7 5\n72660535: 181 857 70 5 2 4 1 11\n1553455: 57 842 4 650 374 79\n177565304: 177 5 6 530 7\n123464883: 65 67 315 7 2 45\n162378: 47 799 75 702 74 3\n75882558: 4 4 9 3 8 7 5 29 5 4 57 5\n15486: 5 771 6 1 2 2 8 8 8 8 2 4\n195018949: 237 9 76 61 19 95 4 9 9\n120067914: 12 7 1 282 9 17 7 2 7 79\n10625355: 6 16 906 3 533\n714034: 2 3 60 7 7 90 325 9\n147283595568: 3 311 33 3 57 822 8 93\n2316922: 8 26 41 831 2 94\n182954295: 438 22 56 5 993 4\n17143497694679: 73 169 33 1 4 71 6 79\n758512003463: 3 2 790 700 4 2 2 34 63\n4146569285: 280 8 9 5 6 7 68 4 9 1 2 5\n31770235539495: 589 8 9 1 1 95 3 63 492\n2140548: 7 6 1 4 3 4 8 929 1 3 8 12\n12113461: 291 3 50 772 17 5 2 2\n9197820380208: 1 58 583 110 58 207\n1539915: 88 340 19 5 689\n198635345304: 19 711 980 6 44 341\n43172: 426 8 4 318 1 1 439 3 5\n53202: 5 3 7 1 4 79 62 6 6\n999074: 1 4 221 5 9 71\n107010: 2 1 29 410 3\n1207: 8 600 5 9 567 17 1\n963: 56 902 7\n3661: 87 42 4 3\n55680: 8 7 2 58 8 4\n1443280: 1 33 16 68 39 592\n11791444132: 954 3 412 412 9\n40408: 8 8 513 70 19\n895: 45 9 784 52 8\n3630590257: 5 787 5 98 113 94 57\n1219939: 9 5 183 9 3\n7243377: 1 231 8 2 1 36 6 5 795 3\n10281688290: 728 359 69 874 8 45\n52129140: 78 1 7 407 547 5 2 4 5\n844925: 778 18 78 6 8\n1517768001: 56 213 629 27 17\n1586: 26 1 18 35 9\n897822305: 10 89 7 8 222 55 52\n307677984: 38 946 58 79 2\n11629377: 7 10 83 82 37 548 6 79\n5706366: 203 30 937 6 1 26\n545930: 1 8 696 5 770\n21436: 57 94 4 4 1\n601219587: 2 5 1 2 1 1 4 1 1 912 327\n1210568: 5 3 9 86 1 1 98 2 8 97 6 8\n163672: 311 939 4 1 130 522\n816: 3 9 7 9 5 25 84 186 56\n413330: 71 9 181 504 50\n275151204: 5 8 9 8 4 3 433 1 5 6 7 3\n5565: 47 19 8 7 1 276\n5528836: 1 552 789 9 936\n30771: 42 81 5 12 9\n113510: 99 58 723\n2552925934889: 802 8 795 54 8 372 4 6\n13201: 45 124 77 31 159\n720468: 17 6 92 4 7\n22380384159: 7 8 166 29 159 1 3 2 8 2\n45770: 4 41 765 2 3\n32957: 4 28 886 71\n5110126: 6 173 214 66 8\n1762745: 982 227 3 3 27 3 6 5\n130796643: 131 32 1 5 5 624\n78364255: 8 9 694 57 7 253\n844276: 8 42 224 792 1\n362023: 9 25 594 5 5 40 87 103\n1291399844: 5 6 1 9 39 1 73 9 6 44\n228417920: 25 37 71 9 26 794 8 4\n40050828: 3 27 763 6 9 9 5 1 9 12\n116627652: 7 4 7 1 446 8 4 5 2 4 75 6\n2516095717: 7 385 8 43 59 8 5 46\n655270872: 9 2 8 159 89 2 9 3 89 95\n35298709: 6 41 170 3 2 422 97\n558606: 4 6 5 74 6 53 7 7 100 1 5\n96911: 5 9 75 6 9 665 2 7 9 2 7 8\n429735: 7 72 58 6 9\n9402: 3 453 9 86 920 1 7 88 6\n2948456: 69 251 9 68 456\n254061: 603 70 2 6 789\n27948: 485 575 322 262 17\n90873: 58 49 8 27 31 31 725\n6444009: 5 6 195 7 6 33 13\n17255343: 78 867 42 3 85\n144630242: 490 2 39 11 7 4 39 86 1\n444869: 4 7 8 878 5 479\n253242155: 42 203 6 7 234 57\n1823338: 2 414 9 487 4 6\n25234118: 91 683 58 7 1\n642484013: 917 822 4 6 1 7 9 1 2\n10018629: 99 944 235 99 628\n52518012: 663 80 8 5 99\n52968775714: 217 3 8 2 3 2 9 6 9 9 94 6\n7014: 1 666 9 933 8 70\n1210591: 39 8 40 97 31\n61925382: 366 648 1 1 9 837 29\n1392623100: 92 3 6 6 8 18 8 815 990\n146952: 66 53 92 6 677 43\n16148106: 41 31 9 5 4 39\n972134: 4 36 905 3 28 9 75 54 3\n1699: 9 7 94 2\n38915712: 66 83 4 3 296 2 1\n24871732: 71 178 3 656 148\n1016303031: 229 634 7 499 532\n553520: 7 3 7 22 69\n588423590: 2 1 9 143 8 3 6 923 1 3 4\n8360806312: 1 3 9 850 24 7 857 5 7 5\n462718: 4 6 26 93 26\n21935424: 280 60 96 2 4 2 84\n885836: 8 850 4 5 2 27 704 58 9\n797703006: 1 3 1 8 9 4 9 495 3 7 60 6\n7714822: 2 4 757 959 3 25\n233319196: 881 27 45 10 4 979\n451620568437: 170 6 57 4 9 5 56 8 439\n2836062720: 7 88 111 9 6 6 2 4 3 8 3 2\n81217110: 827 98 9 501 2\n21081: 6 3 41 6 3 1 6 324 8 5 8\n861: 7 7 2 " <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       #puzzle_input =

     

       27
       27
       +
         """

     

       28
       28
       +
         190: 10 19

     

       29
       29
       +
         3267: 81 40 27

     

       30
       30
       +
         83: 17 5

     

       31
       31
       +
         156: 15 6

     

       32
       32
       +
         7290: 6 8 6 15

     

       33
       33
       +
         161011: 16 10 13

     

       34
       34
       +
         192: 17 8 14

     

       35
       35
       +
         21037: 9 7 18 13

     

       36
       36
       +
         292: 11 6 16 20

     

       37
       37
       +
         """

     

       38
       38
       +
       

     

       39
       39
       +
       equations =

     

       40
       40
       +
         puzzle_input

     

       41
       41
       +
         |> String.split("\n", trim: true)

     

       42
       42
       +
         |> Enum.map(fn row ->

     

       43
       43
       +
           {target, ": " <> rest} = Integer.parse(row)

     

       44
       44
       +
       

     

       45
       45
       +
           values =

     

       46
       46
       +
             rest

     

       47
       47
       +
             |> String.split()

     

       48
       48
       +
             |> Enum.map(&String.to_integer/1)

     

       49
       49
       +
       

     

       50
       50
       +
           {target, values}

     

       51
       51
       +
         end)

     

       52
       52
       +
       ```

     

       53
       53
       +
       

     

       54
       54
       +
       <!-- livebook:{"output":true} -->

     

       55
       55
       +
       

     

       56
       56
       +
       ```

     

       57
       57
       +
       warning: code block contains unused literal "190: 10 19\n3267: 81 40 27\n83: 17 5\n156: 15 6\n7290: 6 8 6 15\n161011: 16 10 13\n192: 17 8 14\n21037: 9 7 18 13\n292: 11 6 16 20\n" (remove the literal or assign it to _ to avoid warnings)

     

       58
       58
       +
       └─ Workspace/hauleth/advent-of-code/2024/day07.livemd#cell:7pxlqq2wa3oqdwfr:1

     

       59
       59
       +
       

     

       60
       60
       +
       ```

     

       61
       61
       +
       

     

       62
       62
       +
       <!-- livebook:{"output":true} -->

     

       63
       63
       +
       

     

       64
       64
       +
       ```

     

       65
       65
       +
       [

     

       66
       66
       +
         {644197722674, [5, 9, 46, 99, 1, 5, 9, 2, 22, 6, 74]},

     

       67
       67
       +
         {3424919, [67, 51, 7, 561, 358]},

     

       68
       68
       +
         {7160145, [9, 9, 7, 4, 8, 3, 91, 2, 3, 3, 5, 731]},

     

       69
       69
       +
         {1133404163, [231, 3, 49, 2, 32, 128, 36]},

     

       70
       70
       +
         {198444, [9, 77, 90, 347, 308, 46, 3]},

     

       71
       71
       +
         {258135, [7, 61, 68, 6, 249, 6]},

     

       72
       72
       +
         {10677865, [864, 7, 4, 1, 9, 4, 7, 7, 1, 5, 367]},

     

       73
       73
       +
         {1134, [54, 7, 3]},

     

       74
       74
       +
         {28760910, [1, 6, 627, 9, 752, 831]},

     

       75
       75
       +
         {6740, [82, 236, 356, 10]},

     

       76
       76
       +
         {983873830, [977, 6, 267, 606, 830]},

     

       77
       77
       +
         {101904, [5, 71, 29, 2, 264]},

     

       78
       78
       +
         {8536122, [5, 3, 7, 388, 120]},

     

       79
       79
       +
         {818217, [8, 27, 21, 484, 92, 5, 214]},

     

       80
       80
       +
         {9221, [219, 23, 270, 18, 5]},

     

       81
       81
       +
         {216699547, [2, 24, 46, 9, 1, 55, 6, 61, 9, 88]},

     

       82
       82
       +
         {19040, [434, 4, 5, 2, 41, 713, 28, 54]},

     

       83
       83
       +
         {113740483608, [52, 951, 38, 417, 23, 17]},

     

       84
       84
       +
         {1837300, [627, 46, 5, 1, 91, 6, 6, 4]},

     

       85
       85
       +
         {21564, [6, 143, 330, 9, 5, 9]},

     

       86
       86
       +
         {100992468, [4, 4, 2, 9, 7, 69, 3, 24, 92, 8, 6, 8]},

     

       87
       87
       +
         {522672, [5, 226, 7, 5]},

     

       88
       88
       +
         {72660535, [181, 857, 70, 5, 2, 4, 1, 11]},

     

       89
       89
       +
         {1553455, [57, 842, 4, 650, 374, 79]},

     

       90
       90
       +
         {177565304, [177, 5, 6, 530, 7]},

     

       91
       91
       +
         {123464883, [65, 67, 315, 7, 2, 45]},

     

       92
       92
       +
         {162378, [47, 799, 75, 702, 74, 3]},

     

       93
       93
       +
         {75882558, [4, 4, 9, 3, 8, 7, 5, 29, 5, 4, 57, 5]},

     

       94
       94
       +
         {15486, [5, 771, 6, 1, 2, 2, 8, 8, 8, 8, 2, 4]},

     

       95
       95
       +
         {195018949, [237, 9, 76, 61, 19, 95, 4, 9, 9]},

     

       96
       96
       +
         {120067914, [12, 7, 1, 282, 9, 17, 7, 2, 7, 79]},

     

       97
       97
       +
         {10625355, [6, 16, 906, 3, 533]},

     

       98
       98
       +
         {714034, [2, 3, 60, 7, 7, 90, 325, 9]},

     

       99
       99
       +
         {147283595568, [3, 311, 33, 3, 57, 822, 8, 93]},

     

       100
       100
       +
         {2316922, [8, 26, 41, 831, 2, 94]},

     

       101
       101
       +
         {182954295, [438, 22, 56, 5, 993, 4]},

     

       102
       102
       +
         {17143497694679, [73, 169, 33, 1, 4, 71, 6, 79]},

     

       103
       103
       +
         {758512003463, [3, 2, 790, 700, 4, 2, 2, 34, 63]},

     

       104
       104
       +
         {4146569285, [280, 8, 9, 5, 6, 7, 68, 4, 9, ...]},

     

       105
       105
       +
         {31770235539495, [589, 8, 9, 1, 1, 95, 3, 63, ...]},

     

       106
       106
       +
         {2140548, [7, 6, 1, 4, 3, 4, 8, ...]},

     

       107
       107
       +
         {12113461, [291, 3, 50, 772, 17, 5, ...]},

     

       108
       108
       +
         {9197820380208, [1, 58, 583, 110, 58, ...]},

     

       109
       109
       +
         {1539915, [88, 340, 19, 5, ...]},

     

       110
       110
       +
         {198635345304, [19, 711, 980, ...]},

     

       111
       111
       +
         {43172, [426, 8, ...]},

     

       112
       112
       +
         {53202, [5, ...]},

     

       113
       113
       +
         {999074, [...]},

     

       114
       114
       +
         {107010, ...},

     

       115
       115
       +
         {...},

     

       116
       116
       +
         ...

     

       117
       117
       +
       ]

     

       118
       118
       +
       ```

     

       119
       119
       +
       

     

       120
       120
       +
       ## Part 1

     

       121
       121
       +
       

     

       122
       122
       +
       ```elixir

     

       123
       123
       +
       defmodule Eq.P1 do

     

       124
       124
       +
         def possible?(0, []), do: true

     

       125
       125
       +
         def possible?(a, [a]), do: true

     

       126
       126
       +
         def possible?(0, [_ | _]), do: false

     

       127
       127
       +
         def possible?(_, []), do: false

     

       128
       128
       +
         def possible?(a, _) when a < 0, do: false

     

       129
       129
       +
       

     

       130
       130
       +
         def possible?(a, [b | rest]) when rem(a, b) == 0 do

     

       131
       131
       +
           possible?(div(a, b), rest) or possible?(a - b, rest)

     

       132
       132
       +
         end

     

       133
       133
       +
       

     

       134
       134
       +
         def possible?(a, [b | rest]), do: possible?(a - b, rest)

     

       135
       135
       +
       end

     

       136
       136
       +
       ```

     

       137
       137
       +
       

     

       138
       138
       +
       <!-- livebook:{"output":true} -->

     

       139
       139
       +
       

     

       140
       140
       +
       ```

     

       141
       141
       +
       {:module, Eq.P1, <<70, 79, 82, 49, 0, 0, 8, ...>>, {:possible?, 2}}

     

       142
       142
       +
       ```

     

       143
       143
       +
       

     

       144
       144
       +
       ```elixir

     

       145
       145
       +
       equations

     

       146
       146
       +
       |> Enum.filter(fn {target, vals} ->

     

       147
       147
       +
         Eq.P1.possible?(target, Enum.reverse(vals))

     

       148
       148
       +
       end)

     

       149
       149
       +
       |> Enum.reduce(0, &(elem(&1, 0) + &2))

     

       150
       150
       +
       ```

     

       151
       151
       +
       

     

       152
       152
       +
       <!-- livebook:{"output":true} -->

     

       153
       153
       +
       

     

       154
       154
       +
       ```

     

       155
       155
       +
       3119088655389

     

       156
       156
       +
       ```

     

       157
       157
       +
       

     

       158
       158
       +
       ## Part 2

     

       159
       159
       +
       

     

       160
       160
       +
       ```elixir

     

       161
       161
       +
       defmodule Eq.P2 do

     

       162
       162
       +
         def possible?(a, [hd | rest]), do: possible?(a, hd, rest)

     

       163
       163
       +
       

     

       164
       164
       +
         defp possible?(a, a, []), do: true

     

       165
       165
       +
         defp possible?(_, _, []), do: false

     

       166
       166
       +
         defp possible?(a, b, _) when b > a, do: false

     

       167
       167
       +
       

     

       168
       168
       +
         defp possible?(target, curr, [a | rest]) do

     

       169
       169
       +
           possible?(target, concat(curr, a), rest) or

     

       170
       170
       +
             possible?(target, curr * a, rest) or

     

       171
       171
       +
             possible?(target, curr + a, rest)

     

       172
       172
       +
         end

     

       173
       173
       +
       

     

       174
       174
       +
         defp concat(a, b), do: a * l10(b) + b

     

       175
       175
       +
       

     

       176
       176
       +
         defp l10(n) when n >= 100, do: 1000

     

       177
       177
       +
         defp l10(n) when n >= 10, do: 100

     

       178
       178
       +
         defp l10(_), do: 10

     

       179
       179
       +
       end

     

       180
       180
       +
       ```

     

       181
       181
       +
       

     

       182
       182
       +
       <!-- livebook:{"output":true} -->

     

       183
       183
       +
       

     

       184
       184
       +
       ```

     

       185
       185
       +
       {:module, Eq.P2, <<70, 79, 82, 49, 0, 0, 9, ...>>, {:l10, 1}}

     

       186
       186
       +
       ```

     

       187
       187
       +
       

     

       188
       188
       +
       ```elixir

     

       189
       189
       +
       equations

     

       190
       190
       +
       |> Task.async_stream(

     

       191
       191
       +
         fn {target, vals} ->

     

       192
       192
       +
           if Eq.P2.possible?(target, vals), do: target, else: 0

     

       193
       193
       +
         end,

     

       194
       194
       +
         ordered: false

     

       195
       195
       +
       )

     

       196
       196
       +
       |> Enum.reduce(0, fn {:ok, val}, acc -> val + acc end)

     

       197
       197
       +
       ```

     

       198
       198
       +
       

     

       199
       199
       +
       <!-- livebook:{"output":true} -->

     

       200
       200
       +
       

     

       201
       201
       +
       ```

     

       202
       202
       +
       264184041398847

     

       203
       203
       +
       ```

     

       204
       204
       +
       

     

       205
       205
       +
       <!-- livebook:{"offset":9317,"stamp":{"token":"XCP.DCDL30p1jz3L9vRDdQ5EJLc3r7y1DTsVhQ3GXFK_huvoEXqgYu2TTOfTq8AFYpt5W6fEIo4MvfrnHttbqS-z4SjRkT7WM09v09mZ_FeyqstWzLMCK_oNqhrrdwPPv5BG_8c","version":2}} -->

+327

2024/day08.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 08

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiI4Iiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjQifQ","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "8", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok,

     

       22
       22
       +
        "..........M..........j.............y.....O........\n...B...............q......m........lGO............\n....................q......2.l.GQ...O.............\n.....X.......................................4....\n.....................q............................\n....M......P...............xl.K.............2.....\n....F.........L.......C.K..............m..........\n..........FM......P....jy......m..........o...r...\n..X.......P.....RL..............G..x..........4...\n............L..........NC.....q...................\n.....C.X...............K....y..........4..........\n........S...R.............j.x.....V...4...........\n.....................R..x.....V..i......m.........\n...........................R.V......N.......X.....\n.....F.........M......N......E....................\n................v................T.......F......O.\n.............................N...V.......Q........\n...v.....................C.....i..................\n......c.....W..n.w........................E.......\n3...................c.....................Q..6....\n...........h......................j...............\n.......n.0......h.................E..............2\n.v.............7.......120.....c..................\n......n.0............w...........D.t.........E...r\n....8..3......0.w.hP....z...D..T...............r..\n.................f........T........G......eQ......\n......f.n.....7..p................................\n.....Y..7.......f......I......D......K............\n............Uf....T..W.....D..r...i...............\n......I...............................Z...........\n....5....B.......b..............s..............Z..\n..........d...W..Uwh.............c..........i.....\n..I.3..Y......................e...................\n.....p.b..........k......7........................\np...........k....I..b..........s..................\n.....k.......o...........W........................\n.A..Y..........U.................a........6.......\n..A...Y.p...................................6.....\nB......k..........................Z............u..\n...3.....................s..............a.........\n......A.........................g.....a...........\n.......A....8...b.U......H....sS..................\n.........................S1.............t.........\n.....................9z..e.....5..1.g.u...........\n.......................z....d....g....H.J....o.6..\n........B................d.....u....9.J.H.........\n.8........S.................u9.............J.....H\n.....................Z5.............t1...........a\n.....................e..v...................o..t..\n.....8...............L.....z.............J........"}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       # puzzle_input =

     

       27
       27
       +
       """

     

       28
       28
       +
       ............

     

       29
       29
       +
       ........0...

     

       30
       30
       +
       .....0......

     

       31
       31
       +
       .......0....

     

       32
       32
       +
       ....0.......

     

       33
       33
       +
       ......A.....

     

       34
       34
       +
       ............

     

       35
       35
       +
       ............

     

       36
       36
       +
       ........A...

     

       37
       37
       +
       .........A..

     

       38
       38
       +
       ............

     

       39
       39
       +
       ............

     

       40
       40
       +
       """

     

       41
       41
       +
       

     

       42
       42
       +
       freqs =

     

       43
       43
       +
         puzzle_input

     

       44
       44
       +
         |> String.split("\n", trim: true)

     

       45
       45
       +
         |> Enum.with_index()

     

       46
       46
       +
         |> Enum.flat_map(fn {row, y} ->

     

       47
       47
       +
           row

     

       48
       48
       +
           |> String.to_charlist()

     

       49
       49
       +
           |> Enum.with_index()

     

       50
       50
       +
           |> Enum.filter(fn {freq, _} -> freq != ?. end)

     

       51
       51
       +
           |> Enum.map(fn {freq, x} -> {{x, y}, freq} end)

     

       52
       52
       +
         end)

     

       53
       53
       +
         |> Map.new()

     

       54
       54
       +
         |> Enum.group_by(&elem(&1, 1), &elem(&1, 0))

     

       55
       55
       +
       ```

     

       56
       56
       +
       

     

       57
       57
       +
       <!-- livebook:{"output":true} -->

     

       58
       58
       +
       

     

       59
       59
       +
       ```

     

       60
       60
       +
       warning: code block contains unused literal "............\n........0...\n.....0......\n.......0....\n....0.......\n......A.....\n............\n............\n........A...\n.........A..\n............\n............\n" (remove the literal or assign it to _ to avoid warnings)

     

       61
       61
       +
       └─ Workspace/hauleth/advent-of-code/2024/day08.livemd#cell:y5uv5vxll4fey6gh:1

     

       62
       62
       +
       

     

       63
       63
       +
       ```

     

       64
       64
       +
       

     

       65
       65
       +
       <!-- livebook:{"output":true} -->

     

       66
       66
       +
       

     

       67
       67
       +
       ```

     

       68
       68
       +
       %{

     

       69
       69
       +
         117 => [{28, 46}, {31, 45}, {38, 43}, {47, 38}],

     

       70
       70
       +
         73 => [{2, 32}, {17, 34}, {23, 27}, {6, 29}],

     

       71
       71
       +
         89 => [{4, 36}, {7, 32}, {6, 37}, {5, 27}],

     

       72
       72
       +
         48 => [{25, 22}, {9, 21}, {8, 23}, {14, 24}],

     

       73
       73
       +
         57 => [{29, 46}, {21, 43}, {36, 45}],

     

       74
       74
       +
         113 => [{30, 9}, {20, 2}, {21, 4}, {19, 1}],

     

       75
       75
       +
         69 => [{42, 18}, {34, 21}, {45, 23}, {29, 14}],

     

       76
       76
       +
         88 => [{7, 10}, {5, 3}, {44, 13}, {2, 8}],

     

       77
       77
       +
         100 => [{25, 45}, {28, 44}, {10, 31}],

     

       78
       78
       +
         71 => [{36, 1}, {35, 25}, {31, 2}, {32, 8}],

     

       79
       79
       +
         98 => [{16, 41}, {7, 33}, {20, 34}, {17, 30}],

     

       80
       80
       +
         81 => [{42, 19}, {41, 16}, {43, 25}, {32, 2}],

     

       81
       81
       +
         76 => [{12, 9}, {14, 6}, {17, 8}, {21, 49}],

     

       82
       82
       +
         85 => [{15, 36}, {12, 28}, {17, 31}, {18, 41}],

     

       83
       83
       +
         120 => [{27, 5}, {35, 8}, {28, 11}, {24, 12}],

     

       84
       84
       +
         109 => [{26, 1}, {39, 6}, {40, 12}, {31, 7}],

     

       85
       85
       +
         72 => [{38, 44}, {40, 45}, {49, 46}, {25, 41}],

     

       86
       86
       +
         110 => [{8, 26}, {7, 21}, {15, 18}, {6, 23}],

     

       87
       87
       +
         68 => [{30, 27}, {28, 24}, {27, 28}, {33, 23}],

     

       88
       88
       +
         86 => [{29, 13}, {33, 16}, {30, 12}, {34, 11}],

     

       89
       89
       +
         116 => [{35, 23}, {36, 47}, {47, 48}, {40, 42}],

     

       90
       90
       +
         51 => [{7, 24}, {0, 19}, {3, 39}, {4, 32}],

     

       91
       91
       +
         80 => [{18, 7}, {19, 24}, {10, 8}, {11, 5}],

     

       92
       92
       +
         77 => [{11, 7}, {15, 14}, {10, 0}, {4, 5}],

     

       93
       93
       +
         78 => [{22, 14}, {29, 16}, {36, 13}, {23, 9}],

     

       94
       94
       +
         108 => [{29, 2}, {28, 5}, {35, 1}],

     

       95
       95
       +
         103 => [{32, 40}, {36, 43}, {33, 44}],

     

       96
       96
       +
         122 => [{27, 49}, {23, 44}, {24, 24}, {22, 43}],

     

       97
       97
       +
         83 => [{10, 46}, {25, 42}, {31, 41}, {8, 11}],

     

       98
       98
       +
         74 => [{38, 45}, {41, 49}, {43, 46}, {40, 44}],

     

       99
       99
       +
         99 => [{31, 22}, {33, 31}, {20, 19}, {6, 18}],

     

       100
       100
       +
         112 => [{5, 33}, {17, 26}, {8, 37}, {0, 34}],

     

       101
       101
       +
         97 => [{38, 40}, {33, 36}, {49, 47}, {40, 39}],

     

       102
       102
       +
         104 => [{16, 21}, {19, 31}, {11, 20}, {18, 24}],

     

       103
       103
       +
         75 => [{30, 5}, {24, 6}, {23, 10}, {37, 27}],

     

       104
       104
       +
         90 => [{21, 47}, {47, 30}, {34, 38}, {38, 29}],

     

       105
       105
       +
         55 => [{15, 22}, {14, 26}, {8, 27}, {25, 33}],

     

       106
       106
       +
         52 => [{45, 3}, {38, 11}, {39, 10}, {46, 8}],

     

       107
       107
       +
         111 => [{13, 35}, {42, 7}, {45, 44}, {44, 48}],

     

       108
       108
       +
         87 => [{25, 35}, {12, 18}, {14, 31}, {21, 28}],

     

       109
       109
       +
         119 => [{21, 23}, {18, 31}, {17, 18}, {16, 24}],

     

       110
       110
       +
         82 => [{12, 11}, {27, 13}, {21, 12}, {16, 8}],

     

       111
       111
       +
         53 => [{22, 47}, {31, 43}, {4, 30}],

     

       112
       112
       +
         50 => [{27, 2}, {24, 22}, {44, 5}, {49, 21}],

     

       113
       113
       +
         66 => [{8, 45}, {9, 30}, {3, 1}, {0, ...}],

     

       114
       114
       +
         70 => [{5, 14}, {41, 15}, {10, ...}, {...}],

     

       115
       115
       +
         56 => [{12, 41}, {4, ...}, {...}, ...],

     

       116
       116
       +
         102 => [{17, ...}, {...}, ...],

     

       117
       117
       +
         105 => [{...}, ...],

     

       118
       118
       +
         121 => [...],

     

       119
       119
       +
         ...

     

       120
       120
       +
       }

     

       121
       121
       +
       ```

     

       122
       122
       +
       

     

       123
       123
       +
       ```elixir

     

       124
       124
       +
       {w, h} =

     

       125
       125
       +
         puzzle_input

     

       126
       126
       +
         |> String.split("\n", trim: true)

     

       127
       127
       +
         |> then(fn [a | _] = lst ->

     

       128
       128
       +
           {byte_size(a), length(lst)}

     

       129
       129
       +
         end)

     

       130
       130
       +
       ```

     

       131
       131
       +
       

     

       132
       132
       +
       <!-- livebook:{"output":true} -->

     

       133
       133
       +
       

     

       134
       134
       +
       ```

     

       135
       135
       +
       {50, 50}

     

       136
       136
       +
       ```

     

       137
       137
       +
       

     

       138
       138
       +
       ```elixir

     

       139
       139
       +
       defmodule Antennas do

     

       140
       140
       +
         def each_pair([]), do: []

     

       141
       141
       +
         def each_pair([a | rest]) do

     

       142
       142
       +
           for(b <- rest, do: {a, b}) ++ each_pair(rest)

     

       143
       143
       +
         end

     

       144
       144
       +
       

     

       145
       145
       +
         def antinodes({xa, ya}, {xb, yb}) do

     

       146
       146
       +
           dx = xa - xb

     

       147
       147
       +
           dy = ya - yb

     

       148
       148
       +
       

     

       149
       149
       +
           Stream.from_index()

     

       150
       150
       +
           |> Stream.flat_map(fn n ->

     

       151
       151
       +
             dx = dx * n

     

       152
       152
       +
             dy = dy * n

     

       153
       153
       +
             [{xa + dx, ya + dy}, {xb - dx, yb - dy}]

     

       154
       154
       +
           end)

     

       155
       155
       +
         end

     

       156
       156
       +
       end

     

       157
       157
       +
       ```

     

       158
       158
       +
       

     

       159
       159
       +
       <!-- livebook:{"output":true} -->

     

       160
       160
       +
       

     

       161
       161
       +
       ```

     

       162
       162
       +
       {:module, Antennas, <<70, 79, 82, 49, 0, 0, 10, ...>>, {:antinodes, 2}}

     

       163
       163
       +
       ```

     

       164
       164
       +
       

     

       165
       165
       +
       ## Part 1

     

       166
       166
       +
       

     

       167
       167
       +
       ```elixir

     

       168
       168
       +
       antinodes =

     

       169
       169
       +
         for {_, antennas} <- freqs,

     

       170
       170
       +
             {a, b} <- Antennas.each_pair(antennas),

     

       171
       171
       +
             {x, y} = node <- Antennas.antinodes(a, b) |> Stream.drop(2) |> Enum.take(2),

     

       172
       172
       +
             x in 0..(w - 1) and y in 0..(h - 1),

     

       173
       173
       +
             into: MapSet.new() do

     

       174
       174
       +
           node

     

       175
       175
       +
         end

     

       176
       176
       +
       ```

     

       177
       177
       +
       

     

       178
       178
       +
       <!-- livebook:{"output":true} -->

     

       179
       179
       +
       

     

       180
       180
       +
       ```

     

       181
       181
       +
       MapSet.new([

     

       182
       182
       +
         {20, 41},

     

       183
       183
       +
         {20, 3},

     

       184
       184
       +
         {16, 10},

     

       185
       185
       +
         {26, 21},

     

       186
       186
       +
         {6, 18},

     

       187
       187
       +
         {10, 32},

     

       188
       188
       +
         {20, 30},

     

       189
       189
       +
         {33, 17},

     

       190
       190
       +
         {17, 30},

     

       191
       191
       +
         {29, 28},

     

       192
       192
       +
         {40, 35},

     

       193
       193
       +
         {28, 37},

     

       194
       194
       +
         {25, 49},

     

       195
       195
       +
         {10, 19},

     

       196
       196
       +
         {14, 17},

     

       197
       197
       +
         {35, 7},

     

       198
       198
       +
         {29, 48},

     

       199
       199
       +
         {1, 34},

     

       200
       200
       +
         {23, 8},

     

       201
       201
       +
         {35, 6},

     

       202
       202
       +
         {49, 17},

     

       203
       203
       +
         {46, 38},

     

       204
       204
       +
         {5, 39},

     

       205
       205
       +
         {37, 29},

     

       206
       206
       +
         {16, 15},

     

       207
       207
       +
         {48, 41},

     

       208
       208
       +
         {4, 18},

     

       209
       209
       +
         {24, 15},

     

       210
       210
       +
         {33, 44},

     

       211
       211
       +
         {39, 18},

     

       212
       212
       +
         {40, 25},

     

       213
       213
       +
         {35, 21},

     

       214
       214
       +
         {41, 17},

     

       215
       215
       +
         {20, 37},

     

       216
       216
       +
         {45, 24},

     

       217
       217
       +
         {0, 35},

     

       218
       218
       +
         {18, 3},

     

       219
       219
       +
         {1, 36},

     

       220
       220
       +
         {35, 41},

     

       221
       221
       +
         {37, 28},

     

       222
       222
       +
         {28, 15},

     

       223
       223
       +
         {29, 38},

     

       224
       224
       +
         {46, 43},

     

       225
       225
       +
         {31, 19},

     

       226
       226
       +
         {19, 39},

     

       227
       227
       +
         {43, 10},

     

       228
       228
       +
         {38, 10},

     

       229
       229
       +
         {21, 26},

     

       230
       230
       +
         {28, ...},

     

       231
       231
       +
         {...},

     

       232
       232
       +
         ...

     

       233
       233
       +
       ])

     

       234
       234
       +
       ```

     

       235
       235
       +
       

     

       236
       236
       +
       ```elixir

     

       237
       237
       +
       MapSet.size(antinodes)

     

       238
       238
       +
       ```

     

       239
       239
       +
       

     

       240
       240
       +
       <!-- livebook:{"output":true} -->

     

       241
       241
       +
       

     

       242
       242
       +
       ```

     

       243
       243
       +
       398

     

       244
       244
       +
       ```

     

       245
       245
       +
       

     

       246
       246
       +
       ## Part 2

     

       247
       247
       +
       

     

       248
       248
       +
       ```elixir

     

       249
       249
       +
       antinodes_res =

     

       250
       250
       +
         for {_, antennas} <- freqs,

     

       251
       251
       +
             {a, b} <- Antennas.each_pair(antennas),

     

       252
       252
       +
             {x, y} = node <- Enum.take(Antennas.antinodes(a, b), 100),

     

       253
       253
       +
             x in 0..(w - 1) and y in 0..(h - 1),

     

       254
       254
       +
             into: MapSet.new() do

     

       255
       255
       +
           node

     

       256
       256
       +
         end

     

       257
       257
       +
       ```

     

       258
       258
       +
       

     

       259
       259
       +
       <!-- livebook:{"output":true} -->

     

       260
       260
       +
       

     

       261
       261
       +
       ```

     

       262
       262
       +
       MapSet.new([

     

       263
       263
       +
         {37, 47},

     

       264
       264
       +
         {35, 30},

     

       265
       265
       +
         {4, 5},

     

       266
       266
       +
         {20, 41},

     

       267
       267
       +
         {31, 42},

     

       268
       268
       +
         {9, 34},

     

       269
       269
       +
         {47, 38},

     

       270
       270
       +
         {20, 3},

     

       271
       271
       +
         {47, 44},

     

       272
       272
       +
         {22, 36},

     

       273
       273
       +
         {45, 7},

     

       274
       274
       +
         {19, 38},

     

       275
       275
       +
         {27, 21},

     

       276
       276
       +
         {9, 33},

     

       277
       277
       +
         {16, 10},

     

       278
       278
       +
         {21, 45},

     

       279
       279
       +
         {26, 21},

     

       280
       280
       +
         {21, 48},

     

       281
       281
       +
         {16, 38},

     

       282
       282
       +
         {35, 26},

     

       283
       283
       +
         {28, 20},

     

       284
       284
       +
         {45, 19},

     

       285
       285
       +
         {27, 22},

     

       286
       286
       +
         {16, 24},

     

       287
       287
       +
         {6, 18},

     

       288
       288
       +
         {10, 32},

     

       289
       289
       +
         {33, 15},

     

       290
       290
       +
         {36, 14},

     

       291
       291
       +
         {20, 30},

     

       292
       292
       +
         {33, 17},

     

       293
       293
       +
         {41, 1},

     

       294
       294
       +
         {36, 25},

     

       295
       295
       +
         {28, 48},

     

       296
       296
       +
         {5, 9},

     

       297
       297
       +
         {14, 16},

     

       298
       298
       +
         {17, 30},

     

       299
       299
       +
         {30, 49},

     

       300
       300
       +
         {32, 18},

     

       301
       301
       +
         {29, 28},

     

       302
       302
       +
         {40, 35},

     

       303
       303
       +
         {6, 23},

     

       304
       304
       +
         {17, 39},

     

       305
       305
       +
         {28, 37},

     

       306
       306
       +
         {6, 29},

     

       307
       307
       +
         {39, 23},

     

       308
       308
       +
         {49, 16},

     

       309
       309
       +
         {34, 0},

     

       310
       310
       +
         {11, 37},

     

       311
       311
       +
         {25, ...},

     

       312
       312
       +
         {...},

     

       313
       313
       +
         ...

     

       314
       314
       +
       ])

     

       315
       315
       +
       ```

     

       316
       316
       +
       

     

       317
       317
       +
       ```elixir

     

       318
       318
       +
       MapSet.size(antinodes_res)

     

       319
       319
       +
       ```

     

       320
       320
       +
       

     

       321
       321
       +
       <!-- livebook:{"output":true} -->

     

       322
       322
       +
       

     

       323
       323
       +
       ```

     

       324
       324
       +
       1333

     

       325
       325
       +
       ```

     

       326
       326
       +
       

     

       327
       327
       +
       <!-- livebook:{"offset":9159,"stamp":{"token":"XCP.vUy-wiQ1Ola4DEyyjRWCHAhmtmjmoDVd4jyZ0g5rhe0RM8-OKii82hOqtdVQ6B_yetZ17Z8avgol_Frq-whc91b45zMSMIRVIC-azF_IQmYLdHX0p3LEQ0xKLcBUuir19OQ","version":2}} -->

+243

2024/day09.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 09

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiI5Iiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjQifQ","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "9", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok,

     

       22
       22
       +
        "6920945132536042828994482345396169724991532616269072173941615129441070989533549353544192338215647480107561245832285861135469128938656230362333818111433746344751894125805448321674418337459440436476402523264257512621383849394968854739721644705231266361534476141022646838663844981685665728936624151235476791584929822482292987334479824016888196957024425673938289753698621244157130975989396226731549454298144391686468562820376390235135108330238590316674261440783039581594584646247629719986582560203598244312596985279832984526808559405915881067383593502384107494586724976925694948216635952475703445963854271259175649271576378184603074946598276445248640841860479933368524996925945274749282264063148922416399632485376097486952663787643633316356949469798134153950341455917737349115548390535536536397237654519556679716185652595572754749672866345553911576628161614338861880658781637382837898686889463249126116447176285128303560134154431099612772162289797131303641655015516771696046959228585241299646581370538088916416989047515564526116366867367181678616439431284930379889626059473847818663132232979123503952455854489755245141781899866948543116887346827534697893607177987563154596774691267167851154138330695352108499217988406372425774968626985943665687196181233111972699532427257992757984672882888037943925818450345177398760216079692074854569485530377584183586279552981343712063437565138087959796501957177177884278405560475435141829787014884681355059571489723985901554488154898784759668954752934048679146776060562786272011429026535298115262548593878183498916571398351436431313482968486771572527901996664899792152552410493090499727835643526428881322227999149881884793853729989624533029587010105028429614225841889414576176753414877452414680577843459538128911939238704598815126186492327558383740971333501769852667796188543180462490517062819496532859194781303437743159526136553370517461484469733677187178992265612439155938358015666261906673153823768535183244601645561579916316476813124539675061263411515873626197742860301068615568696174716481151333516718804424987323957615961444822618946925923196806747458558553262735686467327309580525855605085698452928593956820699112556481136173708346321771719645737818963669665547522134505223646796667286359173528172301211931188731691358636677670346032949579894428251583802532214067603254278658698940647270167640764638397570409829821264846762426836572463386475815673329747876757249732659277388030843590439617143487927833367461978526979212861844382550791390358527895937281110537852835869713059958217969899704145215985377666628719451233132412294358444746793946343553683032671225858498134340537229859741987180829468238642605723478228646886791227546199853372232566387139711011753555879744151132642224546223435667375781861424845134566438891443785750344893853718679532879854483395621276216275644617996376282773738211864275304297979547422875934634992111232368475557713129934172577624852042405732858060209959806520925730394293739081861693532946112557827992852621975727432957291082907728921029905725787812513023871891551681262814572424452648875694586632916946898788794936727799526748807158546930659285568029733948646265541485187570661411984840326374573377475525442055851882711851241546246736884066686885724058588220382743451817154627144869212944944985727560911326298754699513901913775411631051155448259136813383243697125190592983671813131786588158152523929049549018258627964330945831994544156999373027523966329015316477207024639470312244244043635392684240435826402148884612989874566739774998162494686244143442812672951249922585423333957811202767768597518787769627151336335561386093158376767595684951873065594471827052965041948820794865486179401375326111497235854418829486872664452298163169179763609277741983868518845423468770227926607088302941698125295594475259881783566721809397453893791727816025381929613950311537338366491240658016437269618697401059446097141870959520762921795565136242743648578086232855147488427619213536145259919693337741268680894834764319547389247696113145205712656834305853252319218569748862345539664553175240528621328137233671331496239591159242157540311894387168" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       #puzzle_input = "2333133121414131402"

     

       27
       27
       +
       

     

       28
       28
       +
       tags =

     

       29
       29
       +
         Stream.from_index()

     

       30
       30
       +
         |> Stream.intersperse(:gap)

     

       31
       31
       +
       

     

       32
       32
       +
       files =

     

       33
       33
       +
         puzzle_input

     

       34
       34
       +
         |> String.split("", trim: true)

     

       35
       35
       +
         |> Enum.map(&String.to_integer/1)

     

       36
       36
       +
         |> Enum.zip(tags)

     

       37
       37
       +
       ```

     

       38
       38
       +
       

     

       39
       39
       +
       <!-- livebook:{"output":true} -->

     

       40
       40
       +
       

     

       41
       41
       +
       ```

     

       42
       42
       +
       [

     

       43
       43
       +
         {6, 0},

     

       44
       44
       +
         {9, :gap},

     

       45
       45
       +
         {2, 1},

     

       46
       46
       +
         {0, :gap},

     

       47
       47
       +
         {9, 2},

     

       48
       48
       +
         {4, :gap},

     

       49
       49
       +
         {5, 3},

     

       50
       50
       +
         {1, :gap},

     

       51
       51
       +
         {3, 4},

     

       52
       52
       +
         {2, :gap},

     

       53
       53
       +
         {5, 5},

     

       54
       54
       +
         {3, :gap},

     

       55
       55
       +
         {6, 6},

     

       56
       56
       +
         {0, :gap},

     

       57
       57
       +
         {4, 7},

     

       58
       58
       +
         {2, :gap},

     

       59
       59
       +
         {8, 8},

     

       60
       60
       +
         {2, :gap},

     

       61
       61
       +
         {8, 9},

     

       62
       62
       +
         {9, :gap},

     

       63
       63
       +
         {9, 10},

     

       64
       64
       +
         {4, :gap},

     

       65
       65
       +
         {4, 11},

     

       66
       66
       +
         {8, :gap},

     

       67
       67
       +
         {2, 12},

     

       68
       68
       +
         {3, :gap},

     

       69
       69
       +
         {4, 13},

     

       70
       70
       +
         {5, :gap},

     

       71
       71
       +
         {3, 14},

     

       72
       72
       +
         {9, :gap},

     

       73
       73
       +
         {6, 15},

     

       74
       74
       +
         {1, :gap},

     

       75
       75
       +
         {6, 16},

     

       76
       76
       +
         {9, :gap},

     

       77
       77
       +
         {7, 17},

     

       78
       78
       +
         {2, :gap},

     

       79
       79
       +
         {4, 18},

     

       80
       80
       +
         {9, :gap},

     

       81
       81
       +
         {9, 19},

     

       82
       82
       +
         {1, :gap},

     

       83
       83
       +
         {5, 20},

     

       84
       84
       +
         {3, :gap},

     

       85
       85
       +
         {2, 21},

     

       86
       86
       +
         {6, :gap},

     

       87
       87
       +
         {1, 22},

     

       88
       88
       +
         {6, :gap},

     

       89
       89
       +
         {2, 23},

     

       90
       90
       +
         {6, :gap},

     

       91
       91
       +
         {9, ...},

     

       92
       92
       +
         {...},

     

       93
       93
       +
         ...

     

       94
       94
       +
       ]

     

       95
       95
       +
       ```

     

       96
       96
       +
       

     

       97
       97
       +
       ```elixir

     

       98
       98
       +
       defmodule Disk do

     

       99
       99
       +
         def checksum(files) do

     

       100
       100
       +
           files

     

       101
       101
       +
           |> Enum.reduce({0, 0}, fn

     

       102
       102
       +
             {gap, :gap}, {pos, sum} ->

     

       103
       103
       +
               {pos + gap, sum}

     

       104
       104
       +
       

     

       105
       105
       +
             {len, idx}, {pos, sum} ->

     

       106
       106
       +
               new_pos = pos + len

     

       107
       107
       +
               score = Enum.sum(pos..(new_pos - 1)) * idx

     

       108
       108
       +
       

     

       109
       109
       +
               {new_pos, score + sum}

     

       110
       110
       +
           end)

     

       111
       111
       +
           |> elem(1)

     

       112
       112
       +
         end

     

       113
       113
       +
       

     

       114
       114
       +
         def display(lst) do

     

       115
       115
       +
           Enum.map(lst, fn

     

       116
       116
       +
             {len, val} ->

     

       117
       117
       +
               sym = if val == :gap, do: ".", else: to_string(val)

     

       118
       118
       +
               

     

       119
       119
       +
               List.duplicate(sym, len)

     

       120
       120
       +
           end)

     

       121
       121
       +
           |> IO.iodata_to_binary()

     

       122
       122
       +
         end

     

       123
       123
       +
       end

     

       124
       124
       +
       ```

     

       125
       125
       +
       

     

       126
       126
       +
       <!-- livebook:{"output":true} -->

     

       127
       127
       +
       

     

       128
       128
       +
       ```

     

       129
       129
       +
       {:module, Disk, <<70, 79, 82, 49, 0, 0, 11, ...>>, {:display, 1}}

     

       130
       130
       +
       ```

     

       131
       131
       +
       

     

       132
       132
       +
       ## Part 1

     

       133
       133
       +
       

     

       134
       134
       +
       ```elixir

     

       135
       135
       +
       defmodule Compactor do

     

       136
       136
       +
         def run(files) do

     

       137
       137
       +
           occupied =

     

       138
       138
       +
             Enum.reduce(files, 0, fn

     

       139
       139
       +
               {_, :gap}, acc -> acc

     

       140
       140
       +
               {len, _idx}, acc -> acc + len

     

       141
       141
       +
             end)

     

       142
       142
       +
       

     

       143
       143
       +
           compact([], occupied, files, Enum.reverse(files))

     

       144
       144
       +
         end

     

       145
       145
       +
       

     

       146
       146
       +
         defp compact(acc, 0, _, _), do: Enum.reverse(acc)

     

       147
       147
       +
       

     

       148
       148
       +
         defp compact(acc, left, [{0, :gap} | rest], rfiles),

     

       149
       149
       +
           do: compact(acc, left, rest, rfiles)

     

       150
       150
       +
       

     

       151
       151
       +
         defp compact(acc, left, rest, [{_, :gap} | rfiles]),

     

       152
       152
       +
           do: compact(acc, left, rest, rfiles)

     

       153
       153
       +
       

     

       154
       154
       +
         defp compact(acc, left, rest, [{0, _idx} | rfiles]) do

     

       155
       155
       +
           compact(acc, left, rest, rfiles)

     

       156
       156
       +
         end

     

       157
       157
       +
       

     

       158
       158
       +
         defp compact(acc, left, [{gap, :gap} | rest], [{len, idx} | rfiles]) do

     

       159
       159
       +
           fill = min(gap, len)

     

       160
       160
       +
       

     

       161
       161
       +
           compact([{fill, idx} | acc], left - fill, [{gap - fill, :gap} | rest], [

     

       162
       162
       +
             {len - fill, idx} | rfiles

     

       163
       163
       +
           ])

     

       164
       164
       +
         end

     

       165
       165
       +
         

     

       166
       166
       +
         defp compact(acc, left, [{len, idx} = file | rest], rfiles) when is_integer(idx) do

     

       167
       167
       +
           compact([file | acc], left - len, rest, rfiles)

     

       168
       168
       +
         end

     

       169
       169
       +
       end

     

       170
       170
       +
       ```

     

       171
       171
       +
       

     

       172
       172
       +
       <!-- livebook:{"output":true} -->

     

       173
       173
       +
       

     

       174
       174
       +
       ```

     

       175
       175
       +
       {:module, Compactor, <<70, 79, 82, 49, 0, 0, 11, ...>>, {:compact, 4}}

     

       176
       176
       +
       ```

     

       177
       177
       +
       

     

       178
       178
       +
       ```elixir

     

       179
       179
       +
       files

     

       180
       180
       +
       |> Compactor.run()

     

       181
       181
       +
       |> Disk.checksum()

     

       182
       182
       +
       ```

     

       183
       183
       +
       

     

       184
       184
       +
       <!-- livebook:{"output":true} -->

     

       185
       185
       +
       

     

       186
       186
       +
       ```

     

       187
       187
       +
       6332189866718

     

       188
       188
       +
       ```

     

       189
       189
       +
       

     

       190
       190
       +
       ## Part 2

     

       191
       191
       +
       

     

       192
       192
       +
       ```elixir

     

       193
       193
       +
       defmodule Defrag do

     

       194
       194
       +
         def run(files) do

     

       195
       195
       +
           files

     

       196
       196
       +
           |> Enum.reverse()

     

       197
       197
       +
           |> Enum.reduce(files, fn

     

       198
       198
       +
             {_, :gap}, acc -> acc

     

       199
       199
       +
             file, acc -> do_run(acc, file, [])

     

       200
       200
       +
           end)

     

       201
       201
       +
         end

     

       202
       202
       +
       

     

       203
       203
       +
         defp do_run([], _, acc), do: Enum.reverse(acc)

     

       204
       204
       +
       

     

       205
       205
       +
         defp do_run([file | _] = list, file, acc), do: Enum.reverse(acc, list)

     

       206
       206
       +
       

     

       207
       207
       +
         defp do_run([{len, :gap} | rest], {len, idx}, acc),

     

       208
       208
       +
           do: Enum.reverse(acc, [{len, idx} | rep(rest, {len, idx})])

     

       209
       209
       +
       

     

       210
       210
       +
         defp do_run([{gap, :gap} | rest], {len, idx}, acc) when len < gap,

     

       211
       211
       +
           do: Enum.reverse(acc, [{len, idx}, {gap - len, :gap} | rep(rest, {len, idx})])

     

       212
       212
       +
       

     

       213
       213
       +
         defp do_run([hd | rest], file, acc), do: do_run(rest, file, [hd | acc])

     

       214
       214
       +
       

     

       215
       215
       +
         defp rep([{a, :gap}, file, {b, :gap} | rest], {len, _} = file),

     

       216
       216
       +
           do: [{a + len + b, :gap} | rest]

     

       217
       217
       +
       

     

       218
       218
       +
         defp rep([{a, :gap}, file | rest], {len, _} = file), do: [{a + len, :gap} | rest]

     

       219
       219
       +
         defp rep([file, {b, :gap} | rest], {len, _} = file), do: [{len + b, :gap} | rest]

     

       220
       220
       +
         defp rep([file | rest], {len, _} = file), do: [{len, :gap} | rest]

     

       221
       221
       +
         defp rep([hd | rest], file), do: [hd | rep(rest, file)]

     

       222
       222
       +
       end

     

       223
       223
       +
       ```

     

       224
       224
       +
       

     

       225
       225
       +
       <!-- livebook:{"output":true} -->

     

       226
       226
       +
       

     

       227
       227
       +
       ```

     

       228
       228
       +
       {:module, Defrag, <<70, 79, 82, 49, 0, 0, 12, ...>>, {:rep, 2}}

     

       229
       229
       +
       ```

     

       230
       230
       +
       

     

       231
       231
       +
       ```elixir

     

       232
       232
       +
       files

     

       233
       233
       +
       |> Defrag.run()

     

       234
       234
       +
       |> Disk.checksum()

     

       235
       235
       +
       ```

     

       236
       236
       +
       

     

       237
       237
       +
       <!-- livebook:{"output":true} -->

     

       238
       238
       +
       

     

       239
       239
       +
       ```

     

       240
       240
       +
       6353648390778

     

       241
       241
       +
       ```

     

       242
       242
       +
       

     

       243
       243
       +
       <!-- livebook:{"offset":8665,"stamp":{"token":"XCP.-mRlAHFcVs4Mg2hQj8TCLWgOv8zjlatUnbxbgI43tZXllMXB8VfJTbRJrHTJ1k_FrGDhUdviUPyCSPNKqXk-ZOQ9PHWUPFkLaK5S4SMKa18Ny7WrQvSmaHuoE2R6vJhqrck","version":2}} -->

+218

2024/day10.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 10

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIxMCIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI0In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "10", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok,

     

       22
       22
       +
        "543067650323210321032110356789890110710189878760134567\n612148941212306782345091235410765227893258759651021298\n701238932301456798106787549323454336794567549842330807\n898547215450589867287654678892961245987654456732498910\n987656306769678956398013234781870301256003301201567821\n234543215878760145478920105690210982340112210341056932\n109650124981232230569834124567345673451234985452347845\n018744323890341021656765033438454589298545676701037796\n199803210787650110765017842129823672107655677812378987\n785012345654789541874326956010510563201234389983405676\n174321498723498632903455467173421454102348210234514430\n065430239014323721212762398982567876218959650149623521\n145540128765017890101871081071018967327968743898734678\n236692134984178768718981012567894458456876212798604329\n987783005673269659654108923458763349663212108789015012\n896654012562154546743267830309854218767103419276126787\n765780123473043432890154321212903109878756578125435698\n434099874984012301740125654567812893469017647030165556\n323101065765101787434436763058906732154178736543256765\n013298187890678696325569892143215440043289128954343894\n010367296541549045016678765014300351234567037760012983\n329458305032132134787867410967891267653438546891898012\n458789414145010120196986323898763298344129655432743210\n567076523236678743285898456777654101201098766653658901\n456167654107549658374567689985403100312434985567877014\n343228943298938569843210576876312238920125676656986323\n651014543498127478755765435410278947437876985543235434\n743223672567078369876890324320127656506987234350145632\n894102981089569232125981210451256543215432122341076541\n765091234676352101034674323401237894101341001456789830\n014780365445443032126501012532345743103210112565898321\n123689876034321145098432107645236743254101101876543210\n094545763125210056788943258896107858969010332987674301\n785430432106782169877652349787567967678321245696784561\n876021569045893458965601654343478914565414326781093870\n987109878010432167014298710234323901258905015492012901\n789219894324569052123109620123217892109876012323458692\n654308765543678743013234538994106543010870965410069783\n789877787632189852101110145885287676521961871012178654\n034565896601087601211001406776896789437652676523468743\n121053795542194512389132312345445676548943989430549012\n262342187634765433498545434531230107401232104321678298\n876533014123892324567696526540043298340981010780890187\n983414523016101019876587017832134781256672125690743296\n032101654327892100345678789901295690764543434321652345\n123089789236743981234589654800387789835678987787601336\n854176590187656876104310343211456876544549016098543223\n965765410194545675465231230898565963233432145123210112\n876894321243232980370110141767653210112321039654101101\n146765232100101061289879852632154100203410128789210322\n036787103761267876518768763543069911012543454376325412\n123498654854356987405650654985678892327632567215436701\n210567569983543292314321569876301765438761078904589898\n325456478754330101223433478765432654349652987615678765"}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       map =

     

       27
       27
       +
         for {row, y} <- puzzle_input |> String.split("\n", trim: true) |> Enum.with_index(),

     

       28
       28
       +
             {h, x} <- row |> String.to_charlist() |> Enum.with_index(),

     

       29
       29
       +
             into: %{},

     

       30
       30
       +
             do: {{x, y}, h - ?0}

     

       31
       31
       +
       ```

     

       32
       32
       +
       

     

       33
       33
       +
       <!-- livebook:{"output":true} -->

     

       34
       34
       +
       

     

       35
       35
       +
       ```

     

       36
       36
       +
       %{

     

       37
       37
       +
         {37, 47} => 3,

     

       38
       38
       +
         {38, 2} => 4,

     

       39
       39
       +
         {1, 26} => 5,

     

       40
       40
       +
         {32, 15} => 4,

     

       41
       41
       +
         {35, 30} => 3,

     

       42
       42
       +
         {37, 53} => 4,

     

       43
       43
       +
         {4, 5} => 4,

     

       44
       44
       +
         {8, 50} => 3,

     

       45
       45
       +
         {11, 39} => 1,

     

       46
       46
       +
         {22, 38} => 1,

     

       47
       47
       +
         {20, 41} => 8,

     

       48
       48
       +
         {29, 25} => 6,

     

       49
       49
       +
         {29, 26} => 0,

     

       50
       50
       +
         {47, 27} => 0,

     

       51
       51
       +
         {31, 42} => 4,

     

       52
       52
       +
         {9, 34} => 0,

     

       53
       53
       +
         {47, 38} => 2,

     

       54
       54
       +
         {20, 3} => 7,

     

       55
       55
       +
         {47, 44} => 1,

     

       56
       56
       +
         {22, 37} => 3,

     

       57
       57
       +
         {22, 36} => 0,

     

       58
       58
       +
         {45, 7} => 7,

     

       59
       59
       +
         {19, 38} => 0,

     

       60
       60
       +
         {27, 21} => 9,

     

       61
       61
       +
         {9, 33} => 1,

     

       62
       62
       +
         {26, 41} => 4,

     

       63
       63
       +
         {52, 42} => 8,

     

       64
       64
       +
         {21, 35} => 2,

     

       65
       65
       +
         {42, 8} => 6,

     

       66
       66
       +
         {19, 22} => 9,

     

       67
       67
       +
         {16, 10} => 3,

     

       68
       68
       +
         {21, 45} => 5,

     

       69
       69
       +
         {11, 8} => 7,

     

       70
       70
       +
         {26, 21} => 0,

     

       71
       71
       +
         {21, 48} => 1,

     

       72
       72
       +
         {50, 40} => 9,

     

       73
       73
       +
         {10, 25} => 9,

     

       74
       74
       +
         {11, 19} => 0,

     

       75
       75
       +
         {16, 38} => 5,

     

       76
       76
       +
         {35, 15} => 8,

     

       77
       77
       +
         {37, 15} => 6,

     

       78
       78
       +
         {35, 26} => 7,

     

       79
       79
       +
         {28, 20} => 1,

     

       80
       80
       +
         {45, 19} => 9,

     

       81
       81
       +
         {27, 22} => 8,

     

       82
       82
       +
         {16, 24} => 5,

     

       83
       83
       +
         {6, 18} => 0,

     

       84
       84
       +
         {10, 32} => 2,

     

       85
       85
       +
         {32, ...} => 8,

     

       86
       86
       +
         {...} => 7,

     

       87
       87
       +
         ...

     

       88
       88
       +
       }

     

       89
       89
       +
       ```

     

       90
       90
       +
       

     

       91
       91
       +
       ```elixir

     

       92
       92
       +
       starts = Enum.filter(map, fn {_, elev} -> elev == 0 end)

     

       93
       93
       +
       ```

     

       94
       94
       +
       

     

       95
       95
       +
       <!-- livebook:{"output":true} -->

     

       96
       96
       +
       

     

       97
       97
       +
       ```

     

       98
       98
       +
       [

     

       99
       99
       +
         {{38, 5}, 0},

     

       100
       100
       +
         {{24, 7}, 0},

     

       101
       101
       +
         {{11, 35}, 0},

     

       102
       102
       +
         {{3, 9}, 0},

     

       103
       103
       +
         {{15, 36}, 0},

     

       104
       104
       +
         {{41, 32}, 0},

     

       105
       105
       +
         {{51, 14}, 0},

     

       106
       106
       +
         {{51, 24}, 0},

     

       107
       107
       +
         {{5, 12}, 0},

     

       108
       108
       +
         {{4, 35}, 0},

     

       109
       109
       +
         {{40, 4}, 0},

     

       110
       110
       +
         {{46, 4}, 0},

     

       111
       111
       +
         {{22, 30}, 0},

     

       112
       112
       +
         {{27, 12}, 0},

     

       113
       113
       +
         {{7, 4}, 0},

     

       114
       114
       +
         {{24, 43}, 0},

     

       115
       115
       +
         {{31, 20}, 0},

     

       116
       116
       +
         {{29, 42}, 0},

     

       117
       117
       +
         {{29, 9}, 0},

     

       118
       118
       +
         {{10, 2}, 0},

     

       119
       119
       +
         {{0, 20}, 0},

     

       120
       120
       +
         {{15, 20}, 0},

     

       121
       121
       +
         {{14, 0}, 0},

     

       122
       122
       +
         {{42, 48}, 0},

     

       123
       123
       +
         {{40, 15}, 0},

     

       124
       124
       +
         {{43, 14}, 0},

     

       125
       125
       +
         {{19, 2}, 0},

     

       126
       126
       +
         {{14, 22}, 0},

     

       127
       127
       +
         {{34, 35}, 0},

     

       128
       128
       +
         {{38, 42}, 0},

     

       129
       129
       +
         {{23, 5}, 0},

     

       130
       130
       +
         {{0, 11}, 0},

     

       131
       131
       +
         {{44, 11}, 0},

     

       132
       132
       +
         {{15, 30}, 0},

     

       133
       133
       +
         {{17, 44}, 0},

     

       134
       134
       +
         {{31, 32}, 0},

     

       135
       135
       +
         {{48, 28}, 0},

     

       136
       136
       +
         {{21, 39}, 0},

     

       137
       137
       +
         {{49, 13}, 0},

     

       138
       138
       +
         {{29, 45}, 0},

     

       139
       139
       +
         {{4, 37}, 0},

     

       140
       140
       +
         {{53, 31}, 0},

     

       141
       141
       +
         {{45, 46}, 0},

     

       142
       142
       +
         {{43, 29}, 0},

     

       143
       143
       +
         {{8, 0}, 0},

     

       144
       144
       +
         {{47, 42}, 0},

     

       145
       145
       +
         {{7, 14}, 0},

     

       146
       146
       +
         {{52, ...}, 0},

     

       147
       147
       +
         {{...}, ...},

     

       148
       148
       +
         {...},

     

       149
       149
       +
         ...

     

       150
       150
       +
       ]

     

       151
       151
       +
       ```

     

       152
       152
       +
       

     

       153
       153
       +
       ```elixir

     

       154
       154
       +
       defmodule Trail do

     

       155
       155
       +
         def traverse(start, map), do: MapSet.new(traverse(start, map, []))

     

       156
       156
       +
       

     

       157
       157
       +
         defp traverse({curr, 9}, _map, acc), do: [[{curr, 9} | acc]]

     

       158
       158
       +
         defp traverse({curr, elev}, map, acc) do

     

       159
       159
       +
           curr

     

       160
       160
       +
           |> surroundings()

     

       161
       161
       +
           |> then(&Map.take(map, &1))

     

       162
       162
       +
           |> Enum.filter(fn {_, h} -> elev + 1 == h end)

     

       163
       163
       +
           |> Enum.flat_map(&traverse(&1, map, [{curr, elev} | acc]))

     

       164
       164
       +
         end

     

       165
       165
       +
       

     

       166
       166
       +
         defp surroundings({x, y}) do

     

       167
       167
       +
           [

     

       168
       168
       +
             {x, y - 1},

     

       169
       169
       +
             {x - 1, y},

     

       170
       170
       +
             {x, y + 1},

     

       171
       171
       +
             {x + 1, y}

     

       172
       172
       +
           ]

     

       173
       173
       +
         end

     

       174
       174
       +
       end

     

       175
       175
       +
       ```

     

       176
       176
       +
       

     

       177
       177
       +
       <!-- livebook:{"output":true} -->

     

       178
       178
       +
       

     

       179
       179
       +
       ```

     

       180
       180
       +
       {:module, Trail, <<70, 79, 82, 49, 0, 0, 11, ...>>, {:surroundings, 1}}

     

       181
       181
       +
       ```

     

       182
       182
       +
       

     

       183
       183
       +
       ## Part 1

     

       184
       184
       +
       

     

       185
       185
       +
       ```elixir

     

       186
       186
       +
       starts

     

       187
       187
       +
       |> Enum.map(fn start ->

     

       188
       188
       +
         Trail.traverse(start, map)

     

       189
       189
       +
         |> MapSet.new(&hd/1)

     

       190
       190
       +
         |> MapSet.size()

     

       191
       191
       +
       end)

     

       192
       192
       +
       |> Enum.sum()

     

       193
       193
       +
       ```

     

       194
       194
       +
       

     

       195
       195
       +
       <!-- livebook:{"output":true} -->

     

       196
       196
       +
       

     

       197
       197
       +
       ```

     

       198
       198
       +
       733

     

       199
       199
       +
       ```

     

       200
       200
       +
       

     

       201
       201
       +
       ## Section

     

       202
       202
       +
       

     

       203
       203
       +
       ```elixir

     

       204
       204
       +
       starts

     

       205
       205
       +
       |> Enum.map(fn start ->

     

       206
       206
       +
         Trail.traverse(start, map)

     

       207
       207
       +
         |> MapSet.size()

     

       208
       208
       +
       end)

     

       209
       209
       +
       |> Enum.sum()

     

       210
       210
       +
       ```

     

       211
       211
       +
       

     

       212
       212
       +
       <!-- livebook:{"output":true} -->

     

       213
       213
       +
       

     

       214
       214
       +
       ```

     

       215
       215
       +
       1514

     

       216
       216
       +
       ```

     

       217
       217
       +
       

     

       218
       218
       +
       <!-- livebook:{"offset":6605,"stamp":{"token":"XCP.68U6SzidJCV7il26kiMv6z5qLEx_50_v2V7x6LqV9t8LQG1-aShVMNE1DEgCj9SwpKOn02np0aeSu5T1parIYMF9MeWGGfqP-oc4UGnDiDGDtJ5RGqdwcxcPjuPUQmCtZj0","version":2}} -->

+110

2024/day11.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 11

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIxMSIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI0In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "11", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok, "554735 45401 8434 0 188 7487525 77 7"}

     

       22
       22
       +
       ```

     

       23
       23
       +
       

     

       24
       24
       +
       ```elixir

     

       25
       25
       +
       # puzzle_input = "125 17"

     

       26
       26
       +
       

     

       27
       27
       +
       stones =

     

       28
       28
       +
         puzzle_input

     

       29
       29
       +
         |> String.split()

     

       30
       30
       +
         |> Enum.map(&String.to_integer/1)

     

       31
       31
       +
         |> Enum.frequencies()

     

       32
       32
       +
       ```

     

       33
       33
       +
       

     

       34
       34
       +
       <!-- livebook:{"output":true} -->

     

       35
       35
       +
       

     

       36
       36
       +
       ```

     

       37
       37
       +
       %{0 => 1, 7 => 1, 77 => 1, 188 => 1, 8434 => 1, 45401 => 1, 554735 => 1, 7487525 => 1}

     

       38
       38
       +
       ```

     

       39
       39
       +
       

     

       40
       40
       +
       ```elixir

     

       41
       41
       +
       defmodule Stones do

     

       42
       42
       +
         def blink(list), do: Enum.reduce(list, %{}, &alter/2)

     

       43
       43
       +
       

     

       44
       44
       +
         defp alter({0, count}, map), do: update(map, 1, count)

     

       45
       45
       +
       

     

       46
       46
       +
         defp alter({n, count}, map) do

     

       47
       47
       +
           len = len(n)

     

       48
       48
       +
       

     

       49
       49
       +
           if rem(len, 2) == 0 do

     

       50
       50
       +
             half = 10 ** div(len, 2)

     

       51
       51
       +
       

     

       52
       52
       +
             map

     

       53
       53
       +
             |> update(div(n, half), count)

     

       54
       54
       +
             |> update(rem(n, half), count)

     

       55
       55
       +
           else

     

       56
       56
       +
             update(map, n * 2024, count)

     

       57
       57
       +
           end

     

       58
       58
       +
         end

     

       59
       59
       +
       

     

       60
       60
       +
         defp len(n) when n < 10, do: 1

     

       61
       61
       +
         defp len(n) when n < 100, do: 2

     

       62
       62
       +
         defp len(n) when n < 1000, do: 3

     

       63
       63
       +
         defp len(n) when n < 10000, do: 4

     

       64
       64
       +
         defp len(n), do: ceil(:math.log10(n))

     

       65
       65
       +
       

     

       66
       66
       +
         defp update(map, key, val), do: Map.update(map, key, val, &(&1 + val))

     

       67
       67
       +
       end

     

       68
       68
       +
       ```

     

       69
       69
       +
       

     

       70
       70
       +
       <!-- livebook:{"output":true} -->

     

       71
       71
       +
       

     

       72
       72
       +
       ```

     

       73
       73
       +
       {:module, Stones, <<70, 79, 82, 49, 0, 0, 11, ...>>, {:update, 3}}

     

       74
       74
       +
       ```

     

       75
       75
       +
       

     

       76
       76
       +
       ## Part 1

     

       77
       77
       +
       

     

       78
       78
       +
       ```elixir

     

       79
       79
       +
       1..25

     

       80
       80
       +
       |> Enum.reduce(stones, fn _, acc ->

     

       81
       81
       +
         Stones.blink(acc)

     

       82
       82
       +
       end)

     

       83
       83
       +
       |> Map.values()

     

       84
       84
       +
       |> Enum.sum()

     

       85
       85
       +
       ```

     

       86
       86
       +
       

     

       87
       87
       +
       <!-- livebook:{"output":true} -->

     

       88
       88
       +
       

     

       89
       89
       +
       ```

     

       90
       90
       +
       209412

     

       91
       91
       +
       ```

     

       92
       92
       +
       

     

       93
       93
       +
       ## Part 2

     

       94
       94
       +
       

     

       95
       95
       +
       ```elixir

     

       96
       96
       +
       1..75

     

       97
       97
       +
       |> Enum.reduce(stones, fn _, acc ->

     

       98
       98
       +
         Stones.blink(acc)

     

       99
       99
       +
       end)

     

       100
       100
       +
       |> Map.values()

     

       101
       101
       +
       |> Enum.sum()

     

       102
       102
       +
       ```

     

       103
       103
       +
       

     

       104
       104
       +
       <!-- livebook:{"output":true} -->

     

       105
       105
       +
       

     

       106
       106
       +
       ```

     

       107
       107
       +
       248967696501656

     

       108
       108
       +
       ```

     

       109
       109
       +
       

     

       110
       110
       +
       <!-- livebook:{"offset":1963,"stamp":{"token":"XCP.YCGtDQl3XNWJm5oY1OPI2QDRB7EIjZxBmwK3eswS1ryD28kg8fS_fKGIFJGFbtL1NL7wYrv2ADW60yeAZnCv5KbDelUm_bxkPN4_K56iTJ1toOGfIRYlo2lj5beAjrmbhRw","version":2}} -->

+811

2024/day12.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 12

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc, :range_set])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIxMiIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI0In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "12", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok,

     

       22
       22
       +
        "KKKKKKZZZZZZZZDDQQQQXXXXXXXXXXXXTTTTTTTTTTTTDHHHHHHHHHHHHHHHHHGGGGGGPPPGUUGGXXGGGGGGJJJJJJJJJIIIIIIIIIIIIIIIIIIIIDIIIIIIIIIIIKIIIIIIIIIIIIIM\nKKKKKKZZZZZZZDDDQQQQXXCXXXXXXXXXTTTTTTTTTTTTTHHHHHHHHHHHHHHHHHGGGGGGGGPGUUGGGGGGGGGJJJJJJJJIIIIIIIIIIIIIIIIIIVVVIDDIIIIIIIKKKKIIIIIIIIIIIIMM\nKKKKKZZZZZZZZZZQQQQQQXCCCXXXXXXTTTTTTTTTTTTTTTHHHHHHHHHHHHHHHGGGGGGGGGGGGGGGGGGGGJJJJJJJJJJIIIIIIIIIIIIIIIIIIVIIIIDIHIIIIIIIKKIIIIIIIIIIIIMM\nKKKKKZZZZZZZZEEHQQQYQQZCCCCXXXTTTTTTTTTTTTTTHHHIIIIHHHHHHHHHHGGGGGGGGGGGGGGGGGGGGGJJJJJJJJIIIIIIIIKKKKKKIIIIIVIIIIDHHIIIIIIIIKIIIIIIIIIIIIIM\nKKKKKKOOEZEEEEHHQQQYYCCCCCCTTTTTTTTTTTTTTTTTVVVIIIIHHHHHHBBBBGGGGGGGGGGGGGGGGGGGGJJJJJJJJJIIIIIIIBCKKKKKIIIIIIIIHHHHHIIIIIIIIIIIIIIIIIIIMMMM\nKKKKKOOEEEEEEEHHHQQYYCCCCCCCCCTTTTTTTTTTTOOTTIIIIIHHHHHHHHHBBBGGGGGGGGGGGGGGGGGGGJJJJJJJJJIIIIIBBBCKKKKKKKIIIIIHHHHHIIIIIIIIIIIIIIIIIIIIIIMM\nKKKKKKOGGEEEGHHHHQDDYYCCCCCCCOOTTTTTTTTTTTIDIIIIIIIHHHHHHBBBBBGGGGGGGGGGGGGGGGGGGGJJJJJJJJIIIIBBBBKKKKKKKKIKIIIBHHHHHIIIIIIIIIIIIIIIIIIIIIIM\nKKKKTKOOGEGGGHGHDDDDDYYYCCCCCOOTTTTTTTTTTIIIIIIIIIIHHHHHBBBBBBGGGGGJGGGQGGLGGGGGGJJJJJJRRJJJBBBBKKKKKKKKKKKKKKFHHHHHHHIHHIIIIIRIIIIIIIIIIMMM\nKRRRVOOGGGGGGGGGDDDDPDDYDSSCCCOOOTTOTTTTTIIIIIIIIIIHHHBHBBBBBBGGGGGJGJJGGGGGGGGGGJJJJJRRRRRWBBBBBBVKKKKKKKKKKTHHHHHHHHHHIIIIIIIIIIIIIIGIIMMM\nYVRVVOOGGGGGGGDDDDDDDDDDDSSCCOOOOOOOTOOOIIIIIIIIIIIHHBBBBBBBBBGGGGGJJJJJGGGCGGFFGFFJRRRRRRRWWBBBBBBKKKKKKKKKKKHHHHHHHHHFFIIIIIIIIIIIIIGIVVMM\nYVRVVVVGGGGGGGDDDDDDDDDDDDDCCOOOOOOOOOOOIIIIIIIIIIIHHHBBBBBBBBBBGGJJJJJJJJJGGGFFFFRRRRRRRRRRRBBBBBKKKKKKKKKKKKKHHHHHHHHFIIIIIIIIIIIIIIIIVVVM\nYVVVVVVVVGGGGGGDDDDDDDDDDDDOOOOOOOOOOOOOOIIIIIIEEIIHHHOBBBBBBBBBBGJJJJJJJJJFFFFFFFFFRRRRRRRRRRBBBBKBKKKKKKKKKKKHHHHHHFFFFIIFIIIIZIIAIIIIVVMM\nVVVVVVVVVGGGGGGDDDDDDDDDDDOOOOOOOOOOOOOOOOOOOIOOEJJHHHOBBBBBBBBBBEEJEEEEEFFFFFFFFFFFRRRRRRRNBBBBBBBBKKKKKKKKKKRHHHHHHFFFFFFFIIIIIIIIBBIIVMMM\nVVVVVVVVVGGGGGDDDDDDDDDDDDEOOOOOOOOOOOOOOOOOOOOOEEJHHOOOBBBBGGGGBEEEHEEXFFFFFFFFFFFFRRRRRRBNBBBBBBBBKKKKKKKKKKHHHHHHHFFFFFFFIIIIIIIIBBVVVMMM\nVVVVVVVVGGGGGDPDDDDDDDDDDDEEOOOOOOOOOOOOOOOOOOOOEEJEOOOOBGGGGGGGHEEEEEEFFFLFFFFFFFFRRRRRRRBBBBBBBBBBBKKKKKKKKFHHHHHFFFFFFFFIIIIIIIIIIVVVVVMM\nVVVVVVVVGGGGGDDDDDDDDDDDDDDEOOOOOOOOGOOOOOEOIIOOEEEEOOOOOGGGGGGGEEEEEEEFFFFFFFFFFFFFRDRRXXBBBBBBBBBBBKKKKKKKKKBBHHHHFFFFFFFIIIIIIIIIVVVVVVLM\nVVVVVVVVWGGGGDDDDDDDDDDDDEEEOOOOOOGGGOOOOOOIIIIIEEOOOOBOOGGGGGGGUEEEEEGUFFFFFFFFFFFFDDDDMMSBBBBBBBBBBBBBKKKKKKBBBHHFFFFFFFFIIIIINNWIVVVVVVLL\nVVVVVVZZZFGGGRDDDDDDDDDDDEOOOOOOOFFFGOGOOIIIBIBBBEOBBBBBBGGGGGGGEEEEEGGUUFFFFFFFFFFFDDDDDMMMBBBBBBBBBBBKKKKKKBBBBHHFFFFFFFFFIINNNNNPPVVVVLLL\nVVVZZZZZZZIGRRADADDDDDDDDEOEEOYYGFFGGOGGGIIIBBBBBEBBBBBBBGGGGGGGFEEEGGGGUUFFFFFFFFFHDVVVVVVMBBBBBBBBBBBKKKKBBBBBBBBBFFFFFFFRRRRNNNNPPVVLLLLL\nVVZZZZZZZZZRRRADAADEEEDDDEEEEOYYGGGGGGGGGGIBBBBBBBBBBBBBBGGGGGGGEEEEBGGGUUFFFFFFFFFHHVVVVVVMBBBBBBBBBPBKKBBBBBBBBBBFFFFFFFFFRBRNNNNNNNVLLLLL\nVZZZZZBZZZNAAAAAAAAEEEEEEEEEGGYYGGGGGGGGGIIBBBBBBBBBBBBBBGGGGGFFFEEBBGGGGCFFFFFFFFFHHVVVVVVMBBBBBBBMMMMMBBBBBBBGBBBFFFFFFFGGBBBNNNNNLLLLLLLL\nBBBBBBBZZNNNAAAAAAEEEEEEGEEEEGYYGGGGGGGIIIIBBBBBBBBBBBBBBGGGGGFFCCCBGGGCCCFCCWWWWWWWHVVVVVVMMBBBMMMMMMMMBBBBBBBGBGGTTFFFFFFFFBBNNNNNLLLLLLLL\nJBBBBBBBZZNAAAAAAAAAAGGGGGGEGGGGGGGGGGGGGIHDBBBBBBBBBBBBBBFFFFFCCCCCGGGCCKCCCWHHHHHHHVVVVVVMMVVVVVVMMMMMBBBBBBGGBGGTFFFFTFFFFBBBBBBBBBLLLLLL\nJJJBBBBBBAAAAAAAAAAAGGGGGGGEGGGGGGGGGGGGIIHDBBBBBBBBBBBBBBBBFFFCZCCCCCCCCCCCCHHHHHHHHVVVVVVMMVVVVVVMMMMMBBBBBBGGGGGTTFFTTFFFBBBBBBBBBBLLLLLL\nJJJBBBBAAAAAAAAAAAAAGGGGGGGGGGGGGGGGGGGGIHHDHHHHBBBBBBSSSSFFFFFCCCCCCCCCCCCCCHHHHHHHHVVVVVVHHVVVVVVMMMMMBBBBBBGGGGGTTTTTTFHFBBBBBBBBBBBLBBLV\nJJJJJJAAAAAAAAAAAAAAGGGGGGGGGGGGGGGGGGGHHHHHHHHHHIJJJJJSSSSFFFCCFFCCCCCCCCCCCHHHHHHHHVVVVVVVVVVVVVVMMMMMMBBBBGGGGGGGGGTTTLLBBBBBBBBBBBBBBBBV\nJJJJJJAAAAAAAAAAAAAAGAAGGGGGGGGGGGGGGGGHHHHHHHHHHJJJHJSSSSSFFFFFFCCCCCCCCCCCCHRHHHHHHVVVVVVVVVVVVVVGMMMMMBBBBGGGGGGGGGTTLLLLLLBBBBBBBBBBBBBB\nJJJJJJAAAAAAAAAAAAAAAAGGGGGGGGHGGGGGGGGHHHHHHHHHHJJJJJJJSJSFFFFFCCCCCCCCCCCCCCHHHHHHHVVVVVVVVVVVVVVGGMMCMBBBGGGGGGGGPGGGLLZLLLBBBBBBBBBBBBBB\nJJJJJJAAAAAAAAAAAAAAGAGGGGGGGGGGGGZZGHGHHHHHHHHHJJJJJJJJJJSFFFFFCCCCCCCCCCCCCCHHHHHHHHHOHHOOMVVVVVVGGJGGIBBBTGGGGGGTGGGLLLLLLLLBBBBBBBBBBBBB\nJJJJJAA" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       map =

     

       27
       27
       +
         puzzle_input

     

       28
       28
       +
         |> String.split("\n", trim: true)

     

       29
       29
       +
         |> Enum.with_index()

     

       30
       30
       +
         |> Enum.flat_map(fn {row, y} ->

     

       31
       31
       +
           row

     

       32
       32
       +
           |> String.split("", trim: true)

     

       33
       33
       +
           |> Enum.with_index()

     

       34
       34
       +
           |> Enum.map(fn {plant, x} -> {{x, y}, plant} end)

     

       35
       35
       +
         end)

     

       36
       36
       +
         |> Map.new()

     

       37
       37
       +
       ```

     

       38
       38
       +
       

     

       39
       39
       +
       <!-- livebook:{"output":true} -->

     

       40
       40
       +
       

     

       41
       41
       +
       ```

     

       42
       42
       +
       %{

     

       43
       43
       +
         {18, 103} => "H",

     

       44
       44
       +
         {76, 13} => "F",

     

       45
       45
       +
         {61, 121} => "X",

     

       46
       46
       +
         {112, 138} => "T",

     

       47
       47
       +
         {37, 47} => "U",

     

       48
       48
       +
         {65, 63} => "G",

     

       49
       49
       +
         {77, 129} => "E",

     

       50
       50
       +
         {120, 47} => "L",

     

       51
       51
       +
         {38, 2} => "T",

     

       52
       52
       +
         {1, 26} => "J",

     

       53
       53
       +
         {116, 69} => "W",

     

       54
       54
       +
         {124, 56} => "O",

     

       55
       55
       +
         {83, 76} => "N",

     

       56
       56
       +
         {117, 125} => "Q",

     

       57
       57
       +
         {100, 134} => "W",

     

       58
       58
       +
         {78, 139} => "D",

     

       59
       59
       +
         {32, 15} => "O",

     

       60
       60
       +
         {103, 106} => "N",

     

       61
       61
       +
         {30, 113} => "J",

     

       62
       62
       +
         {123, 104} => "W",

     

       63
       63
       +
         {68, 134} => "Q",

     

       64
       64
       +
         {124, 60} => "O",

     

       65
       65
       +
         {89, 14} => "R",

     

       66
       66
       +
         {35, 30} => "E",

     

       67
       67
       +
         {37, 53} => "H",

     

       68
       68
       +
         {77, 130} => "E",

     

       69
       69
       +
         {2, 132} => "Q",

     

       70
       70
       +
         {4, 5} => "K",

     

       71
       71
       +
         {8, 50} => "X",

     

       72
       72
       +
         {78, 98} => "Y",

     

       73
       73
       +
         {101, 62} => "X",

     

       74
       74
       +
         {98, 136} => "W",

     

       75
       75
       +
         {95, 56} => "D",

     

       76
       76
       +
         {74, 12} => "F",

     

       77
       77
       +
         {17, 138} => "F",

     

       78
       78
       +
         {102, 74} => "S",

     

       79
       79
       +
         {11, 39} => "P",

     

       80
       80
       +
         {131, 5} => "I",

     

       81
       81
       +
         {65, 43} => "S",

     

       82
       82
       +
         {22, 38} => "R",

     

       83
       83
       +
         {14, 86} => "N",

     

       84
       84
       +
         {139, 46} => "U",

     

       85
       85
       +
         {12, 135} => "Q",

     

       86
       86
       +
         {65, 131} => "A",

     

       87
       87
       +
         {49, 117} => "O",

     

       88
       88
       +
         {20, 41} => "D",

     

       89
       89
       +
         {29, 25} => "G",

     

       90
       90
       +
         {86, 10} => "R",

     

       91
       91
       +
         {83, ...} => "I",

     

       92
       92
       +
         {...} => "G",

     

       93
       93
       +
         ...

     

       94
       94
       +
       }

     

       95
       95
       +
       ```

     

       96
       96
       +
       

     

       97
       97
       +
       ```elixir

     

       98
       98
       +
       defmodule Garden do

     

       99
       99
       +
         def plots(map) do

     

       100
       100
       +
           map

     

       101
       101
       +
           |> Enum.group_by(&elem(&1, 1), &elem(&1, 0))

     

       102
       102
       +
           |> Enum.flat_map(fn {kind, pts} ->

     

       103
       103
       +
             for parcel <- parcels(MapSet.new(pts), []) do

     

       104
       104
       +
               {kind, parcel}

     

       105
       105
       +
             end

     

       106
       106
       +
           end)

     

       107
       107
       +
         end

     

       108
       108
       +
       

     

       109
       109
       +
         def parcels(set, acc) do

     

       110
       110
       +
           case Enum.take(set, 1) do

     

       111
       111
       +
             [] ->

     

       112
       112
       +
               acc

     

       113
       113
       +
       

     

       114
       114
       +
             [p] ->

     

       115
       115
       +
               {parcel, rest} = flood(p, MapSet.new(), set)

     

       116
       116
       +
       

     

       117
       117
       +
               parcels(rest, [parcel | acc])

     

       118
       118
       +
           end

     

       119
       119
       +
         end

     

       120
       120
       +
       

     

       121
       121
       +
         def flood({x, y} = curr, visited, potential) do

     

       122
       122
       +
           visited = MapSet.put(visited, curr)

     

       123
       123
       +
           potential = MapSet.delete(potential, curr)

     

       124
       124
       +
       

     

       125
       125
       +
           for next <- [

     

       126
       126
       +
                 {x - 1, y},

     

       127
       127
       +
                 {x + 1, y},

     

       128
       128
       +
                 {x, y - 1},

     

       129
       129
       +
                 {x, y + 1}

     

       130
       130
       +
               ],

     

       131
       131
       +
               next in potential,

     

       132
       132
       +
               reduce: {visited, potential} do

     

       133
       133
       +
             {v, p} -> flood(next, v, p)

     

       134
       134
       +
           end

     

       135
       135
       +
         end

     

       136
       136
       +
       

     

       137
       137
       +
         def as_int(false), do: 0

     

       138
       138
       +
         def as_int(true), do: 1

     

       139
       139
       +
       end

     

       140
       140
       +
       ```

     

       141
       141
       +
       

     

       142
       142
       +
       <!-- livebook:{"output":true} -->

     

       143
       143
       +
       

     

       144
       144
       +
       ```

     

       145
       145
       +
       {:module, Garden, <<70, 79, 82, 49, 0, 0, 15, ...>>, {:as_int, 1}}

     

       146
       146
       +
       ```

     

       147
       147
       +
       

     

       148
       148
       +
       ```elixir

     

       149
       149
       +
       plots = Garden.plots(map)

     

       150
       150
       +
       ```

     

       151
       151
       +
       

     

       152
       152
       +
       <!-- livebook:{"output":true} -->

     

       153
       153
       +
       

     

       154
       154
       +
       ```

     

       155
       155
       +
       [

     

       156
       156
       +
         {"A", MapSet.new([{131, 11}])},

     

       157
       157
       +
         {"A",

     

       158
       158
       +
          MapSet.new([

     

       159
       159
       +
            {54, 38},

     

       160
       160
       +
            {54, 39},

     

       161
       161
       +
            {55, 38},

     

       162
       162
       +
            {56, 36},

     

       163
       163
       +
            {56, 37},

     

       164
       164
       +
            {56, 38},

     

       165
       165
       +
            {57, 37},

     

       166
       166
       +
            {57, 38},

     

       167
       167
       +
            {57, 39},

     

       168
       168
       +
            {57, 40},

     

       169
       169
       +
            {58, 36},

     

       170
       170
       +
            {58, 37},

     

       171
       171
       +
            {58, 38},

     

       172
       172
       +
            {58, 39},

     

       173
       173
       +
            {58, 40},

     

       174
       174
       +
            {59, 36},

     

       175
       175
       +
            {59, 37},

     

       176
       176
       +
            {59, 38},

     

       177
       177
       +
            {60, 36},

     

       178
       178
       +
            {60, 37},

     

       179
       179
       +
            {60, 38},

     

       180
       180
       +
            {61, 36},

     

       181
       181
       +
            {61, 37},

     

       182
       182
       +
            {61, 38},

     

       183
       183
       +
            {62, 38},

     

       184
       184
       +
            {63, 38}

     

       185
       185
       +
          ])},

     

       186
       186
       +
         {"A", MapSet.new([{18, 56}])},

     

       187
       187
       +
         {"A",

     

       188
       188
       +
          MapSet.new([

     

       189
       189
       +
            {93, 86},

     

       190
       190
       +
            {94, 86},

     

       191
       191
       +
            {95, 86},

     

       192
       192
       +
            {95, 87},

     

       193
       193
       +
            {95, 88},

     

       194
       194
       +
            {96, 86},

     

       195
       195
       +
            {96, 87},

     

       196
       196
       +
            {97, 80},

     

       197
       197
       +
            {97, 81},

     

       198
       198
       +
            {97, 82},

     

       199
       199
       +
            {97, 83},

     

       200
       200
       +
            {97, 84},

     

       201
       201
       +
            {97, 85},

     

       202
       202
       +
            {97, 86},

     

       203
       203
       +
            {97, 87},

     

       204
       204
       +
            {98, 80},

     

       205
       205
       +
            {98, 81},

     

       206
       206
       +
            {98, 82},

     

       207
       207
       +
            {98, 83},

     

       208
       208
       +
            {98, 84},

     

       209
       209
       +
            {98, 85},

     

       210
       210
       +
            {99, 81},

     

       211
       211
       +
            {99, 82},

     

       212
       212
       +
            {99, 84}

     

       213
       213
       +
          ])},

     

       214
       214
       +
         {"A",

     

       215
       215
       +
          MapSet.new([

     

       216
       216
       +
            {35, 102},

     

       217
       217
       +
            {42, 111},

     

       218
       218
       +
            {38, 112},

     

       219
       219
       +
            {38, 108},

     

       220
       220
       +
            {39, 111},

     

       221
       221
       +
            {35, 106},

     

       222
       222
       +
            {41, 105},

     

       223
       223
       +
            {36, 105},

     

       224
       224
       +
            {36, 108},

     

       225
       225
       +
            {42, 110},

     

       226
       226
       +
            {35, 104},

     

       227
       227
       +
            {36, 109},

     

       228
       228
       +
            {43, 111},

     

       229
       229
       +
            {42, 107},

     

       230
       230
       +
            {41, 107},

     

       231
       231
       +
            {37, 108},

     

       232
       232
       +
            {41, 111},

     

       233
       233
       +
            {42, 108},

     

       234
       234
       +
            {39, 107},

     

       235
       235
       +
            {35, 103},

     

       236
       236
       +
            {36, 111},

     

       237
       237
       +
            {37, 113},

     

       238
       238
       +
            {37, 105},

     

       239
       239
       +
            {40, 110},

     

       240
       240
       +
            {38, 107},

     

       241
       241
       +
            {43, 107},

     

       242
       242
       +
            {38, 105},

     

       243
       243
       +
            {41, 110},

     

       244
       244
       +
            {34, 108},

     

       245
       245
       +
            {37, 109},

     

       246
       246
       +
            {35, 108},

     

       247
       247
       +
            {36, 106},

     

       248
       248
       +
            {42, 109},

     

       249
       249
       +
            {38, 114},

     

       250
       250
       +
            {37, 112},

     

       251
       251
       +
            {39, 110},

     

       252
       252
       +
            {39, 109},

     

       253
       253
       +
            {36, 103},

     

       254
       254
       +
            {38, 110},

     

       255
       255
       +
            {37, 111},

     

       256
       256
       +
            {39, 108},

     

       257
       257
       +
            {38, ...},

     

       258
       258
       +
            {...},

     

       259
       259
       +
            ...

     

       260
       260
       +
          ])},

     

       261
       261
       +
         {"A", MapSet.new([{70, 115}, {70, 116}, {70, 117}, {71, 116}, {71, 117}, {72, 116}, {72, 117}])},

     

       262
       262
       +
         {"A",

     

       263
       263
       +
          MapSet.new([

     

       264
       264
       +
            {85, 84},

     

       265
       265
       +
            {88, 82},

     

       266
       266
       +
            {87, 83},

     

       267
       267
       +
            {83, 84},

     

       268
       268
       +
            {87, 79},

     

       269
       269
       +
            {86, 82},

     

       270
       270
       +
            {86, 84},

     

       271
       271
       +
            {83, 85},

     

       272
       272
       +
            {87, 78},

     

       273
       273
       +
            {87, 84},

     

       274
       274
       +
            {85, 79},

     

       275
       275
       +
            {87, 81},

     

       276
       276
       +
            {85, 80},

     

       277
       277
       +
            {88, 83},

     

       278
       278
       +
            {84, 84},

     

       279
       279
       +
            {86, 81},

     

       280
       280
       +
            {86, 80},

     

       281
       281
       +
            {82, 85},

     

       282
       282
       +
            {85, 82},

     

       283
       283
       +
            {82, 84},

     

       284
       284
       +
            {82, 86},

     

       285
       285
       +
            {88, 81},

     

       286
       286
       +
            {87, 82},

     

       287
       287
       +
            {86, 83},

     

       288
       288
       +
            {85, 81},

     

       289
       289
       +
            {83, 83},

     

       290
       290
       +
            {84, 80},

     

       291
       291
       +
            {88, 84},

     

       292
       292
       +
            {83, 86},

     

       293
       293
       +
            {87, 80},

     

       294
       294
       +
            {87, 77},

     

       295
       295
       +
            {81, 85},

     

       296
       296
       +
            {85, 83},

     

       297
       297
       +
            {84, 85},

     

       298
       298
       +
            {84, 82},

     

       299
       299
       +
            {84, 81},

     

       300
       300
       +
            {84, 83}

     

       301
       301
       +
          ])},

     

       302
       302
       +
         {"A",

     

       303
       303
       +
          MapSet.new([

     

       304
       304
       +
            {19, 22},

     

       305
       305
       +
            {10, 25},

     

       306
       306
       +
            {16, 24},

     

       307
       307
       +
            {10, 32},

     

       308
       308
       +
            {17, 30},

     

       309
       309
       +
            {6, 29},

     

       310
       310
       +
            {18, 29},

     

       311
       311
       +
            {17, 22},

     

       312
       312
       +
            {13, 25},

     

       313
       313
       +
            {14, 24},

     

       314
       314
       +
            {10, 23},

     

       315
       315
       +
            {8, 29},

     

       316
       316
       +
            {13, 22},

     

       317
       317
       +
            {14, 28},

     

       318
       318
       +
            {6, 26},

     

       319
       319
       +
            {18, 26},

     

       320
       320
       +
            {16, 23},

     

       321
       321
       +
            {21, 26},

     

       322
       322
       +
            {19, 30},

     

       323
       323
       +
            {13, 27},

     

       324
       324
       +
            {16, 18},

     

       325
       325
       +
            {18, 23},

     

       326
       326
       +
            {9, 25},

     

       327
       327
       +
            {16, 29},

     

       328
       328
       +
            {7, 26},

     

       329
       329
       +
            {12, 27},

     

       330
       330
       +
            {16, 30},

     

       331
       331
       +
            {17, 24},

     

       332
       332
       +
            {18, 24},

     

       333
       333
       +
            {18, 22},

     

       334
       334
       +
            {6, 28},

     

       335
       335
       +
            {13, 20},

     

       336
       336
       +
            {9, 26},

     

       337
       337
       +
            {7, 27},

     

       338
       338
       +
            {11, 22},

     

       339
       339
       +
            {8, 25},

     

       340
       340
       +
            {17, 23},

     

       341
       341
       +
            {13, 23},

     

       342
       342
       +
            {20, ...},

     

       343
       343
       +
            {...},

     

       344
       344
       +
            ...

     

       345
       345
       +
          ])},

     

       346
       346
       +
         {"A",

     

       347
       347
       +
          MapSet.new([

     

       348
       348
       +
            {111, 103},

     

       349
       349
       +
            {107, 102},

     

       350
       350
       +
            {110, 102},

     

       351
       351
       +
            {110, 106},

     

       352
       352
       +
            {112, 103},

     

       353
       353
       +
            {114, 103},

     

       354
       354
       +
            {112, 100},

     

       355
       355
       +
            {108, 97},

     

       356
       356
       +
            {103, 96},

     

       357
       357
       +
            {109, 104},

     

       358
       358
       +
            {103, 99},

     

       359
       359
       +
            {108, 95},

     

       360
       360
       +
            {110, 104},

     

       361
       361
       +
            {113, 101},

     

       362
       362
       +
            {105, 105},

     

       363
       363
       +
            {108, 108},

     

       364
       364
       +
            {106, 105},

     

       365
       365
       +
            {111, 100},

     

       366
       366
       +
            {104, 98},

     

       367
       367
       +
            {109, 101},

     

       368
       368
       +
            {111, 104},

     

       369
       369
       +
            {107, 100},

     

       370
       370
       +
            {106, 102},

     

       371
       371
       +
            {112, 106},

     

       372
       372
       +
            {105, 95},

     

       373
       373
       +
            {104, 104},

     

       374
       374
       +
            {112, 97},

     

       375
       375
       +
            {108, 94},

     

       376
       376
       +
            {104, 97},

     

       377
       377
       +
            {111, 99},

     

       378
       378
       +
            {108, 102},

     

       379
       379
       +
            {108, 109},

     

       380
       380
       +
            {101, 97},

     

       381
       381
       +
            {104, 103},

     

       382
       382
       +
            {102, 96},

     

       383
       383
       +
            {112, 101},

     

       384
       384
       +
            {113, 97},

     

       385
       385
       +
            {100, ...},

     

       386
       386
       +
            {...},

     

       387
       387
       +
            ...

     

       388
       388
       +
          ])},

     

       389
       389
       +
         {"A",

     

       390
       390
       +
          MapSet.new([

     

       391
       391
       +
            {132, 99},

     

       392
       392
       +
            {136, 110},

     

       393
       393
       +
            {137, 104},

     

       394
       394
       +
            {139, 106},

     

       395
       395
       +
            {134, 98},

     

       396
       396
       +
            {139, 101},

     

       397
       397
       +
            {136, 102},

     

       398
       398
       +
            {139, 104},

     

       399
       399
       +
            {136, 96},

     

       400
       400
       +
            {134, 107},

     

       401
       401
       +
            {132, 100},

     

       402
       402
       +
            {138, 96},

     

       403
       403
       +
            {138, 102},

     

       404
       404
       +
            {135, 109},

     

       405
       405
       +
            {137, 107},

     

       406
       406
       +
            {133, 97},

     

       407
       407
       +
            {135, 107},

     

       408
       408
       +
            {137, 101},

     

       409
       409
       +
            {139, 97},

     

       410
       410
       +
            {137, 100},

     

       411
       411
       +
            {139, 109},

     

       412
       412
       +
            {135, 100},

     

       413
       413
       +
            {137, 97},

     

       414
       414
       +
            {132, 97},

     

       415
       415
       +
            {138, 105},

     

       416
       416
       +
            {137, 106},

     

       417
       417
       +
            {138, 99},

     

       418
       418
       +
            {136, 100},

     

       419
       419
       +
            {135, 98},

     

       420
       420
       +
            {139, 98},

     

       421
       421
       +
            {138, 103},

     

       422
       422
       +
            {138, 107},

     

       423
       423
       +
            {136, 108},

     

       424
       424
       +
            {139, 99},

     

       425
       425
       +
            {133, 96},

     

       426
       426
       +
            {139, 105},

     

       427
       427
       +
            {132, ...},

     

       428
       428
       +
            {...},

     

       429
       429
       +
            ...

     

       430
       430
       +
          ])},

     

       431
       431
       +
         {"A",

     

       432
       432
       +
          MapSet.new([

     

       433
       433
       +
            {84, 102},

     

       434
       434
       +
            {82, 100},

     

       435
       435
       +
            {86, 101},

     

       436
       436
       +
            {82, 91},

     

       437
       437
       +
            {86, 93},

     

       438
       438
       +
            {90, 93},

     

       439
       439
       +
            {88, 93},

     

       440
       440
       +
            {86, 96},

     

       441
       441
       +
            {82, 95},

     

       442
       442
       +
            {84, 93},

     

       443
       443
       +
            {85, 97},

     

       444
       444
       +
            {87, 95},

     

       445
       445
       +
            {81, 95},

     

       446
       446
       +
            {83, 100},

     

       447
       447
       +
            {87, 93},

     

       448
       448
       +
            {81, 100},

     

       449
       449
       +
            {84, 96},

     

       450
       450
       +
            {88, 95},

     

       451
       451
       +
            {81, 98},

     

       452
       452
       +
            {84, 100},

     

       453
       453
       +
            {85, 102},

     

       454
       454
       +
            {84, 91},

     

       455
       455
       +
            {82, 97},

     

       456
       456
       +
            {85, 99},

     

       457
       457
       +
            {83, 95},

     

       458
       458
       +
            {89, 96},

     

       459
       459
       +
            {88, 94},

     

       460
       460
       +
            {84, 104},

     

       461
       461
       +
            {86, 102},

     

       462
       462
       +
            {80, 92},

     

       463
       463
       +
            {89, 94},

     

       464
       464
       +
            {86, 103},

     

       465
       465
       +
            {83, 92},

     

       466
       466
       +
            {83, 96},

     

       467
       467
       +
            {82, 102},

     

       468
       468
       +
            {84, ...},

     

       469
       469
       +
            {...},

     

       470
       470
       +
            ...

     

       471
       471
       +
          ])},

     

       472
       472
       +
         {"A",

     

       473
       473
       +
          MapSet.new([

     

       474
       474
       +
            {65, 131},

     

       475
       475
       +
            {65, 129},

     

       476
       476
       +
            {74, 135},

     

       477
       477
       +
            {72, 134},

     

       478
       478
       +
            {71, 133},

     

       479
       479
       +
            {66, 130},

     

       480
       480
       +
            {73, 135},

     

       481
       481
       +
            {69, 130},

     

       482
       482
       +
            {74, 134},

     

       483
       483
       +
            {66, 132},

     

       484
       484
       +
            {68, 132},

     

       485
       485
       +
            {67, 128},

     

       486
       486
       +
            {69, 133},

     

       487
       487
       +
            {71, 132},

     

       488
       488
       +
            {70, 134},

     

       489
       489
       +
            {72, 132},

     

       490
       490
       +
            {72, 133},

     

       491
       491
       +
            {69, 132},

     

       492
       492
       +
            {71, 130},

     

       493
       493
       +
            {74, 136},

     

       494
       494
       +
            {73, 136},

     

       495
       495
       +
            {70, 128},

     

       496
       496
       +
            {68, 130},

     

       497
       497
       +
            {69, 129},

     

       498
       498
       +
            {73, 133},

     

       499
       499
       +
            {69, 131},

     

       500
       500
       +
            {70, 129},

     

       501
       501
       +
            {70, 130},

     

       502
       502
       +
            {67, 133},

     

       503
       503
       +
            {68, 131},

     

       504
       504
       +
            {68, 129},

     

       505
       505
       +
            {72, 135},

     

       506
       506
       +
            {68, 128},

     

       507
       507
       +
            {73, 134},

     

       508
       508
       +
            {66, ...},

     

       509
       509
       +
            {...},

     

       510
       510
       +
            ...

     

       511
       511
       +
          ])},

     

       512
       512
       +
         {"B", MapSet.new([{132, 12}, {132, 13}, {133, 12}, {133, 13}])},

     

       513
       513
       +
         {"B", MapSet.new([{111, 6}])},

     

       514
       514
       +
         {"B", MapSet.new([{104, 115}])},

     

       515
       515
       +
         {"B", MapSet.new([{83, 87}, {84, 87}, {84, 88}])},

     

       516
       516
       +
         {"B", MapSet.new([{83, 82}])},

     

       517
       517
       +
         {"B", MapSet.new([{71, 79}])},

     

       518
       518
       +
         {"B",

     

       519
       519
       +
          MapSet.new([

     

       520
       520
       +
            {69, 112},

     

       521
       521
       +
            {70, 109},

     

       522
       522
       +
            {70, 111},

     

       523
       523
       +
            {70, 112},

     

       524
       524
       +
            {71, 108},

     

       525
       525
       +
            {71, 109},

     

       526
       526
       +
            {71, 110},

     

       527
       527
       +
            {71, 111},

     

       528
       528
       +
            {72, 108}

     

       529
       529
       +
          ])},

     

       530
       530
       +
         {"B", MapSet.new([{67, 20}, {67, 21}, {68, 19}, {68, 20}])},

     

       531
       531
       +
         {"B", MapSet.new([{63, 100}])},

     

       532
       532
       +
         {"B", MapSet.new([{44, 121}, {44, 122}])},

     

       533
       533
       +
         {"B", MapSet.new([{41, 45}])},

     

       534
       534
       +
         {"B", MapSet.new([{30, 54}])},

     

       535
       535
       +
         {"B", MapSet.new([{18, 90}])},

     

       536
       536
       +
         {"B", MapSet.new([{10, 127}])},

     

       537
       537
       +
         {"B", MapSet.new([{9, 126}])},

     

       538
       538
       +
         {"B",

     

       539
       539
       +
          MapSet.new([

     

       540
       540
       +
            {37, 75},

     

       541
       541
       +
            {39, 77},

     

       542
       542
       +
            {42, 73},

     

       543
       543
       +
            {35, 75},

     

       544
       544
       +
            {39, 81},

     

       545
       545
       +
            {40, 75},

     

       546
       546
       +
            {41, 75},

     

       547
       547
       +
            {40, 77},

     

       548
       548
       +
            {40, 81},

     

       549
       549
       +
            {40, 76},

     

       550
       550
       +
            {32, 78},

     

       551
       551
       +
            {33, 78},

     

       552
       552
       +
            {32, 77},

     

       553
       553
       +
            {37, 80},

     

       554
       554
       +
            {35, 79},

     

       555
       555
       +
            {34, 75},

     

       556
       556
       +
            {30, 78},

     

       557
       557
       +
            {39, 76},

     

       558
       558
       +
            {34, ...},

     

       559
       559
       +
            {...},

     

       560
       560
       +
            ...

     

       561
       561
       +
          ])},

     

       562
       562
       +
         {"B", MapSet.new([{42, 69}])},

     

       563
       563
       +
         {"B",

     

       564
       564
       +
          MapSet.new([

     

       565
       565
       +
            {0, 21},

     

       566
       566
       +
            {1, 21},

     

       567
       567
       +
            {1, 22},

     

       568
       568
       +
            {2, 21},

     

       569
       569
       +
            {2, 22},

     

       570
       570
       +
            {3, 21},

     

       571
       571
       +
            {3, 22},

     

       572
       572
       +
            {3, 23},

     

       573
       573
       +
            {3, 24},

     

       574
       574
       +
            {4, 21},

     

       575
       575
       +
            {4, 22},

     

       576
       576
       +
            {4, 23},

     

       577
       577
       +
            {4, 24},

     

       578
       578
       +
            {5, 21},

     

       579
       579
       +
            {5, 22},

     

       580
       580
       +
            {5, 23},

     

       581
       581
       +
            {5, ...},

     

       582
       582
       +
            {...},

     

       583
       583
       +
            ...

     

       584
       584
       +
          ])},

     

       585
       585
       +
         {"B", MapSet.new([{100, 130}])},

     

       586
       586
       +
         {"B",

     

       587
       587
       +
          MapSet.new([

     

       588
       588
       +
            {108, 25},

     

       589
       589
       +
            {108, 21},

     

       590
       590
       +
            {104, 24},

     

       591
       591
       +
            {104, 21},

     

       592
       592
       +
            {109, 18},

     

       593
       593
       +
            {107, 25},

     

       594
       594
       +
            {107, 18},

     

       595
       595
       +
            {109, 17},

     

       596
       596
       +
            {107, 27},

     

       597
       597
       +
            {106, 22},

     

       598
       598
       +
            {113, 20},

     

       599
       599
       +
            {112, 17},

     

       600
       600
       +
            {106, 26},

     

       601
       601
       +
            {108, 24},

     

       602
       602
       +
            {105, ...},

     

       603
       603
       +
            {...},

     

       604
       604
       +
            ...

     

       605
       605
       +
          ])},

     

       606
       606
       +
         {"B",

     

       607
       607
       +
          MapSet.new([

     

       608
       608
       +
            {15, 93},

     

       609
       609
       +
            {18, 93},

     

       610
       610
       +
            {17, 93},

     

       611
       611
       +
            {19, 97},

     

       612
       612
       +
            {13, 98},

     

       613
       613
       +
            {16, 93},

     

       614
       614
       +
            {17, 97},

     

       615
       615
       +
            {13, 95},

     

       616
       616
       +
            {14, 93},

     

       617
       617
       +
            {12, 95},

     

       618
       618
       +
            {15, 98},

     

       619
       619
       +
            {15, 96},

     

       620
       620
       +
            {14, 95},

     

       621
       621
       +
            {14, ...},

     

       622
       622
       +
            {...},

     

       623
       623
       +
            ...

     

       624
       624
       +
          ])},

     

       625
       625
       +
         {"B",

     

       626
       626
       +
          MapSet.new([

     

       627
       627
       +
            {45, 19},

     

       628
       628
       +
            {53, 23},

     

       629
       629
       +
            {54, 16},

     

       630
       630
       +
            {55, 17},

     

       631
       631
       +
            {53, 19},

     

       632
       632
       +
            {55, 20},

     

       633
       633
       +
            {56, 18},

     

       634
       634
       +
            {55, 21},

     

       635
       635
       +
            {49, 20},

     

       636
       636
       +
            {56, 22},

     

       637
       637
       +
            {47, 22},

     

       638
       638
       +
            {54, 23},

     

       639
       639
       +
            {47, ...},

     

       640
       640
       +
            {...},

     

       641
       641
       +
            ...

     

       642
       642
       +
          ])},

     

       643
       643
       +
         {"B",

     

       644
       644
       +
          MapSet.new([

     

       645
       645
       +
            {98, 9},

     

       646
       646
       +
            {97, 20},

     

       647
       647
       +
            {95, 16},

     

       648
       648
       +
            {100, 18},

     

       649
       649
       +
            {94, 21},

     

       650
       650
       +
            {97, 10},

     

       651
       651
       +
            {102, 16},

     

       652
       652
       +
            {93, 17},

     

       653
       653
       +
            {98, 19},

     

       654
       654
       +
            {95, 17},

     

       655
       655
       +
            {96, 13},

     

       656
       656
       +
            {92, ...},

     

       657
       657
       +
            {...},

     

       658
       658
       +
            ...

     

       659
       659
       +
          ])},

     

       660
       660
       +
         {"B",

     

       661
       661
       +
          MapSet.new([

     

       662
       662
       +
            {58, 10},

     

       663
       663
       +
            {61, 7},

     

       664
       664
       +
            {53, 9},

     

       665
       665
       +
            {58, 8},

     

       666
       666
       +
            {55, 11},

     

       667
       667
       +
            {60, 10},

     

       668
       668
       +
            {60, 11},

     

       669
       669
       +
            {60, 12},

     

       670
       670
       +
            {61, 11},

     

       671
       671
       +
            {59, 13},

     

       672
       672
       +
            {56, ...},

     

       673
       673
       +
            {...},

     

       674
       674
       +
            ...

     

       675
       675
       +
          ])},

     

       676
       676
       +
         {"B",

     

       677
       677
       +
          MapSet.new([

     

       678
       678
       +
            {131, 24},

     

       679
       679
       +
            {129, 25},

     

       680
       680
       +
            {130, 28},

     

       681
       681
       +
            {132, 31},

     

       682
       682
       +
            {127, 22},

     

       683
       683
       +
            {132, 33},

     

       684
       684
       +
            {130, 25},

     

       685
       685
       +
            {123, 25},

     

       686
       686
       +
            {130, 27},

     

       687
       687
       +
            {126, ...},

     

       688
       688
       +
            {...},

     

       689
       689
       +
            ...

     

       690
       690
       +
          ])},

     

       691
       691
       +
         {"B", MapSet.new([{30, 42}, {31, 42}, {32, 42}])},

     

       692
       692
       +
         {"C", MapSet.new([{114, 87}, {114, 88}])},

     

       693
       693
       +
         {"C", MapSet.new([{103, 27}])},

     

       694
       694
       +
         {"C", MapSet.new([{98, 4}, {98, 5}])},

     

       695
       695
       +
         {"C", MapSet.new([{92, 104}])},

     

       696
       696
       +
         {"C", MapSet.new([{83, 33}])},

     

       697
       697
       +
         {"C", MapSet.new([{82, 87}])},

     

       698
       698
       +
         {"C", MapSet.new([{76, 32}])},

     

       699
       699
       +
         {"C", MapSet.new([{75, ...}])},

     

       700
       700
       +
         {"C", MapSet.new([{...}])},

     

       701
       701
       +
         {"C", MapSet.new([...])},

     

       702
       702
       +
         {"C", ...},

     

       703
       703
       +
         {...},

     

       704
       704
       +
         ...

     

       705
       705
       +
       ]

     

       706
       706
       +
       ```

     

       707
       707
       +
       

     

       708
       708
       +
       ## Part 1

     

       709
       709
       +
       

     

       710
       710
       +
       ```elixir

     

       711
       711
       +
       defmodule Garden.Circ do

     

       712
       712
       +
         def circumfence(set) do

     

       713
       713
       +
           {{sx, _}, {ex, _}} = Enum.min_max_by(set, &elem(&1, 0))

     

       714
       714
       +
           {{_, sy}, {_, ey}} = Enum.min_max_by(set, &elem(&1, 1))

     

       715
       715
       +
       

     

       716
       716
       +
           rows = (sx - 1)..(ex + 1)//1

     

       717
       717
       +
           cols = (sy - 1)..(ey + 1)//1

     

       718
       718
       +
       

     

       719
       719
       +
           vert =

     

       720
       720
       +
             rows

     

       721
       721
       +
             |> Enum.map(fn x -> count_flips(cols, &({x, &1} in set)) end)

     

       722
       722
       +
             |> Enum.sum()

     

       723
       723
       +
       

     

       724
       724
       +
           hori =

     

       725
       725
       +
             cols

     

       726
       726
       +
             |> Enum.map(fn y -> count_flips(rows, &({&1, y} in set)) end)

     

       727
       727
       +
             |> Enum.sum()

     

       728
       728
       +
       

     

       729
       729
       +
           vert + hori

     

       730
       730
       +
         end

     

       731
       731
       +
         

     

       732
       732
       +
         defp count_flips(enum, init \\ false, func) do

     

       733
       733
       +
           Enum.reduce(enum, {0, init}, fn elem, {count, last} ->

     

       734
       734
       +
             curr = func.(elem)

     

       735
       735
       +
             {count + Garden.as_int(last != curr), curr}

     

       736
       736
       +
           end)

     

       737
       737
       +
           |> elem(0)

     

       738
       738
       +
         end

     

       739
       739
       +
       end

     

       740
       740
       +
       ```

     

       741
       741
       +
       

     

       742
       742
       +
       <!-- livebook:{"output":true} -->

     

       743
       743
       +
       

     

       744
       744
       +
       ```

     

       745
       745
       +
       {:module, Garden.Circ, <<70, 79, 82, 49, 0, 0, 15, ...>>, {:count_flips, 3}}

     

       746
       746
       +
       ```

     

       747
       747
       +
       

     

       748
       748
       +
       ```elixir

     

       749
       749
       +
       plots

     

       750
       750
       +
       |> Enum.map(fn {_, points} ->

     

       751
       751
       +
         Garden.Circ.circumfence(points) * MapSet.size(points)

     

       752
       752
       +
       end)

     

       753
       753
       +
       |> Enum.sum()

     

       754
       754
       +
       ```

     

       755
       755
       +
       

     

       756
       756
       +
       <!-- livebook:{"output":true} -->

     

       757
       757
       +
       

     

       758
       758
       +
       ```

     

       759
       759
       +
       1464678

     

       760
       760
       +
       ```

     

       761
       761
       +
       

     

       762
       762
       +
       ## Part 2

     

       763
       763
       +
       

     

       764
       764
       +
       ```elixir

     

       765
       765
       +
       defmodule Garden.Sides do

     

       766
       766
       +
         def sides(set) do

     

       767
       767
       +
           xy = do_count(set, 0, 1)

     

       768
       768
       +
           yx = do_count(set, 1, 0)

     

       769
       769
       +
       

     

       770
       770
       +
           xy + yx

     

       771
       771
       +
         end

     

       772
       772
       +
       

     

       773
       773
       +
         defp do_count(set, a, b) do

     

       774
       774
       +
           set

     

       775
       775
       +
           |> Enum.group_by(&elem(&1, a), &elem(&1, b))

     

       776
       776
       +
           |> Enum.sort()

     

       777
       777
       +
           |> Enum.map(fn {_, row} -> row |> Enum.map(&(&1..&1)) |> RangeSet.new() end)

     

       778
       778
       +
           |> Enum.chunk_every(2, 1, [RangeSet.new()])

     

       779
       779
       +
           |> Enum.flat_map(fn [top, bot] ->

     

       780
       780
       +
             top.ranges

     

       781
       781
       +
             |> Enum.map(fn a..b//_ ->

     

       782
       782
       +
               Garden.as_int(not Enum.any?(bot.ranges, &(a == &1.first))) +

     

       783
       783
       +
                 Garden.as_int(not Enum.any?(bot.ranges, &(b == &1.last)))

     

       784
       784
       +
             end)

     

       785
       785
       +
           end)

     

       786
       786
       +
           |> Enum.sum()

     

       787
       787
       +
         end

     

       788
       788
       +
       end

     

       789
       789
       +
       ```

     

       790
       790
       +
       

     

       791
       791
       +
       <!-- livebook:{"output":true} -->

     

       792
       792
       +
       

     

       793
       793
       +
       ```

     

       794
       794
       +
       {:module, Garden.Sides, <<70, 79, 82, 49, 0, 0, 16, ...>>, {:do_count, 3}}

     

       795
       795
       +
       ```

     

       796
       796
       +
       

     

       797
       797
       +
       ```elixir

     

       798
       798
       +
       plots

     

       799
       799
       +
       |> Enum.map(fn {_, plot} ->

     

       800
       800
       +
         Garden.Sides.sides(plot) * MapSet.size(plot)

     

       801
       801
       +
       end)

     

       802
       802
       +
       |> Enum.sum()

     

       803
       803
       +
       ```

     

       804
       804
       +
       

     

       805
       805
       +
       <!-- livebook:{"output":true} -->

     

       806
       806
       +
       

     

       807
       807
       +
       ```

     

       808
       808
       +
       877492

     

       809
       809
       +
       ```

     

       810
       810
       +
       

     

       811
       811
       +
       <!-- livebook:{"offset":17848,"stamp":{"token":"XCP.d5P0-cESwFZ7qUYI4K40J_3AxksZ7WIqnIE6sn4smJvJahembJKNW-3db5gLxIgp_FEyn1pBBioGJSDsU7MO2fi1HjFgxeFNU0dLXi9Z4tf68Ey8dtld73d7SrSGlcv2DDM","version":2}} -->

+272

2024/day13.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 13

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIxMyIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI0In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "13", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok,

     

       22
       22
       +
        "Button A: X+22, Y+88\nButton B: X+90, Y+28\nPrize: X=6496, Y=3076\n\nButton A: X+54, Y+14\nButton B: X+14, Y+44\nPrize: X=8084, Y=1284\n\nButton A: X+96, Y+15\nButton B: X+55, Y+63\nPrize: X=5535, Y=3966\n\nButton A: X+17, Y+42\nButton B: X+40, Y+25\nPrize: X=12176, Y=3136\n\nButton A: X+87, Y+31\nButton B: X+15, Y+36\nPrize: X=6672, Y=2500\n\nButton A: X+59, Y+27\nButton B: X+21, Y+56\nPrize: X=1475, Y=15098\n\nButton A: X+39, Y+51\nButton B: X+98, Y+14\nPrize: X=7890, Y=3126\n\nButton A: X+23, Y+37\nButton B: X+35, Y+14\nPrize: X=16537, Y=6184\n\nButton A: X+21, Y+89\nButton B: X+74, Y+23\nPrize: X=2407, Y=8748\n\nButton A: X+47, Y+17\nButton B: X+35, Y+59\nPrize: X=17994, Y=16242\n\nButton A: X+14, Y+45\nButton B: X+52, Y+16\nPrize: X=18768, Y=3912\n\nButton A: X+29, Y+45\nButton B: X+85, Y+11\nPrize: X=3149, Y=4161\n\nButton A: X+81, Y+95\nButton B: X+67, Y+12\nPrize: X=5489, Y=2110\n\nButton A: X+48, Y+58\nButton B: X+86, Y+22\nPrize: X=4802, Y=2280\n\nButton A: X+27, Y+59\nButton B: X+47, Y+15\nPrize: X=2602, Y=2090\n\nButton A: X+39, Y+87\nButton B: X+94, Y+38\nPrize: X=8830, Y=6134\n\nButton A: X+23, Y+61\nButton B: X+82, Y+16\nPrize: X=8405, Y=3957\n\nButton A: X+54, Y+14\nButton B: X+24, Y+63\nPrize: X=894, Y=1708\n\nButton A: X+26, Y+14\nButton B: X+18, Y+35\nPrize: X=5510, Y=12541\n\nButton A: X+65, Y+55\nButton B: X+21, Y+69\nPrize: X=430, Y=620\n\nButton A: X+11, Y+62\nButton B: X+50, Y+11\nPrize: X=11414, Y=3683\n\nButton A: X+21, Y+54\nButton B: X+93, Y+22\nPrize: X=7683, Y=5642\n\nButton A: X+20, Y+95\nButton B: X+52, Y+29\nPrize: X=5580, Y=10155\n\nButton A: X+37, Y+13\nButton B: X+11, Y+66\nPrize: X=18250, Y=14983\n\nButton A: X+54, Y+28\nButton B: X+37, Y+58\nPrize: X=17939, Y=14902\n\nButton A: X+87, Y+65\nButton B: X+11, Y+79\nPrize: X=3765, Y=4087\n\nButton A: X+74, Y+30\nButton B: X+16, Y+59\nPrize: X=9858, Y=8342\n\nButton A: X+74, Y+31\nButton B: X+17, Y+59\nPrize: X=14764, Y=6598\n\nButton A: X+12, Y+95\nButton B: X+27, Y+33\nPrize: X=945, Y=3324\n\nButton A: X+21, Y+36\nButton B: X+34, Y+14\nPrize: X=7247, Y=5012\n\nButton A: X+48, Y+62\nButton B: X+90, Y+29\nPrize: X=9150, Y=5973\n\nButton A: X+93, Y+43\nButton B: X+49, Y+91\nPrize: X=7090, Y=6422\n\nButton A: X+28, Y+70\nButton B: X+68, Y+21\nPrize: X=17176, Y=3693\n\nButton A: X+33, Y+16\nButton B: X+27, Y+51\nPrize: X=1884, Y=2771\n\nButton A: X+11, Y+43\nButton B: X+51, Y+19\nPrize: X=4114, Y=10066\n\nButton A: X+26, Y+70\nButton B: X+87, Y+46\nPrize: X=3532, Y=6874\n\nButton A: X+22, Y+35\nButton B: X+38, Y+13\nPrize: X=7508, Y=16592\n\nButton A: X+33, Y+16\nButton B: X+48, Y+72\nPrize: X=12065, Y=15896\n\nButton A: X+67, Y+25\nButton B: X+14, Y+55\nPrize: X=4093, Y=10275\n\nButton A: X+36, Y+17\nButton B: X+43, Y+77\nPrize: X=3253, Y=1933\n\nButton A: X+84, Y+24\nButton B: X+42, Y+69\nPrize: X=8862, Y=4869\n\nButton A: X+70, Y+16\nButton B: X+17, Y+68\nPrize: X=5690, Y=3224\n\nButton A: X+58, Y+27\nButton B: X+44, Y+92\nPrize: X=1890, Y=1595\n\nButton A: X+64, Y+30\nButton B: X+29, Y+57\nPrize: X=15004, Y=15224\n\nButton A: X+13, Y+90\nButton B: X+64, Y+33\nPrize: X=6560, Y=6048\n\nButton A: X+37, Y+91\nButton B: X+64, Y+49\nPrize: X=5214, Y=8379\n\nButton A: X+12, Y+80\nButton B: X+75, Y+25\nPrize: X=6684, Y=8460\n\nButton A: X+27, Y+53\nButton B: X+53, Y+30\nPrize: X=4897, Y=14148\n\nButton A: X+41, Y+11\nButton B: X+39, Y+72\nPrize: X=2818, Y=493\n\nButton A: X+74, Y+45\nButton B: X+14, Y+35\nPrize: X=8996, Y=13510\n\nButton A: X+11, Y+36\nButton B: X+86, Y+58\nPrize: X=18273, Y=14722\n\nButton A: X+99, Y+72\nButton B: X+11, Y+39\nPrize: X=2530, Y=3390\n\nButton A: X+55, Y+17\nButton B: X+22, Y+80\nPrize: X=3652, Y=6326\n\nButton A: X+11, Y+17\nButton B: X+76, Y+16\nPrize: X=5480, Y=1976\n\nButton A: X+18, Y+73\nButton B: X+28, Y+22\nPrize: X=3222, Y=4827\n\nButton A: X+14, Y+46\nButton B: X+33, Y+29\nPrize: X=2212, Y=3932\n\nButton A: X+11, Y+14\nButton B: X+80, Y+28\nPrize: X=4187, Y=2450\n\nButton A: X+28, Y+70\nButton B: X+78, Y+25\nPrize: X=2220, Y=1810\n\nButton A: X+53, Y+19\nButton B: X+73, Y+91\nPrize: X=4514, Y=2850\n\nButton A: X+21, Y+54\nButton B: X+54, Y+25\nPrize: X=5609, Y=7594\n\nButton A: X+79, Y+15\nButton B: X+16, Y+80\nPrize: X=14993, Y=17105\n\nButton A: X+20, Y+59\nButton B: X+35, Y+17\nPrize: X=10820, Y=1709\n\nButton A: X+96, Y+22\nButton B: X+24, Y+43\n" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       #puzzle_input =

     

       27
       27
       +
         """

     

       28
       28
       +
       Button A: X+94, Y+34

     

       29
       29
       +
       Button B: X+22, Y+67

     

       30
       30
       +
       Prize: X=8400, Y=5400

     

       31
       31
       +
       

     

       32
       32
       +
       Button A: X+26, Y+66

     

       33
       33
       +
       Button B: X+67, Y+21

     

       34
       34
       +
       Prize: X=12748, Y=12176

     

       35
       35
       +
       

     

       36
       36
       +
       Button A: X+17, Y+86

     

       37
       37
       +
       Button B: X+84, Y+37

     

       38
       38
       +
       Prize: X=7870, Y=6450

     

       39
       39
       +
       

     

       40
       40
       +
       Button A: X+69, Y+23

     

       41
       41
       +
       Button B: X+27, Y+71

     

       42
       42
       +
       Prize: X=18641, Y=10279

     

       43
       43
       +
         """

     

       44
       44
       +
       ```

     

       45
       45
       +
       

     

       46
       46
       +
       <!-- livebook:{"output":true} -->

     

       47
       47
       +
       

     

       48
       48
       +
       ```

     

       49
       49
       +
       warning: outdented heredoc line. The contents inside the heredoc should be indented at the same level as the closing """. The following is forbidden:

     

       50
       50
       +
       

     

       51
       51
       +
           def text do

     

       52
       52
       +
             """

     

       53
       53
       +
           contents

     

       54
       54
       +
             """

     

       55
       55
       +
           end

     

       56
       56
       +
       

     

       57
       57
       +
       Instead make sure the contents are indented as much as the heredoc closing:

     

       58
       58
       +
       

     

       59
       59
       +
           def text do

     

       60
       60
       +
             """

     

       61
       61
       +
             contents

     

       62
       62
       +
             """

     

       63
       63
       +
           end

     

       64
       64
       +
       

     

       65
       65
       +
       The current heredoc line is indented too little

     

       66
       66
       +
       └─ Workspace/hauleth/advent-of-code/2024/day13.livemd#cell:b6uoz4dag7jywljr:3:3

     

       67
       67
       +
       

     

       68
       68
       +
       ```

     

       69
       69
       +
       

     

       70
       70
       +
       <!-- livebook:{"output":true} -->

     

       71
       71
       +
       

     

       72
       72
       +
       ```

     

       73
       73
       +
       "Button A: X+94, Y+34\nButton B: X+22, Y+67\nPrize: X=8400, Y=5400\n\nButton A: X+26, Y+66\nButton B: X+67, Y+21\nPrize: X=12748, Y=12176\n\nButton A: X+17, Y+86\nButton B: X+84, Y+37\nPrize: X=7870, Y=6450\n\nButton A: X+69, Y+23\nButton B: X+27, Y+71\nPrize: X=18641, Y=10279\n"

     

       74
       74
       +
       ```

     

       75
       75
       +
       

     

       76
       76
       +
       ```elixir

     

       77
       77
       +
       games =

     

       78
       78
       +
         puzzle_input

     

       79
       79
       +
         |> String.split("\n\n", trim: true)

     

       80
       80
       +
         |> Enum.map(fn game ->

     

       81
       81
       +
           [

     

       82
       82
       +
             "Button A: X+" <> <<ax::2-binary>> <> ", Y+" <> <<ay::2-binary>>,

     

       83
       83
       +
             "Button B: X+" <> <<bx::2-binary>> <> ", Y+" <> <<by::2-binary>>,

     

       84
       84
       +
             "Prize: " <> prize_pos

     

       85
       85
       +
           ] = String.split(game, "\n", trim: true)

     

       86
       86
       +
       

     

       87
       87
       +
           ["X=" <> px, "Y=" <> py] = String.split(prize_pos, ", ")

     

       88
       88
       +
       

     

       89
       89
       +
           %{

     

       90
       90
       +
             btn_a: {String.to_integer(ax), String.to_integer(ay)},

     

       91
       91
       +
             btn_b: {String.to_integer(bx), String.to_integer(by)},

     

       92
       92
       +
             prize: {String.to_integer(px), String.to_integer(py)}

     

       93
       93
       +
           }

     

       94
       94
       +
         end)

     

       95
       95
       +
       ```

     

       96
       96
       +
       

     

       97
       97
       +
       <!-- livebook:{"output":true} -->

     

       98
       98
       +
       

     

       99
       99
       +
       ```

     

       100
       100
       +
       [

     

       101
       101
       +
         %{btn_a: {22, 88}, btn_b: {90, 28}, prize: {6496, 3076}},

     

       102
       102
       +
         %{btn_a: {54, 14}, btn_b: {14, 44}, prize: {8084, 1284}},

     

       103
       103
       +
         %{btn_a: {96, 15}, btn_b: {55, 63}, prize: {5535, 3966}},

     

       104
       104
       +
         %{btn_a: {17, 42}, btn_b: {40, 25}, prize: {12176, 3136}},

     

       105
       105
       +
         %{btn_a: {87, 31}, btn_b: {15, 36}, prize: {6672, 2500}},

     

       106
       106
       +
         %{btn_a: {59, 27}, btn_b: {21, 56}, prize: {1475, 15098}},

     

       107
       107
       +
         %{btn_a: {39, 51}, btn_b: {98, 14}, prize: {7890, 3126}},

     

       108
       108
       +
         %{btn_a: {23, 37}, btn_b: {35, 14}, prize: {16537, 6184}},

     

       109
       109
       +
         %{btn_a: {21, 89}, btn_b: {74, 23}, prize: {2407, 8748}},

     

       110
       110
       +
         %{btn_a: {47, 17}, btn_b: {35, 59}, prize: {17994, 16242}},

     

       111
       111
       +
         %{btn_a: {14, 45}, btn_b: {52, 16}, prize: {18768, 3912}},

     

       112
       112
       +
         %{btn_a: {29, 45}, btn_b: {85, 11}, prize: {3149, 4161}},

     

       113
       113
       +
         %{btn_a: {81, 95}, btn_b: {67, 12}, prize: {5489, 2110}},

     

       114
       114
       +
         %{btn_a: {48, 58}, btn_b: {86, 22}, prize: {4802, 2280}},

     

       115
       115
       +
         %{btn_a: {27, 59}, btn_b: {47, 15}, prize: {2602, 2090}},

     

       116
       116
       +
         %{btn_a: {39, 87}, btn_b: {94, 38}, prize: {8830, 6134}},

     

       117
       117
       +
         %{btn_a: {23, 61}, btn_b: {82, 16}, prize: {8405, 3957}},

     

       118
       118
       +
         %{btn_a: {54, 14}, btn_b: {24, 63}, prize: {894, 1708}},

     

       119
       119
       +
         %{btn_a: {26, 14}, btn_b: {18, 35}, prize: {5510, 12541}},

     

       120
       120
       +
         %{btn_a: {65, 55}, btn_b: {21, 69}, prize: {430, 620}},

     

       121
       121
       +
         %{btn_a: {11, 62}, btn_b: {50, 11}, prize: {11414, 3683}},

     

       122
       122
       +
         %{btn_a: {21, 54}, btn_b: {93, 22}, prize: {7683, 5642}},

     

       123
       123
       +
         %{btn_a: {20, 95}, btn_b: {52, 29}, prize: {5580, 10155}},

     

       124
       124
       +
         %{btn_a: {37, 13}, btn_b: {11, 66}, prize: {18250, 14983}},

     

       125
       125
       +
         %{btn_a: {54, 28}, btn_b: {37, 58}, prize: {17939, 14902}},

     

       126
       126
       +
         %{btn_a: {87, 65}, btn_b: {11, 79}, prize: {3765, 4087}},

     

       127
       127
       +
         %{btn_a: {74, 30}, btn_b: {16, 59}, prize: {9858, 8342}},

     

       128
       128
       +
         %{btn_a: {74, 31}, btn_b: {17, 59}, prize: {14764, 6598}},

     

       129
       129
       +
         %{btn_a: {12, 95}, btn_b: {27, 33}, prize: {945, 3324}},

     

       130
       130
       +
         %{btn_a: {21, 36}, btn_b: {34, 14}, prize: {7247, 5012}},

     

       131
       131
       +
         %{btn_a: {48, 62}, btn_b: {90, 29}, prize: {9150, 5973}},

     

       132
       132
       +
         %{btn_a: {93, 43}, btn_b: {49, 91}, prize: {7090, 6422}},

     

       133
       133
       +
         %{btn_a: {28, 70}, btn_b: {68, 21}, prize: {17176, 3693}},

     

       134
       134
       +
         %{btn_a: {33, 16}, btn_b: {27, 51}, prize: {1884, 2771}},

     

       135
       135
       +
         %{btn_a: {11, 43}, btn_b: {51, 19}, prize: {4114, 10066}},

     

       136
       136
       +
         %{btn_a: {26, 70}, btn_b: {87, 46}, prize: {3532, 6874}},

     

       137
       137
       +
         %{btn_a: {22, 35}, btn_b: {38, 13}, prize: {7508, 16592}},

     

       138
       138
       +
         %{btn_a: {33, 16}, btn_b: {48, 72}, prize: {12065, 15896}},

     

       139
       139
       +
         %{btn_a: {67, 25}, btn_b: {14, 55}, prize: {4093, 10275}},

     

       140
       140
       +
         %{btn_a: {36, 17}, btn_b: {43, 77}, prize: {3253, 1933}},

     

       141
       141
       +
         %{btn_a: {84, 24}, btn_b: {42, 69}, prize: {8862, 4869}},

     

       142
       142
       +
         %{btn_a: {70, 16}, btn_b: {17, 68}, prize: {5690, 3224}},

     

       143
       143
       +
         %{btn_a: {58, 27}, btn_b: {44, 92}, prize: {1890, 1595}},

     

       144
       144
       +
         %{btn_a: {64, 30}, btn_b: {29, 57}, prize: {15004, 15224}},

     

       145
       145
       +
         %{btn_a: {13, 90}, btn_b: {64, 33}, prize: {6560, 6048}},

     

       146
       146
       +
         %{btn_a: {37, 91}, btn_b: {64, 49}, prize: {5214, ...}},

     

       147
       147
       +
         %{btn_a: {12, 80}, btn_b: {75, ...}, prize: {...}},

     

       148
       148
       +
         %{btn_a: {27, ...}, btn_b: {...}, ...},

     

       149
       149
       +
         %{btn_a: {...}, ...},

     

       150
       150
       +
         %{...},

     

       151
       151
       +
         ...

     

       152
       152
       +
       ]

     

       153
       153
       +
       ```

     

       154
       154
       +
       

     

       155
       155
       +
       Yay, matrices again. We need to solve linear equations in form of:

     

       156
       156
       +
       

     

       157
       157
       +
       $$

     

       158
       158
       +
       \begin{cases}

     

       159
       159
       +
       a_x x & + & b_x y & = & p_x \\

     

       160
       160
       +
       a_y x & + & b_x y & = & p_y

     

       161
       161
       +
       \end{cases}

     

       162
       162
       +
       $$

     

       163
       163
       +
       

     

       164
       164
       +
       So we need to solve:

     

       165
       165
       +
       

     

       166
       166
       +
       $$

     

       167
       167
       +
       \begin{bmatrix}

     

       168
       168
       +
       a_x & b_x \\

     

       169
       169
       +
       a_y & b_y

     

       170
       170
       +
       \end{bmatrix}

     

       171
       171
       +
       \begin{bmatrix}

     

       172
       172
       +
       x \\

     

       173
       173
       +
       y

     

       174
       174
       +
       \end{bmatrix}

     

       175
       175
       +
       = \begin{bmatrix}

     

       176
       176
       +
       p_x \\

     

       177
       177
       +
       p_y

     

       178
       178
       +
       \end{bmatrix}

     

       179
       179
       +
       $$

     

       180
       180
       +
       

     

       181
       181
       +
       For each game. So we can use [Cramer's Rule](https://en.wikipedia.org/wiki/Cramer%27s_rule).

     

       182
       182
       +
       

     

       183
       183
       +
       $$

     

       184
       184
       +
       \begin{gather*}

     

       185
       185
       +
       x = \frac{\text{det}(A_x)}{\text{det}(A)} \\

     

       186
       186
       +
       y = \frac{\text{det}(A_y)}{\text{det}(A)}

     

       187
       187
       +
       \end{gather*}

     

       188
       188
       +
       $$

     

       189
       189
       +
       

     

       190
       190
       +
       Assuming that $\text{det}(A) \ne 0$ (otherwise there will be no solution). In case of $2\times2$ matrices determinant is simple to compute:

     

       191
       191
       +
       

     

       192
       192
       +
       $$

     

       193
       193
       +
       \text{det}

     

       194
       194
       +
       \begin{vmatrix}

     

       195
       195
       +
       a & b \\

     

       196
       196
       +
       c & d

     

       197
       197
       +
       \end{vmatrix}

     

       198
       198
       +
       = ad - bc

     

       199
       199
       +
       $$

     

       200
       200
       +
       

     

       201
       201
       +
       So in the end we need to compute:

     

       202
       202
       +
       

     

       203
       203
       +
       $$

     

       204
       204
       +
       \begin{gather*}

     

       205
       205
       +
       x = \frac{p_x b_y - b_x p_y}{a_x b_y - b_x a_y} \\

     

       206
       206
       +
       y = \frac{a_x p_y - p_x a_y}{a_x b_y - b_x a_y}

     

       207
       207
       +
       \end{gather*}

     

       208
       208
       +
       $$

     

       209
       209
       +
       

     

       210
       210
       +
       And reject cases where $x$ or $y$ is non-integer value.

     

       211
       211
       +
       

     

       212
       212
       +
       ```elixir

     

       213
       213
       +
       defmodule Game do

     

       214
       214
       +
         def solve(%{btn_a: {ax, ay}, btn_b: {bx, by}, prize: {px, py}}) do

     

       215
       215
       +
           det_a = ax * by - bx * ay

     

       216
       216
       +
           det_x = px * by - bx * py

     

       217
       217
       +
           det_y = ax * py - px * ay

     

       218
       218
       +
           

     

       219
       219
       +
           if rem(det_x, det_a) == 0 do

     

       220
       220
       +
             {div(det_x, det_a), div(det_y, det_a)}

     

       221
       221
       +
           end

     

       222
       222
       +
         end

     

       223
       223
       +
       end

     

       224
       224
       +
       ```

     

       225
       225
       +
       

     

       226
       226
       +
       <!-- livebook:{"output":true} -->

     

       227
       227
       +
       

     

       228
       228
       +
       ```

     

       229
       229
       +
       {:module, Game, <<70, 79, 82, 49, 0, 0, 8, ...>>, {:solve, 1}}

     

       230
       230
       +
       ```

     

       231
       231
       +
       

     

       232
       232
       +
       ## Part 1

     

       233
       233
       +
       

     

       234
       234
       +
       ```elixir

     

       235
       235
       +
       games

     

       236
       236
       +
       |> Enum.map(&Game.solve/1)

     

       237
       237
       +
       |> Enum.map(fn

     

       238
       238
       +
         nil -> 0

     

       239
       239
       +
         {a, b} -> a * 3 + b * 1

     

       240
       240
       +
       end)

     

       241
       241
       +
       |> Enum.sum()

     

       242
       242
       +
       ```

     

       243
       243
       +
       

     

       244
       244
       +
       <!-- livebook:{"output":true} -->

     

       245
       245
       +
       

     

       246
       246
       +
       ```

     

       247
       247
       +
       31897

     

       248
       248
       +
       ```

     

       249
       249
       +
       

     

       250
       250
       +
       ## Part 2

     

       251
       251
       +
       

     

       252
       252
       +
       ```elixir

     

       253
       253
       +
       games

     

       254
       254
       +
       |> Enum.map(fn %{prize: {px, py}} = game ->

     

       255
       255
       +
         add = 10_000_000_000_000

     

       256
       256
       +
         %{game | prize: {px + add, py + add}}

     

       257
       257
       +
       end)

     

       258
       258
       +
       |> Enum.map(&Game.solve/1)

     

       259
       259
       +
       |> Enum.map(fn

     

       260
       260
       +
         nil -> 0

     

       261
       261
       +
         {a, b} -> a * 3 + b * 1

     

       262
       262
       +
       end)

     

       263
       263
       +
       |> Enum.sum()

     

       264
       264
       +
       ```

     

       265
       265
       +
       

     

       266
       266
       +
       <!-- livebook:{"output":true} -->

     

       267
       267
       +
       

     

       268
       268
       +
       ```

     

       269
       269
       +
       87596249540359

     

       270
       270
       +
       ```

     

       271
       271
       +
       

     

       272
       272
       +
       <!-- livebook:{"offset":11449,"stamp":{"token":"XCP.AhVykQ8wyKxhTI29dXZZ0BnWEqWCuVGz8E2TRFpScgbUfqJJtY47yrvU9g9OzcejZVc8LbU3ak4YrgSGy5A5XeARPC3qt5fGPV4K9PYS3YabI7-q8rCKi8R6ZpGBpmZeDNQ","version":2}} -->

+219

2024/day14.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 14

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc, :image])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIxNCIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI0In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "14", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok,

     

       22
       22
       +
        "p=49,14 v=-82,-41\np=27,80 v=67,31\np=76,93 v=-15,-66\np=90,62 v=-84,86\np=62,86 v=46,20\np=7,72 v=25,26\np=30,32 v=-92,60\np=91,40 v=6,1\np=50,58 v=57,-21\np=71,79 v=-3,58\np=84,44 v=36,-59\np=87,12 v=-62,-95\np=69,46 v=76,39\np=50,51 v=-26,-64\np=41,58 v=30,5\np=80,97 v=-13,9\np=52,84 v=98,-50\np=52,32 v=64,39\np=52,91 v=61,20\np=31,22 v=49,45\np=85,73 v=-43,32\np=77,15 v=20,-52\np=17,10 v=74,-3\np=88,92 v=-54,26\np=20,46 v=31,-63\np=42,49 v=-26,44\np=3,101 v=40,-95\np=78,77 v=-17,48\np=10,88 v=-88,55\np=100,68 v=74,76\np=42,11 v=-97,-25\np=88,57 v=-37,93\np=11,36 v=-33,54\np=88,61 v=-58,43\np=66,47 v=-55,82\np=11,52 v=52,-60\np=9,48 v=41,-64\np=70,57 v=61,27\np=22,80 v=11,11\np=73,11 v=65,56\np=79,84 v=-28,41\np=50,79 v=-93,-12\np=55,35 v=23,-64\np=48,26 v=45,29\np=38,23 v=-86,-54\np=71,48 v=-21,6\np=60,98 v=28,-54\np=75,70 v=59,7\np=24,71 v=-20,-46\np=55,88 v=79,-23\np=13,48 v=44,49\np=37,73 v=-86,-99\np=82,12 v=-26,80\np=13,16 v=-8,30\np=86,34 v=84,99\np=45,90 v=-31,68\np=23,93 v=44,8\np=3,52 v=-65,-54\np=64,7 v=16,-30\np=97,88 v=-67,-39\np=58,87 v=72,42\np=8,70 v=-27,5\np=25,67 v=99,22\np=48,92 v=19,31\np=23,46 v=-16,-76\np=13,101 v=70,13\np=55,4 v=-25,-39\np=44,10 v=10,-59\np=56,2 v=83,67\np=90,83 v=28,42\np=28,84 v=7,-12\np=49,87 v=-7,-50\np=11,56 v=-76,87\np=27,72 v=46,-28\np=76,43 v=-59,32\np=19,50 v=80,62\np=12,1 v=44,-84\np=53,29 v=83,61\np=57,12 v=-63,-90\np=67,39 v=38,71\np=38,78 v=86,26\np=14,19 v=-72,-85\np=75,9 v=42,-43\np=89,33 v=65,-43\np=77,21 v=-64,54\np=32,72 v=-45,-71\np=9,21 v=55,-4\np=22,49 v=70,-71\np=86,73 v=-35,-7\np=32,5 v=-41,-62\np=14,51 v=89,-92\np=71,34 v=24,-69\np=87,18 v=69,-10\np=58,67 v=4,-28\np=22,75 v=15,26\np=73,14 v=-77,24\np=2,26 v=-12,91\np=53,3 v=38,-57\np=49,35 v=-37,-59\np=25,87 v=52,-83\np=47,74 v=46,-22\np=70,22 v=-81,24\np=46,57 v=23,-76\np=59,96 v=27,-40\np=72,77 v=99,28\np=66,89 v=61,-67\np=46,43 v=70,-23\np=30,55 v=-67,48\np=8,75 v=89,-17\np=15,29 v=-86,-3\np=53,2 v=38,-56\np=6,90 v=55,-83\np=44,83 v=8,-50\np=2,56 v=-54,-43\np=30,13 v=19,-62\np=21,97 v=-78,-46\np=13,53 v=70,22\np=2,5 v=59,56\np=2,48 v=18,50\np=81,94 v=92,57\np=1,1 v=6,-59\np=99,61 v=-65,-76\np=99,95 v=-24,35\np=17,53 v=-84,19\np=33,77 v=-4,53\np=100,32 v=-3,-43\np=60,74 v=-10,97\np=23,54 v=-57,-75\np=56,69 v=27,21\np=58,100 v=-51,44\np=43,77 v=-41,-93\np=75,3 v=80,13\np=66,32 v=72,34\np=67,67 v=-32,69\np=80,80 v=-23,-3\np=62,23 v=-4,48\np=77,0 v=87,30\np=2,96 v=-35,-73\np=15,4 v=4,-38\np=92,56 v=-54,-16\np=90,46 v=26,-16\np=75,2 v=1,67\np=59,71 v=-59,-33\np=79,21 v=-62,24\np=34,99 v=45,14\np=49,18 v=-37,-76\np=63,26 v=79,-41\np=97,54 v=-80,71\np=66,18 v=69,-30\np=14,25 v=74,-90\np=9,95 v=-87,96\np=24,39 v=-8,83\np=32,98 v=-75,79\np=36,50 v=-23,-92\np=97,36 v=-73,86\np=66,36 v=23,-53\np=84,3 v=2,95\np=89,73 v=48,26\np=3,94 v=-46,68\np=61,75 v=-52,-98\np=51,36 v=8,50\np=70,48 v=80,-2\np=32,39 v=-54,4\np=73,85 v=-92,-72\np=22,70 v=-12,38\np=92,48 v=-92,93\np=100,79 v=-76,-12\np=1,52 v=-43,65\np=22,98 v=78,52\np=35,76 v=-97,48\np=52,14 v=-48,-74\np=7,55 v=29,98\np=79,40 v=-2,-38\np=90,91 v=57,-72\np=60,3 v=-14,-94\np=34,69 v=-56,32\np=63,19 v=-44,24\np=48,71 v=-18,-98\np=90,42 v=-87,9\np=73,59 v=27,-28\np=30,66 v=18,-48\np=9,54 v=-79,-43\np=57,73 v=-73,-34\np=75,93 v=-39,60\np=31,75 v=-98,86\np=93,86 v=-95,-45\np=64,33 v=33,4\np=62,27 v=12,46\np=76,93 v=91,58\np=92,23 v=-13,29\np=54,93 v=69,51\np=19,53 v=59,-16\np=78,90 v=84,-7\np=17,93 v=33,25\np=100,73 v=5,59\np=74,39 v=80,28\np=88,4 v=84,19\np=63,98 v=-65,-2\np=81,98 v=32,4\np=64,89 v=-7,9\np=88,3 v=-35,9\np=77,14 v=-62,-79\np=15,15 v=18,-41\np=40,4 v=41,-24\np=14,68 v=89,-98\np=77,71 v=-14,97\np=69,28 v=1,-9\np=16,102 v=-87,52\np=26,20 v=-62,15\np=100,25 v=28,-37\np=22,63 v=93,-5\np=9,47 v=77,-47\np=78,36 v=76,-95\np=41,84 v=52,63\np=14,6 v=30,-88\np=99,72 v=59,42\np=72,45 v=7,-21\np=99,71 v=-20,-98\np=30,40 v=-6,82\np=75,50 v=-99,97\np=91,80 v=8,44\np=7,44 v=52,-91\np=96,12 v=-50,-74\np=72,48 v=-88,-33\np=21,7 v=-29,-3\np=96,38 v=2,-48\np=33,22 v=86,-36\np=79,84 v=-36,-77\np=87,65 v=2,48\np=46,42 v=98,-11\np=60,79 v=80,-27\np=95,3 v=-2,-94\np=94,75 v=88,-29\np=16,66 v=-24,48\np=83,51 v=-24,-64\np=54,94 v=-10,-7\np=0,96 v=-8,-96\np=4,50 v=-31,71\np=21,98 v=-66,-4\np=50,85 v=-48,69\np=71,14 v=5,67\np=19,56 v=71,6\np=18,43 v=-16,-49\np=11,25 v=18,45\np=38,90 v=-52,-34\np=50,9 v=-89,73\np=15,23 v=" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       robots =

     

       27
       27
       +
         puzzle_input

     

       28
       28
       +
         |> String.split("\n", trim: true)

     

       29
       29
       +
         |> Enum.map(fn row ->

     

       30
       30
       +
           ["p=" <> pos, "v=" <> v] = String.split(row, " ")

     

       31
       31
       +
       

     

       32
       32
       +
           pos = pos |> String.split(",") |> Enum.map(&String.to_integer/1) |> List.to_tuple()

     

       33
       33
       +
           v = v |> String.split(",") |> Enum.map(&String.to_integer/1) |> List.to_tuple()

     

       34
       34
       +
       

     

       35
       35
       +
           %{pos: pos, v: v}

     

       36
       36
       +
         end)

     

       37
       37
       +
       ```

     

       38
       38
       +
       

     

       39
       39
       +
       <!-- livebook:{"output":true} -->

     

       40
       40
       +
       

     

       41
       41
       +
       ```

     

       42
       42
       +
       [

     

       43
       43
       +
         %{pos: {49, 14}, v: {-82, -41}},

     

       44
       44
       +
         %{pos: {27, 80}, v: {67, 31}},

     

       45
       45
       +
         %{pos: {76, 93}, v: {-15, -66}},

     

       46
       46
       +
         %{pos: {90, 62}, v: {-84, 86}},

     

       47
       47
       +
         %{pos: {62, 86}, v: {46, 20}},

     

       48
       48
       +
         %{pos: {7, 72}, v: {25, 26}},

     

       49
       49
       +
         %{pos: {30, 32}, v: {-92, 60}},

     

       50
       50
       +
         %{pos: {91, 40}, v: {6, 1}},

     

       51
       51
       +
         %{pos: {50, 58}, v: {57, -21}},

     

       52
       52
       +
         %{pos: {71, 79}, v: {-3, 58}},

     

       53
       53
       +
         %{pos: {84, 44}, v: {36, -59}},

     

       54
       54
       +
         %{pos: {87, 12}, v: {-62, -95}},

     

       55
       55
       +
         %{pos: {69, 46}, v: {76, 39}},

     

       56
       56
       +
         %{pos: {50, 51}, v: {-26, -64}},

     

       57
       57
       +
         %{pos: {41, 58}, v: {30, 5}},

     

       58
       58
       +
         %{pos: {80, 97}, v: {-13, 9}},

     

       59
       59
       +
         %{pos: {52, 84}, v: {98, -50}},

     

       60
       60
       +
         %{pos: {52, 32}, v: {64, 39}},

     

       61
       61
       +
         %{pos: {52, 91}, v: {61, 20}},

     

       62
       62
       +
         %{pos: {31, 22}, v: {49, 45}},

     

       63
       63
       +
         %{pos: {85, 73}, v: {-43, 32}},

     

       64
       64
       +
         %{pos: {77, 15}, v: {20, -52}},

     

       65
       65
       +
         %{pos: {17, 10}, v: {74, -3}},

     

       66
       66
       +
         %{pos: {88, 92}, v: {-54, 26}},

     

       67
       67
       +
         %{pos: {20, 46}, v: {31, -63}},

     

       68
       68
       +
         %{pos: {42, 49}, v: {-26, 44}},

     

       69
       69
       +
         %{pos: {3, 101}, v: {40, -95}},

     

       70
       70
       +
         %{pos: {78, 77}, v: {-17, 48}},

     

       71
       71
       +
         %{pos: {10, 88}, v: {-88, 55}},

     

       72
       72
       +
         %{pos: {100, 68}, v: {74, 76}},

     

       73
       73
       +
         %{pos: {42, 11}, v: {-97, -25}},

     

       74
       74
       +
         %{pos: {88, 57}, v: {-37, 93}},

     

       75
       75
       +
         %{pos: {11, 36}, v: {-33, 54}},

     

       76
       76
       +
         %{pos: {88, 61}, v: {-58, 43}},

     

       77
       77
       +
         %{pos: {66, 47}, v: {-55, 82}},

     

       78
       78
       +
         %{pos: {11, 52}, v: {52, -60}},

     

       79
       79
       +
         %{pos: {9, 48}, v: {41, -64}},

     

       80
       80
       +
         %{pos: {70, 57}, v: {61, 27}},

     

       81
       81
       +
         %{pos: {22, 80}, v: {11, 11}},

     

       82
       82
       +
         %{pos: {73, 11}, v: {65, 56}},

     

       83
       83
       +
         %{pos: {79, 84}, v: {-28, 41}},

     

       84
       84
       +
         %{pos: {50, 79}, v: {-93, -12}},

     

       85
       85
       +
         %{pos: {55, 35}, v: {23, -64}},

     

       86
       86
       +
         %{pos: {48, 26}, v: {45, 29}},

     

       87
       87
       +
         %{pos: {38, 23}, v: {-86, -54}},

     

       88
       88
       +
         %{pos: {71, 48}, v: {-21, 6}},

     

       89
       89
       +
         %{pos: {60, 98}, v: {28, ...}},

     

       90
       90
       +
         %{pos: {75, ...}, v: {...}},

     

       91
       91
       +
         %{pos: {...}, ...},

     

       92
       92
       +
         %{...},

     

       93
       93
       +
         ...

     

       94
       94
       +
       ]

     

       95
       95
       +
       ```

     

       96
       96
       +
       

     

       97
       97
       +
       ```elixir

     

       98
       98
       +
       room = {w, h} = {101, 103}

     

       99
       99
       +
       ```

     

       100
       100
       +
       

     

       101
       101
       +
       <!-- livebook:{"output":true} -->

     

       102
       102
       +
       

     

       103
       103
       +
       ```

     

       104
       104
       +
       {101, 103}

     

       105
       105
       +
       ```

     

       106
       106
       +
       

     

       107
       107
       +
       ```elixir

     

       108
       108
       +
       defmodule Robot do

     

       109
       109
       +
         def walk(robots, room, n \\ 1), do: Enum.map(robots, &move(&1, room, n))

     

       110
       110
       +
       

     

       111
       111
       +
         def move(%{pos: {x, y}, v: {vx, vy}}, {w, h}, by \\ 1) do

     

       112
       112
       +
           x = Integer.mod(x + vx * by, w)

     

       113
       113
       +
           y = Integer.mod(y + vy * by, h)

     

       114
       114
       +
       

     

       115
       115
       +
           %{pos: {x, y}, v: {vx, vy}}

     

       116
       116
       +
         end

     

       117
       117
       +
       

     

       118
       118
       +
         def quad(%{pos: {x, y}}, {w, h}) do

     

       119
       119
       +
           hw = div(w - 1, 2)

     

       120
       120
       +
           hh = div(h - 1, 2)

     

       121
       121
       +
       

     

       122
       122
       +
           if x == hw or y == hh do

     

       123
       123
       +
             :middle

     

       124
       124
       +
           else

     

       125
       125
       +
             {sign(x - hw), sign(y - hh)}

     

       126
       126
       +
           end

     

       127
       127
       +
         end

     

       128
       128
       +
       

     

       129
       129
       +
         defp sign(0), do: 0

     

       130
       130
       +
         defp sign(n) when n < 0, do: -1

     

       131
       131
       +
         defp sign(n) when n > 0, do: 1

     

       132
       132
       +
       

     

       133
       133
       +
         def with_neighbours(robots) do

     

       134
       134
       +
           set = MapSet.new(robots, & &1.pos)

     

       135
       135
       +
       

     

       136
       136
       +
           with_neighbours =

     

       137
       137
       +
             Enum.count(robots, fn %{pos: {x, y}} ->

     

       138
       138
       +
               [{x + 1, y}, {x - 1, y}, {x, y - 1}, {x, y + 1}] |> Enum.any?(&(&1 in set))

     

       139
       139
       +
             end)

     

       140
       140
       +
       

     

       141
       141
       +
           div(with_neighbours * 100, length(robots))

     

       142
       142
       +
         end

     

       143
       143
       +
       end

     

       144
       144
       +
       ```

     

       145
       145
       +
       

     

       146
       146
       +
       <!-- livebook:{"output":true} -->

     

       147
       147
       +
       

     

       148
       148
       +
       ```

     

       149
       149
       +
       {:module, Robot, <<70, 79, 82, 49, 0, 0, 18, ...>>, {:with_neighbours, 1}}

     

       150
       150
       +
       ```

     

       151
       151
       +
       

     

       152
       152
       +
       ## Part 1

     

       153
       153
       +
       

     

       154
       154
       +
       ```elixir

     

       155
       155
       +
       robots

     

       156
       156
       +
       |> Robot.walk(room, 100)

     

       157
       157
       +
       |> Enum.group_by(fn robot -> Robot.quad(robot, room) end)

     

       158
       158
       +
       |> Map.new(fn {k, l} -> {k, length(l)} end)

     

       159
       159
       +
       |> Map.drop([:middle])

     

       160
       160
       +
       |> Map.values()

     

       161
       161
       +
       |> Enum.product()

     

       162
       162
       +
       ```

     

       163
       163
       +
       

     

       164
       164
       +
       <!-- livebook:{"output":true} -->

     

       165
       165
       +
       

     

       166
       166
       +
       ```

     

       167
       167
       +
       219150360

     

       168
       168
       +
       ```

     

       169
       169
       +
       

     

       170
       170
       +
       ## Part 2

     

       171
       171
       +
       

     

       172
       172
       +
       Hack that I have found over the internet - if more than 60% of the robots have neighbours, you have found solution.

     

       173
       173
       +
       

     

       174
       174
       +
       Othe hack that I have found - checking whether there are no robots that are occupying the same position - didn't work for me.

     

       175
       175
       +
       

     

       176
       176
       +
       ```elixir

     

       177
       177
       +
       {tree, steps} =

     

       178
       178
       +
         Stream.from_index()

     

       179
       179
       +
         |> Task.async_stream(

     

       180
       180
       +
           fn step ->

     

       181
       181
       +
             robots = Robot.walk(robots, room, step)

     

       182
       182
       +
       

     

       183
       183
       +
             if Robot.with_neighbours(robots) >= 60, do: {robots, step}

     

       184
       184
       +
           end,

     

       185
       185
       +
           ordered: false

     

       186
       186
       +
         )

     

       187
       187
       +
         |> Enum.find_value(fn {:ok, val} -> val end)

     

       188
       188
       +
       

     

       189
       189
       +
       steps

     

       190
       190
       +
       ```

     

       191
       191
       +
       

     

       192
       192
       +
       <!-- livebook:{"output":true} -->

     

       193
       193
       +
       

     

       194
       194
       +
       ```

     

       195
       195
       +
       8053

     

       196
       196
       +
       ```

     

       197
       197
       +
       

     

       198
       198
       +
       ```elixir

     

       199
       199
       +
       Image.new!(w, h)

     

       200
       200
       +
       |> Image.mutate(fn img ->

     

       201
       201
       +
         for %{pos: {x, y}} <- tree do

     

       202
       202
       +
           # Add some festivity

     

       203
       203
       +
           color =

     

       204
       204
       +
             if abs(:math.sin(x + y)) < 0.5 do

     

       205
       205
       +
               :red

     

       206
       206
       +
             else

     

       207
       207
       +
               :green

     

       208
       208
       +
             end

     

       209
       209
       +
       

     

       210
       210
       +
           Image.Draw.point(img, x, y, color: color)

     

       211
       211
       +
         end

     

       212
       212
       +
       

     

       213
       213
       +
         {:ok, img}

     

       214
       214
       +
       end)

     

       215
       215
       +
       |> elem(1)

     

       216
       216
       +
       |> Image.resize!(4, interpolate: :nearest)

     

       217
       217
       +
       ```

     

       218
       218
       +
       

     

       219
       219
       +
       <!-- livebook:{"offset":9213,"stamp":{"token":"XCP.bbViODF6Z4_TcNSzpaXWzuFflurdyZ5JsvKHJZr6NjgJ4MQaH2OorTxA-YR5uDBN5HxiB0uC5hX0vi-Kgdm26HMcOubYpE_c39bjuPfPH_BH4SVxLeEac5c8aaRtPdt7CJk","version":2}} -->

+395

2024/day15.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 15

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIxNSIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI0In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "15", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok,

     

       22
       22
       +
        "##################################################\n##...O...#OO...O.#....#....#O#O..O..O......O..O..#\n#OOOO.#.O.O.....OO#...O.OO.O....O.#..OO....O#OOO.#\n#...#.#O..O...OO......O.......#....O..O#.O..OO...#\n#.O.....O..#.........O......OO..O..OO.OO....O.O..#\n#.....O.OO.O.#.O...O..#.OOOO..#...#.O.OO.O.#.#OO##\n#...OO.#..O.O.#.O..OO..O....O...OO.OOO.......O...#\n##.O.....O..#O...........O..O.....O.......OO.....#\n#...O..O....O...O...O...O..O..O...O......O..OO...#\n#.O##.O.OO.....O.O.#....O#.....OO.O.O.#..O....#O.#\n#.............#.O........OOO.OO..#.............O.#\n#OOO..O.O.........OO....O.#......#.OO.......O..O.#\n#.......#...O..#O.OO...O..#O.O...##O#O......O##..#\n#O#.O..#........O....O.....O...#O..#......O.O..O.#\n#O..O..O#...#.......OO.OO..O.....O..O..O.O.O...O.#\n#...O.O...OO.......#O#O...O.##.....#..O.O.....O..#\n#.#OOOO..OO..O....O.O....OO.#.OO..O.......O....#.#\n#..O...#.....#.....OO..#O....O#.O....O..OOO.O...O#\n#.O.......OO.O.#........OO...O..O#..O.#..##...#.O#\n#.O..#..........OO.O.O..O..O.......O...O.O.OO....#\n#.O..##..........OO..O..O.....#OO#...#..O....O...#\n#O.OOOO.O..O........O#.#OO.OO...OO.#OO..OO#O.....#\n#..OO..........O...O....O.O.....O.....O...#..O..O#\n#.#O..O..O.....#.O...#........O.O.O..O.......#.O.#\n#..##..O.....O......O..O@........O....O#.O..OO..O#\n#...O..##O.#....#.......O..OO#..O.O.....##O....O.#\n#....O.O...O.OOO.O.O#..O..OOOOOOOOOO#.....O...#.O#\n#O.....#O..O..#..O....O.O..OOOO.#.O.O#....#.O.O#.#\n#..O.O..#O..............O....###..O#.O.....O.#O#O#\n#O...O.O.#.#..O......OO.OO#..O...O.O....O#.O...OO#\n#..OO.O#.....O##.O##....O..#..#..#O..O.....#....O#\n#....#..O..O....O.OO...O.......OO.OO...O.O.....O.#\n#....O.O.#O.#OO.......O......O........OOO..O.....#\n#..#...##.O......##.....O..O.O#.O...O....O..#.O..#\n#...O.O..O....O..O.OOOOOO...#.O...OO.#.....OO.O..#\n#O.......O....#.OO.OO...OO...##O......O.O........#\n##.O.OO.OO...O..O#......O.O....#.............O.#.#\n#O#O...O..O..OO.O.O...OO..O.O..OOOO..O..O...O..O.#\n#..OO.O#O..O..#.O..O.#...#..O.....OO..OOO..O...O.#\n#.O.O..OO.....O...O.....O..#..O..#.O.#.OOO...O.O.#\n#.O..O.......O...OO#.#..O....O...O....O..........#\n#....O..O.OO...OO..#....#O.OO.OO##.....O.........#\n#..O..O....O...O....OO#.#O..O.#.#O.O..O...#....O.#\n#.O.....O.#.O#.O..O.OO.O#............O..........O#\n#..O#O.O.........O.#.O#O..#O.O.........O....O..O.#\n#..O.....#OO..O..#.#.#....O.O.OO.O.O......O#.#O..#\n#.O.O..O.O.O.O...O..O..OO..................#OO...#\n#..O....O....O.....OOO...OO..OO.......O....OO....#\n#.O....OO.O................OO....O.O#O.O.........#\n##################################################\n\n>v>>>^>>v>vv^v^^v^^^<v^vv^vv<<>^v^^^<<<vv<>vv^^>v>v^^><>^<v<v><>>^>^<^^v>v<>^^v<><<^><v>v^v<<^>^>^>^>>vvv>^<<^^^^^><vv>>^>^^>^vv>><v^^v^<<<>^^<<<^^^vv^<^<<<>v<^v<v>^<>v<^>>^v^<>><><<^<>v>^>^>v>>v>vv^><v<v^v>vv>><^^<<>>vv<<^vv>^^vv>>><^v^>>v<<<<v>^<><>^>v^vv>v>><><^vvv>^><<>^<<<vvv^>^vv<<>v^^^>v<>^^vv>vv^<>^<>vvv<vvvv^^^<^vv^<v^<<vv^v<><vvvv^>vv<>><><<v>><^>v<>v<v<v>^v>^<>^v>>><^>>v<<<v^>^v>v>^^>^v<v^v^^<vv^v^><<^^<v^v>>^v>>>>>v<v^>^>^v^>vv^v^><^<v>^^<>^v^>><>>><vv<<>^v<^vvv<v^vvv^>v<<v>>^>><<^v^^v>^^>^<<<>v^^>><<v>^<v^<^>v>>>^^^<<vvv^>vvv>^><v>^>vvv^^^v^^>v^><v>><>^<v<<vv^^>>^^v>><vv>vvv>^>>>vv^><^<v<<<^^v>v^<v^^>^^<<<>v^vv<vvv>^v>v<^^>vv>v<>>vv<><v>v<^^<<^>>v<v^<>^<<v>><<vv^<<<<v^^^v^^<^<^<>v><^<>>v>v>v>v>v><v>>v<<^>>><v^v<v>>v^><^v^>>>^>^<<>>^^v><^<v^vv^<><>>v^^>v<vvv>v<>><<<<<>><<><v<>vv><^^^><vv<v<<>v^>v>>^^v^v^>vvv<v^<>><<<^>vvv><^^v>v<>v><^<v>v<^<<^<>v>>>>^<>^^^>v<v<<vv><v>>>^<^>v^><vv>^<<v<>><<^<>>>^v>><<>v^^v<^>v^v^>vvvv>vv<<>^^^<v>^<<v>>><<>>>vv^<^><><^^^>^v^<><>^<vv<^vv^^v>^<\n<^>vv>v>^^>^vvvv<<^><^<>>^<v>v>>^^<v><^<>><<<>^vv<>v<v^>>>^<<^<><<>^^vv^^<<><<vvv>v^^>vv^<v<<>>v><^>v^>>^^v<<<<^v<v<<>>v><v^>vv^<vv^>^v>^^>>><>v<><^v><vvvv^v<<>>^^v><>>vv^>v>v^>^>v<><^v>v^^<<>^v^>^>v<><^v<^^vv<>^^^v^>>><<><<<<v^v^><v<v<^^^><><^<<^^^vv<^^<^<v>v<<v^>>v<>>^<vv<^<v><>^<^v^>^v>>>^v>>v^>^^v^>><<v>>^<v>^vvv<v<<<v>^<>vv<^<v<>^<>v^v^>vv^v>><^>><>^^^<<v<vv^<vv>>v<^^^>vv<^^>vv^^^^<<^<v^>v<v>vvv<v<<^^><v<<^>^^<>v>>v><^v^<v>vv^<v<<v>v>vvv^>v<vv>>>>>^^v<<>^><>v^^^>^^>^>^^vvvv^v<v>>^^^v>>^<v<^^v>>><<>^^><<<^>v^^^v><v<v<v^v^><>^>v<v<^^^>" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       #puzzle_input =

     

       27
       27
       +
         """

     

       28
       28
       +
       ##########

     

       29
       29
       +
       #..O..O.O#

     

       30
       30
       +
       #......O.#

     

       31
       31
       +
       #.OO..O.O#

     

       32
       32
       +
       #..O@..O.#

     

       33
       33
       +
       #O#..O...#

     

       34
       34
       +
       #O..O..O.#

     

       35
       35
       +
       #.OO.O.OO#

     

       36
       36
       +
       #....O...#

     

       37
       37
       +
       ##########

     

       38
       38
       +
       

     

       39
       39
       +
       <vv>^<v^>v>^vv^v>v<>v^v<v<^vv<<<^><<><>>v<vvv<>^v^>^<<<><<v<<<v^vv^v>^

     

       40
       40
       +
       vvv<<^>^v^^><<>>><>^<<><^vv^^<>vvv<>><^^v>^>vv<>v<<<<v<^v>^<^^>>>^<v<v

     

       41
       41
       +
       ><>vv>v^v^<>><>>>><^^>vv>v<^^^>>v^v^<^^>v^^>v^<^v>v<>>v^v^<v>v^^<^^vv<

     

       42
       42
       +
       <<v<^>>^^^^>>>v^<>vvv^><v<<<>^^^vv^<vvv>^>v<^^^^v<>^>vvvv><>>v^<<^^^^^

     

       43
       43
       +
       ^><^><>>><>^^<<^^v>>><^<v>^<vv>>v>>>^v><>^v><<<<v>>v<v<v>vvv>^<><<>^><

     

       44
       44
       +
       ^>><>^v<><^vvv<^^<><v<<<<<><^v<<<><<<^^<v<^^^><^>>^<v^><<<^>>^v<v^v<v^

     

       45
       45
       +
       >^>>^v>vv>^<<^v<>><<><<v<<v><>v<^vv<<<>^^v^>^^>>><<^v>>v^v><^^>>^<>vv^

     

       46
       46
       +
       <><^^>^^^<><vvvvv^v<v<<>^v<v>v<<^><<><<><<<^^<<<^<<>><<><^^^>^^<>^>v<>

     

       47
       47
       +
       ^^>vv<^v^v<vv>^<><v<^v>^^^>>>^^vvv^>vvv<>>>^<^>>>>>^<<^v>^vvv<>^<><<v>

     

       48
       48
       +
       v^^>>><<^^<>>^v^<v^vv<>v^<<>^<^v^v><^<<<><<^<v><v<>vv>>v><v^<vv<>v^<<^

     

       49
       49
       +
         """

     

       50
       50
       +
       

     

       51
       51
       +
       #puzzle_input =

     

       52
       52
       +
         """

     

       53
       53
       +
       ########

     

       54
       54
       +
       #..O.O.#

     

       55
       55
       +
       ##@.O..#

     

       56
       56
       +
       #...O..#

     

       57
       57
       +
       #.#.O..#

     

       58
       58
       +
       #...O..#

     

       59
       59
       +
       #......#

     

       60
       60
       +
       ########

     

       61
       61
       +
       

     

       62
       62
       +
       <^^>>>vv<v>>v<<

     

       63
       63
       +
         """

     

       64
       64
       +
       ```

     

       65
       65
       +
       

     

       66
       66
       +
       <!-- livebook:{"output":true} -->

     

       67
       67
       +
       

     

       68
       68
       +
       ```

     

       69
       69
       +
       warning: outdented heredoc line. The contents inside the heredoc should be indented at the same level as the closing """. The following is forbidden:

     

       70
       70
       +
       

     

       71
       71
       +
           def text do

     

       72
       72
       +
             """

     

       73
       73
       +
           contents

     

       74
       74
       +
             """

     

       75
       75
       +
           end

     

       76
       76
       +
       

     

       77
       77
       +
       Instead make sure the contents are indented as much as the heredoc closing:

     

       78
       78
       +
       

     

       79
       79
       +
           def text do

     

       80
       80
       +
             """

     

       81
       81
       +
             contents

     

       82
       82
       +
             """

     

       83
       83
       +
           end

     

       84
       84
       +
       

     

       85
       85
       +
       The current heredoc line is indented too little

     

       86
       86
       +
       └─ Workspace/hauleth/advent-of-code/2024/day15.livemd#cell:7w6bq5lw7vctw7mk:3:3

     

       87
       87
       +
       

     

       88
       88
       +
       warning: outdented heredoc line. The contents inside the heredoc should be indented at the same level as the closing """. The following is forbidden:

     

       89
       89
       +
       

     

       90
       90
       +
           def text do

     

       91
       91
       +
             """

     

       92
       92
       +
           contents

     

       93
       93
       +
             """

     

       94
       94
       +
           end

     

       95
       95
       +
       

     

       96
       96
       +
       Instead make sure the contents are indented as much as the heredoc closing:

     

       97
       97
       +
       

     

       98
       98
       +
           def text do

     

       99
       99
       +
             """

     

       100
       100
       +
             contents

     

       101
       101
       +
             """

     

       102
       102
       +
           end

     

       103
       103
       +
       

     

       104
       104
       +
       The current heredoc line is indented too little

     

       105
       105
       +
       └─ Workspace/hauleth/advent-of-code/2024/day15.livemd#cell:7w6bq5lw7vctw7mk:28:3

     

       106
       106
       +
       

     

       107
       107
       +
       warning: code block contains unused literal "##########\n#..O..O.O#\n#......O.#\n#.OO..O.O#\n#..O@..O.#\n#O#..O...#\n#O..O..O.#\n#.OO.O.OO#\n#....O...#\n##########\n\n<vv>^<v^>v>^vv^v>v<>v^v<v<^vv<<<^><<><>>v<vvv<>^v^>^<<<><<v<<<v^vv^v>^\nvvv<<^>^v^^><<>>><>^<<><^vv^^<>vvv<>><^^v>^>vv<>v<<<<v<^v>^<^^>>>^<v<v\n><>vv>v^v^<>><>>>><^^>vv>v<^^^>>v^v^<^^>v^^>v^<^v>v<>>v^v^<v>v^^<^^vv<\n<<v<^>>^^^^>>>v^<>vvv^><v<<<>^^^vv^<vvv>^>v<^^^^v<>^>vvvv><>>v^<<^^^^^\n^><^><>>><>^^<<^^v>>><^<v>^<vv>>v>>>^v><>^v><<<<v>>v<v<v>vvv>^<><<>^><\n^>><>^v<><^vvv<^^<><v<<<<<><^v<<<><<<^^<v<^^^><^>>^<v^><<<^>>^v<v^v<v^\n>^>>^v>vv>^<<^v<>><<><<v<<v><>v<^vv<<<>^^v^>^^>>><<^v>>v^v><^^>>^<>vv^\n<><^^>^^^<><vvvvv^v<v<<>^v<v>v<<^><<><<><<<^^<<<^<<>><<><^^^>^^<>^>v<>\n^^>vv<^v^v<vv>^<><v<^v>^^^>>>^^vvv^>vvv<>>>^<^>>>>>^<<^v>^vvv<>^<><<v>\nv^^>>><<^^<>>^v^<v^vv<>v^<<>^<^v^v><^<<<><<^<v><v<>vv>>v><v^<vv<>v^<<^\n" (remove the literal or assign it to _ to avoid warnings)

     

       108
       108
       +
       └─ Workspace/hauleth/advent-of-code/2024/day15.livemd#cell:7w6bq5lw7vctw7mk:1

     

       109
       109
       +
       

     

       110
       110
       +
       ```

     

       111
       111
       +
       

     

       112
       112
       +
       <!-- livebook:{"output":true} -->

     

       113
       113
       +
       

     

       114
       114
       +
       ```

     

       115
       115
       +
       "########\n#..O.O.#\n##@.O..#\n#...O..#\n#.#.O..#\n#...O..#\n#......#\n########\n\n<^^>>>vv<v>>v<<\n"

     

       116
       116
       +
       ```

     

       117
       117
       +
       

     

       118
       118
       +
       ```elixir

     

       119
       119
       +
       [map, moves] = String.split(puzzle_input, "\n\n")

     

       120
       120
       +
       ```

     

       121
       121
       +
       

     

       122
       122
       +
       <!-- livebook:{"output":true} -->

     

       123
       123
       +
       

     

       124
       124
       +
       ```

     

       125
       125
       +
       ["##################################################\n##...O...#OO...O.#....#....#O#O..O..O......O..O..#\n#OOOO.#.O.O.....OO#...O.OO.O....O.#..OO....O#OOO.#\n#...#.#O..O...OO......O.......#....O..O#.O..OO...#\n#.O.....O..#.........O......OO..O..OO.OO....O.O..#\n#.....O.OO.O.#.O...O..#.OOOO..#...#.O.OO.O.#.#OO##\n#...OO.#..O.O.#.O..OO..O....O...OO.OOO.......O...#\n##.O.....O..#O...........O..O.....O.......OO.....#\n#...O..O....O...O...O...O..O..O...O......O..OO...#\n#.O##.O.OO.....O.O.#....O#.....OO.O.O.#..O....#O.#\n#.............#.O........OOO.OO..#.............O.#\n#OOO..O.O.........OO....O.#......#.OO.......O..O.#\n#.......#...O..#O.OO...O..#O.O...##O#O......O##..#\n#O#.O..#........O....O.....O...#O..#......O.O..O.#\n#O..O..O#...#.......OO.OO..O.....O..O..O.O.O...O.#\n#...O.O...OO.......#O#O...O.##.....#..O.O.....O..#\n#.#OOOO..OO..O....O.O....OO.#.OO..O.......O....#.#\n#..O...#.....#.....OO..#O....O#.O....O..OOO.O...O#\n#.O.......OO.O.#........OO...O..O#..O.#..##...#.O#\n#.O..#..........OO.O.O..O..O.......O...O.O.OO....#\n#.O..##..........OO..O..O.....#OO#...#..O....O...#\n#O.OOOO.O..O........O#.#OO.OO...OO.#OO..OO#O.....#\n#..OO..........O...O....O.O.....O.....O...#..O..O#\n#.#O..O..O.....#.O...#........O.O.O..O.......#.O.#\n#..##..O.....O......O..O@........O....O#.O..OO..O#\n#...O..##O.#....#.......O..OO#..O.O.....##O....O.#\n#....O.O...O.OOO.O.O#..O..OOOOOOOOOO#.....O...#.O#\n#O.....#O..O..#..O....O.O..OOOO.#.O.O#....#.O.O#.#\n#..O.O..#O..............O....###..O#.O.....O.#O#O#\n#O...O.O.#.#..O......OO.OO#..O...O.O....O#.O...OO#\n#..OO.O#.....O##.O##....O..#..#..#O..O.....#....O#\n#....#..O..O....O.OO...O.......OO.OO...O.O.....O.#\n#....O.O.#O.#OO.......O......O........OOO..O.....#\n#..#...##.O......##.....O..O.O#.O...O....O..#.O..#\n#...O.O..O....O..O.OOOOOO...#.O...OO.#.....OO.O..#\n#O.......O....#.OO.OO...OO...##O......O.O........#\n##.O.OO.OO...O..O#......O.O....#.............O.#.#\n#O#O...O..O..OO.O.O...OO..O.O..OOOO..O..O...O..O.#\n#..OO.O#O..O..#.O..O.#...#..O.....OO..OOO..O...O.#\n#.O.O..OO.....O...O.....O..#..O..#.O.#.OOO...O.O.#\n#.O..O.......O...OO#.#..O....O...O....O..........#\n#....O..O.OO...OO..#....#O.OO.OO##.....O.........#\n#..O..O....O...O....OO#.#O..O.#.#O.O..O...#....O.#\n#.O.....O.#.O#.O..O.OO.O#............O..........O#\n#..O#O.O.........O.#.O#O..#O.O.........O....O..O.#\n#..O.....#OO..O..#.#.#....O.O.OO.O.O......O#.#O..#\n#.O.O..O.O.O.O...O..O..OO..................#OO...#\n#..O....O....O.....OOO...OO..OO.......O....OO....#\n#.O....OO.O................OO....O.O#O.O.........#\n##################################################",

     

       126
       126
       +
        ">v>>>^>>v>vv^v^^v^^^<v^vv^vv<<>^v^^^<<<vv<>vv^^>v>v^^><>^<v<v><>>^>^<^^v>v<>^^v<><<^><v>v^v<<^>^>^>^>>vvv>^<<^^^^^><vv>>^>^^>^vv>><v^^v^<<<>^^<<<^^^vv^<^<<<>v<^v<v>^<>v<^>>^v^<>><><<^<>v>^>^>v>>v>vv^><v<v^v>vv>><^^<<>>vv<<^vv>^^vv>>><^v^>>v<<<<v>^<><>^>v^vv>v>><><^vvv>^><<>^<<<vvv^>^vv<<>v^^^>v<>^^vv>vv^<>^<>vvv<vvvv^^^<^vv^<v^<<vv^v<><vvvv^>vv<>><><<v>><^>v<>v<v<v>^v>^<>^v>>><^>>v<<<v^>^v>v>^^>^v<v^v^^<vv^v^><<^^<v^v>>^v>>>>>v<v^>^>^v^>vv^v^><^<v>^^<>^v^>><>>><vv<<>^v<^vvv<v^vvv^>v<<v>>^>><<^v^^v>^^>^<<<>v^^>><<v>^<v^<^>v>>>^^^<<vvv^>vvv>^><v>^>vvv^^^v^^>v^><v>><>^<v<<vv^^>>^^v>><vv>vvv>^>>>vv^><^<v<<<^^v>v^<v^^>^^<<<>v^vv<vvv>^v>v<^^>vv>v<>>vv<><v>v<^^<<^>>v<v^<>^<<v>><<vv^<<<<v^^^v^^<^<^<>v><^<>>v>v>v>v>v><v>>v<<^>>><v^v<v>>v^><^v^>>>^>^<<>>^^v><^<v^vv^<><>>v^^>v<vvv>v<>><<<<<>><<><v<>vv><^^^><vv<v<<>v^>v>>^^v^v^>vvv<v^<>><<<^>vvv><^^v>v<>v><^<v>v<^<<^<>v>>>>^<>^^^>v<v<<vv><v>>>^<^>v^><vv>^<<v<>><<^<>>>^v>><<>v^^v<^>v^v^>vvvv>vv<<>^^^<v>^<<v>>><<>>>vv^<^><><^^^>^v^<><>^<vv<^vv^^v>^<\n<^>vv>v>^^>^vvvv<<^><^<>>^<v>v>>^^<v><^<>><<<>^vv<>v<v^>>>^<<^<><<>^^vv^^<<><<vvv>v^^>vv^<v<<>>v><^>v^>>^^v<<<<^v<v<<>>v><v^>vv^<vv^>^v>^^>>><>v<><^v><vvvv^v<<>>^^v><>>vv^>v>v^>^>v<><^v>v^^<<>^v^>^>v<><^v<^^vv<>^^^v^>>><<><<<<v^v^><v<v<^^^><><^<<^^^vv<^^<^<v>v<<v^>>v<>>^<vv<^<v><>^<^v^>^v>>>^v>>v^>^^v^>><<v>>^<v>^vvv<v<<<v>^<>vv<^<v<>^<>v^v^>vv^v>><^>><>^^^<<v<vv^<vv>>v<^^^>vv<^^>vv^^^^<<^<v^>v<v>vvv<v<<^^><v<<^>^^<>v>>v><^v^<v>vv^<v<<v>v>vvv^>v<vv>>>>>^^v<<>^><>v^^^>^^>^>^^vvvv^v<v>>^^^v>>^<v<^^v>>><<>^^><<<^>v^^^v><v<v<v^v^><>^>v<v<^^^>>>vv><<^>><v>><<v<<vv><^^^<<^<>v>^v^v><<<<<<>>vv^<<<><<><><<^<^>^<v<^v>>>^>v^>^v>^v^<^>^v>><<<v>v^^vvv><<^>v^^<><v^>><<v><^^>>v<<<<<^>>><><vv>v<<>>^v<><<^>>v<<<^<^>>^>v^>^v<v>^v>>v<^>><<>><>vvv<<>vv^>v>><><<^><vvv>v><^>^<^v><>>v><v><^v^vv><>^^>>>v<^v^<^v>^v><vv<<v<<v><>>><v<vv<>>v^^>>>vv><v<<<<><v^^>>v>^<v^^>^v<<<><v>v>>^^<vv<v^v>><^<^^<>><v>^<^^<><^^^><>^<v^^^<v<^>>^v>vv^^<^v>><<vv><<v>><v>>>^>>><<<v<<><^vvv^<v>^>vvv^v>>v><<>v><<v<vvvvv^>^>><v^>vv^>>^\nvvv^v^><<v<>><><><<<^v>^v^><>^vvv<<^<<v^v<>>v<v^^>>^>v<v>^v<v^v>^<<vvv<^^v<<<<>v^v<<<v<^>><v^vv^vvvv^v><><v<<^>v>v^v^<v<v<^<><^>^vv<^^v<^^>vv<<>^^<>><<<<^^>>>^<^^>vv<>>>^^^^vv^>^v^v^^>^<<<>v^<v>^^^>v<^^<<^<v><^vvv>v>v>v<^>><^<^<>>>^^<<<vv^>>><>>v><>^<>^^<v^><<vv>vv^v<<>^>v><vvv>v^>>v^^^v<<>>^v><^<>^>^<^>^^<vv<>>><v^v^>>>^^>>^v^^^>>^v>v><^^^v<>>vv>>v^^<><^^v>v<^>>v<v^v^v^v^vv^vvv>v^vv>^v>vv<vv<^<<<v^v><<v>v<<^>vvv^^^^>>^>v>^^<>vv<>^^v><v<<^v><><><^<vv^>v^^>>>^^vv>^v>^<>vvv^v<^vv^<<^<^^<>>^<<><vv^>^>^^v^<v><v^>><^^>><<><<<<<<^>^><^v>^v>><v><v<>vvv>^^<^<<>v>>vv<v<><^<<^<>v<v>><><>^v><v<^^^<>>vvv>^^>>>v><v><^^>><<^<v><<^<v<<vv>>^vv<>v>^><><<<<<v>>>v^^v>^<>^<>v^^>>^<>>v^>^<>>>><>><v^v>>v>^<<^v^><<>>^v>><>><>>>><>vv<<>>^>v^v^<vvvvvvv^>v<<<^^<>vvvv^<<><<v^<<vv^^^v^^<<><v>v^^<^^v^^<>^v<>vvv>>^^v^^^<v>v^^vv<^^^<<>^v^>>^^<<^^v^^v<<vv^<<>>>v<>vv<v^v<<>vvv>^<v>v>^v<^^v<>^>^<><<v>v<>v^>v^v>><<><v><>>>>v^<^<^><>^v^<^><<v<^v><>>^v^^^v^><>^v>v<<^v>>^<<v<>v<^<<<<>>^><<<vv<^v^<^>^^><^^vvv^><v<><^^<>^v^>\nvvvv^vv^>>^v^v<^<vvv<>v>v>vv>^>^><^vv><v^v>v<><>v^v^>vvvv<<>v<^^^vv<^v><>^>^>v<>^>^vvv<>^>^<^^v^<><<>^>^v><v>^v>v^<v^<>>^^>^>v^>v>>^^<v><^<^vv>^vv^v^>v><^vv>^>v>^><>v>v^^>>v>^<<v^<vvv>>v<v>v^^<>^v^vv^<^^<v>>>v>>^v>vvv^^v^>v<vvv^<><v>v>v<>^^v^^<vv<>v<vvv>>><><<>>v>^^<^^^^><v>^>v<^<^>v^^>v>^>>^><<<^vv>vv^v^><v^<v>vv>^<>^vvvv^>vv>^>v^>v<<v^^<v^<v>>vvv<<v<>>>v^>^vv>^<v<>>^^v<vv<^>v<>^<<^^><>^^v>^v>>^<v>vv^v<<^^>^<v<><v>vv<><vv<>>v<^^^><<^^>^v<>vv<v>><<<v><<>>vv^>>^vvvv^><<v<vv^v<vv<>v<><v<<><v>vvv>>vv^^^<><^v<><v<^<v<v<^>>vv<><<>^^>><<v><^>vvv^>^vvv<>v^^<<^<vv>>v>^>v>^^><<>v<v^>^<<<<vv<<^^^>^>^>v<>>vv^><v<><<><^><><^^vv>>^<^vv<^^v<><<><>vvvv^^^<>v>>v^<vvv<v<vv><<v^v<v>>^v^<<^>>vvvv^v<<^<^vv<v<v>^v<^<^^>vv<v^^^>>^<^><^^v<v^v^>^^^v^v>^>^><^>>^v<v<^^^v^>>^v>vv>^v<>^v^^^v^v^>v>><^^<^v<<v<^v<>v^<>^<>^v<v^^v<^>v<v>^v<<><<<>^v><<<^>vvvvv^v^^^<<v>>v^>>^^<<v^^>vv^^vvvv>^>v^<<<^<>v><<^>^v^<^>><<<v<vv>vv<<^>^<^^><>>^^v>vvv^<^>^^^^<^v<<>^<>^>>v>^<><><>>^^vv^<<>><^<v><>^v^vvv<<>>^<>^>v<<^><<^>^<^>^<<><\n<<^<^>><<<vv>v<v<^<>>>v^>vv><>>vvvv<<^><<<>v<>v^v^<>v>v<^^<<v<vv^<<<vv>^<>^^vv<><v<<^v^v<^<v" <> ...]

     

       127
       127
       +
       ```

     

       128
       128
       +
       

     

       129
       129
       +
       ```elixir

     

       130
       130
       +
       %{robot: [robot], wall: walls, box: boxes} =

     

       131
       131
       +
         map

     

       132
       132
       +
         |> String.split("\n", trim: true)

     

       133
       133
       +
         |> Enum.with_index()

     

       134
       134
       +
         |> Enum.flat_map(fn {row, y} ->

     

       135
       135
       +
           row

     

       136
       136
       +
           |> String.to_charlist()

     

       137
       137
       +
           |> Enum.with_index()

     

       138
       138
       +
           |> Enum.reject(fn {kind, _} -> kind == ?. end)

     

       139
       139
       +
           |> Enum.map(fn {kind, x} ->

     

       140
       140
       +
             kind =

     

       141
       141
       +
               case kind do

     

       142
       142
       +
                 ?# -> :wall

     

       143
       143
       +
                 ?O -> :box

     

       144
       144
       +
                 ?@ -> :robot

     

       145
       145
       +
               end

     

       146
       146
       +
       

     

       147
       147
       +
             {{x, y}, kind}

     

       148
       148
       +
           end)

     

       149
       149
       +
         end)

     

       150
       150
       +
         |> Enum.group_by(&elem(&1, 1), &elem(&1, 0))

     

       151
       151
       +
       

     

       152
       152
       +
       walls = MapSet.new(walls)

     

       153
       153
       +
       boxes = MapSet.new(boxes)

     

       154
       154
       +
       ```

     

       155
       155
       +
       

     

       156
       156
       +
       <!-- livebook:{"output":true} -->

     

       157
       157
       +
       

     

       158
       158
       +
       ```

     

       159
       159
       +
       MapSet.new([

     

       160
       160
       +
         {38, 2},

     

       161
       161
       +
         {29, 26},

     

       162
       162
       +
         {9, 34},

     

       163
       163
       +
         {47, 38},

     

       164
       164
       +
         {47, 44},

     

       165
       165
       +
         {22, 37},

     

       166
       166
       +
         {19, 38},

     

       167
       167
       +
         {27, 21},

     

       168
       168
       +
         {19, 22},

     

       169
       169
       +
         {16, 10},

     

       170
       170
       +
         {16, 38},

     

       171
       171
       +
         {35, 26},

     

       172
       172
       +
         {10, 32},

     

       173
       173
       +
         {36, 14},

     

       174
       174
       +
         {28, 48},

     

       175
       175
       +
         {17, 30},

     

       176
       176
       +
         {32, 18},

     

       177
       177
       +
         {40, 35},

     

       178
       178
       +
         {6, 23},

     

       179
       179
       +
         {28, 37},

     

       180
       180
       +
         {29, 47},

     

       181
       181
       +
         {29, 40},

     

       182
       182
       +
         {29, 10},

     

       183
       183
       +
         {6, 42},

     

       184
       184
       +
         {23, 46},

     

       185
       185
       +
         {10, 33},

     

       186
       186
       +
         {4, 46},

     

       187
       187
       +
         {43, 47},

     

       188
       188
       +
         {12, 8},

     

       189
       189
       +
         {3, 16},

     

       190
       190
       +
         {15, 3},

     

       191
       191
       +
         {20, 46},

     

       192
       192
       +
         {33, 48},

     

       193
       193
       +
         {35, 6},

     

       194
       194
       +
         {41, 9},

     

       195
       195
       +
         {25, 29},

     

       196
       196
       +
         {1, 2},

     

       197
       197
       +
         {3, 30},

     

       198
       198
       +
         {8, 5},

     

       199
       199
       +
         {18, 37},

     

       200
       200
       +
         {37, 43},

     

       201
       201
       +
         {3, 47},

     

       202
       202
       +
         {30, 26},

     

       203
       203
       +
         {41, 31},

     

       204
       204
       +
         {4, 15},

     

       205
       205
       +
         {33, 40},

     

       206
       206
       +
         {6, 21},

     

       207
       207
       +
         {5, 26},

     

       208
       208
       +
         {1, ...},

     

       209
       209
       +
         {...},

     

       210
       210
       +
         ...

     

       211
       211
       +
       ])

     

       212
       212
       +
       ```

     

       213
       213
       +
       

     

       214
       214
       +
       ```elixir

     

       215
       215
       +
       moves = moves |> String.to_charlist() |> Enum.reject(& &1 not in ~c"^>v<")

     

       216
       216
       +
       ```

     

       217
       217
       +
       

     

       218
       218
       +
       <!-- livebook:{"output":true} -->

     

       219
       219
       +
       

     

       220
       220
       +
       ```

     

       221
       221
       +
       ~c">v>>>^>>v>vv^v^^v^^^<v^vv^vv<<>^v^^^<<<vv<>vv^^>v>v^^><>^<v<v><>>^>^<^^v>v<>^^v<><<^><v>v^v<<^>^>^>^>>vvv>^<<^^^^^><vv>>^>^^>^vv>><v^^v^<<<>^^<<<^^^vv^<^<<<>v<^v<v>^<>v<^>>^v^<>><><<^<>v>^>^>v>>v>vv^><v<v^v>vv>><^^<<>>vv<<^vv>^^vv>>><^v^>>v<<<<v>^<><>^>v^vv>v>><><^vvv>^><<>^<<<vvv^>^vv<<>v^^^>v<>^^vv>vv^<>^<>vvv<vvvv^^^<^vv^<v^<<vv^v<><vvvv^>vv<>><><<v>><^>v<>v<v<v>^v>^<>^v>>><^>>v<<<v^>^v>v>^^>^v<v^v^^<vv^v^><<^^<v^v>>^v>>>>>v<v^>^>^v^>vv^v^><^<v>^^<>^v^>><>>><vv<<>^v<^vvv<v^vvv^>v<<v>>^>><<^v^^v>^^>^<<<>v^^>><<v>^<v^<^>v>>>^^^<<vvv^>vvv>^><v>^>vvv^^^v^^>v^><v>><>^<v<<vv^^>>^^v>><vv>vvv>^>>>vv^><^<v<<<^^v>v^<v^^>^^<<<>v^vv<vvv>^v>v<^^>vv>v<>>vv<><v>v<^^<<^>>v<v^<>^<<v>><<vv^<<<<v^^^v^^<^<^<>v><^<>>v>v>v>v>v><v>>v<<^>>><v^v<v>>v^><^v^>>>^>^<<>>^^v><^<v^vv^<><>>v^^>v<vvv>v<>><<<<<>><<><v<>vv><^^^><vv<v<<>v^>v>>^^v^v^>vvv<v^<>><<<^>vvv><^^v>v<>v><^<v>v<^<<^<>v>>>>^<>^^^>v<v<<vv><v>>>^<^>v^><vv>^<<v<>><<^<>>>^v>><<>v^^v<^>v^v^>vvvv>vv<<>^^^<v>^<<v>>><<>>>vv^<^><><^^^>^v^<><>^<vv<^vv^^v>^<<^>vv>v>^^>^vvvv<<^><^<>>^<v>v>>^^<v><^<>><<<>^vv<>v<v^>>>^<<^<><<>^^vv^^<<><<vvv>v^^>vv^<v<<>>v><^>v^>>^^v<<<<^v<v<<>>v><v^>vv^<vv^>^v>^^>>><>v<><^v><vvvv^v<<>>^^v><>>vv^>v>v^>^>v<><^v>v^^<<>^v^>^>v<><^v<^^vv<>^^^v^>>><<><<<<v^v^><v<v<^^^><><^<<^^^vv<^^<^<v>v<<v^>>v<>>^<vv<^<v><>^<^v^>^v>>>^v>>v^>^^v^>><<v>>^<v>^vvv<v<<<v>^<>vv<^<v<>^<>v^v^>vv^v>><^>><>^^^<<v<vv^<vv>>v<^^^>vv<^^>vv^^^^<<^<v^>v<v>vvv<v<<^^><v<<^>^^<>v>>v><^v^<v>vv^<v<<v>v>vvv^>v<vv>>>>>^^v<<>^><>v^^^>^^>^>^^vvvv^v<v>>^^^v>>^<v<^^v>>><<>^^><<<^>v^^^v><v<v<v^v^><>^>v<v<^^^>>>vv><<^>><v>><<v<<vv><^^^<<^<>v>^v^v><<<<<<>>vv^<<<><<><><<^<^>^<v<^v>>>^>v^>^v>^v^<^>^v>><<<v>v^^vvv><<^>v^^<><v^>><<v><^^>>v<<<<<^>>><><vv>v<<>>^v<><<^>>v<<<^<^>>^>v^>^v<v>^v>>v<^>><<>><>vvv<<>vv^>v>><><<^><vvv>v><^>^<^v><>>v><v><^v^vv><>^^>>>v<^v^<^v>^v><vv<<v<<v><>>><v<vv<>>v^^>>>vv><v<<<<><v^^>>v>^<v^^>^v<<<><v>v>>^^<vv<v^v>><^<^^<>><v>^<^^<><^^^><>^<v^^^<v<^>>^v>vv^^<^v>><<vv><<v>><v>>>^>>><<<v<<><^vvv^<v>^>vvv^v>>v><<>v><<v<vvvvv^>^>><v^>vv^>>^vvv^v^><<v<>><><><<<^v>^v^><>^vvv<<^<<v^v<>>v<v^^>>^>v<v>^v<v^v>^<<vvv<^^v<<<<>v^v<<<v<^>><v^vv^vvvv^v><><v<<^>v>v^v^<v<v<^<><^>^vv<^^v<^^>vv<<>^^<>><<<<^^>>>^<^^>vv<>>>^^^^vv^>^v^v^^>^<<<>v^<v>^^^>v<^^<<^<v><^vvv>v>v>v<^>><^<^<>>>^^<<<vv^>>><>>v><>^<>^^<v^><<vv>vv^v<<>^>v><vvv>v^>>v^^^v<<>>^v><^<>^>^<^>^^<vv<>>><v^v^>>>^^>>^v^^^>>^v>v><^^^v<>>vv>>v^^<><^^v>v<^>>v<v^v^v^v^vv^vvv>v^vv>^v>vv<vv<^<<<v^v><<v>v<<^>vvv^^^^>>^>v>^^<>vv<>^^v><v<<^v><><><^<vv^>v^^>>>^^vv>^v>^<>vvv^v<^vv^<<^<^^<>>^<<><vv^>^>^^v^<v><v^>><^^>><<><<<<<<^>^><^v>^v>><v><v<>vvv>^^<^<<>v>>vv<v<><^<<^<>v<v>><><>^v><v<^^^<>>vvv>^^>>>v><v><^^>><<^<v><<^<v<<vv>>^vv<>v>^><><<<<<v>>>v^^v>^<>^<>v^^>>^<>>v^>^<>>>><>><v^v>>v>^<<^v^><<>>^v>><>><>>>><>vv<<>>^>v^v^<vvvvvvv^>v<<<^^<>vvvv^<<><<v^<<vv^^^v^^<<><v>v^^<^^v^^<>^v<>vvv>>^^v^^^<v>v^^vv<^^^<<>^v^>>^^<<^^v^^v<<vv^<<>>>v<>vv<v^v<<>vvv>^<v>v>^v<^^v<>^>^<><<v>v<>v^>v^v>><<><v><>>>>v^<^<^><>^v^<^><<v<^v><>>^v^^^v^><>^v>v<<^v>>^<<v<>v<^<<<<>>^><<<vv<^v^<^>^^><^^vvv^><v<><^^<>^v^>vvvv^vv^>>^v^v<^<vvv<>v>v>vv>^>^><^vv><v^v>v<><>v^v^>vvvv<<>v<^^^vv<^v><>^>^>v<>^>^vvv<>^>^<^^v^<><<>^>^v><v>^v>v^<v^<>>^^>^>v^>v>>^^<v><^<^vv>^vv^v^>v><^vv>^>v>^><>v>v^^>>v>^<<v^<vvv>>v<v>v^^<>^v^vv^<^^<v>>>v>>^v>vvv^^v^>v<vvv^<><v>v>v<>^^v^^<vv<>v<vvv>>><><<>>v>^^<^^^^><v>^>v<^<^>v^^>v>^>>^><<<^vv>vv^v^><v^<v>vv>^<>^vvvv^>vv>^>v^>v<<v^^<v^<v>>vvv<<v<>>>v^>^vv>^<v<>>^^v<vv<^>v<>^<<^^><>^^v>^v>>^<v>vv^v<<^^>^<v<><v>vv<><vv<>>v<^^^><<^^>^v<>vv<v>><<<v><<>>vv^>>^vvvv^><<v<vv^v<vv<>v<><v<<><v>vvv>>vv^^^<><^v<><v<^<v<v<^>>vv<><<>^^>><<v><^>vvv^>^vvv<>v^^<<^<vv>>v>^>v>^^><<>v<v^>^<<<<vv<<^^^>^>^>v<>>vv^><v<><<><^><><^^vv>>^<^vv<^^v<><<><>vvvv^^^<>v>>v^<vvv<v<vv><<v^v<v>>^v^<<^>>vvvv^v<<^<^vv<v<v>^v<^<^^>vv<v^^^>>^<^><^^v<v^v^>^^^v^v>^>^><^>>^v<v<^^^v^>>^v>vv>^v<>^v^^^v^v^>v>><^^<^v<<v<^v<>v^<>^<>^v<v^^v<^>v<v>^v<<><<<>^v><<<^>vvvvv^v^^^<<v>>v^>>^^<<v^^>vv^^vvvv>^>v^<<<^<>v><<^>^v^<^>><<<v<vv>vv<<^>^<^^><>>^^v>vvv^<^>^^^^<^v<<>^<>^>>v>^<><><>>^^vv^<<>><^<v><>^v^vvv<<>>^<>^>v<<^><<^>^<^>^<<><<<^<^>><<<vv>v<v<^<>>>v^>vv><>>vvvv<<^><<<>v<>v^v^<>v>v<^^<<v<vv^<<<vv>^<>^^vv<><v<<^v^v<^<v>>vv" ++ ...

     

       222
       222
       +
       ```

     

       223
       223
       +
       

     

       224
       224
       +
       ## Part 1

     

       225
       225
       +
       

     

       226
       226
       +
       ```elixir

     

       227
       227
       +
       defmodule Warehouse.A do

     

       228
       228
       +
         def walk(start, path, walls, boxes) do

     

       229
       229
       +
           Enum.reduce(path, {start, boxes}, fn dir, {pos, boxes} ->

     

       230
       230
       +
             move(pos, walls, boxes, dir)

     

       231
       231
       +
           end)

     

       232
       232
       +
           |> elem(1)

     

       233
       233
       +
         end

     

       234
       234
       +
         

     

       235
       235
       +
         def move({x, y}, walls, boxes, dir) do

     

       236
       236
       +
           next = next({x, y}, dir)

     

       237
       237
       +
       

     

       238
       238
       +
           cond do

     

       239
       239
       +
             next in walls ->

     

       240
       240
       +
               {{x, y}, boxes}

     

       241
       241
       +
       

     

       242
       242
       +
             next in boxes ->

     

       243
       243
       +
               if new_boxes = move_box(next, boxes, walls, dir) do

     

       244
       244
       +
                 {next, new_boxes}

     

       245
       245
       +
               else

     

       246
       246
       +
                 {{x, y}, boxes}

     

       247
       247
       +
               end

     

       248
       248
       +
       

     

       249
       249
       +
             true ->

     

       250
       250
       +
               {next, boxes}

     

       251
       251
       +
           end

     

       252
       252
       +
         end

     

       253
       253
       +
       

     

       254
       254
       +
         defp move_box(pos, boxes, walls, dir) do

     

       255
       255
       +
           next = next(pos, dir)

     

       256
       256
       +
           cond do

     

       257
       257
       +
             next in walls -> nil

     

       258
       258
       +
               

     

       259
       259
       +
             next in boxes ->

     

       260
       260
       +
               if new_boxes = move_box(next, boxes, walls, dir) do

     

       261
       261
       +
                 new_boxes |> MapSet.delete(pos) |> MapSet.put(next)

     

       262
       262
       +
               end

     

       263
       263
       +
       

     

       264
       264
       +
             true ->

     

       265
       265
       +
               boxes |> MapSet.delete(pos) |> MapSet.put(next)

     

       266
       266
       +
           end

     

       267
       267
       +
         end

     

       268
       268
       +
       

     

       269
       269
       +
         defp next({x, y}, ?^), do: {x, y - 1}

     

       270
       270
       +
         defp next({x, y}, ?>), do: {x + 1, y}

     

       271
       271
       +
         defp next({x, y}, ?v), do: {x, y + 1}

     

       272
       272
       +
         defp next({x, y}, ?<), do: {x - 1, y}

     

       273
       273
       +
       end

     

       274
       274
       +
       ```

     

       275
       275
       +
       

     

       276
       276
       +
       <!-- livebook:{"output":true} -->

     

       277
       277
       +
       

     

       278
       278
       +
       ```

     

       279
       279
       +
       {:module, Warehouse.A, <<70, 79, 82, 49, 0, 0, 14, ...>>, {:next, 2}}

     

       280
       280
       +
       ```

     

       281
       281
       +
       

     

       282
       282
       +
       ```elixir

     

       283
       283
       +
       robot

     

       284
       284
       +
       |> Warehouse.A.walk(moves, walls, boxes)

     

       285
       285
       +
       |> Enum.map(fn {x, y} -> x + y * 100 end)

     

       286
       286
       +
       |> Enum.sum()

     

       287
       287
       +
       ```

     

       288
       288
       +
       

     

       289
       289
       +
       <!-- livebook:{"output":true} -->

     

       290
       290
       +
       

     

       291
       291
       +
       ```

     

       292
       292
       +
       1406628

     

       293
       293
       +
       ```

     

       294
       294
       +
       

     

       295
       295
       +
       ## Part 2

     

       296
       296
       +
       

     

       297
       297
       +
       ```elixir

     

       298
       298
       +
       defmodule Warehouse.B do

     

       299
       299
       +
         def resize({x, y}, walls, boxes) do

     

       300
       300
       +
           start = {2 * x, y}

     

       301
       301
       +
       

     

       302
       302
       +
           walls =

     

       303
       303
       +
             walls

     

       304
       304
       +
             |> Enum.flat_map(fn {x, y} ->

     

       305
       305
       +
               [{2 * x, y}, {2 * x + 1, y}]

     

       306
       306
       +
             end)

     

       307
       307
       +
             |> MapSet.new()

     

       308
       308
       +
       

     

       309
       309
       +
           boxes =

     

       310
       310
       +
             boxes

     

       311
       311
       +
             |> Enum.flat_map(fn {x, y} ->

     

       312
       312
       +
               pos = [{2 * x, y}, {2 * x + 1, y}]

     

       313
       313
       +
               box = %{p: pos}

     

       314
       314
       +
       

     

       315
       315
       +
               for p <- pos do

     

       316
       316
       +
                 {p, box}

     

       317
       317
       +
               end

     

       318
       318
       +
             end)

     

       319
       319
       +
       

     

       320
       320
       +
           {start, walls, boxes}

     

       321
       321
       +
         end

     

       322
       322
       +
       

     

       323
       323
       +
         def walk(start, path, walls, boxes) do

     

       324
       324
       +
           Enum.reduce(path, {start, boxes}, fn dir, {pos, boxes} ->

     

       325
       325
       +
             move(pos, walls, boxes, dir)

     

       326
       326
       +
           end)

     

       327
       327
       +
           |> elem(1)

     

       328
       328
       +
         end

     

       329
       329
       +
       

     

       330
       330
       +
         def move({x, y}, walls, boxes, dir) do

     

       331
       331
       +
           next = next({x, y}, dir)

     

       332
       332
       +
       

     

       333
       333
       +
           cond do

     

       334
       334
       +
             next in walls ->

     

       335
       335
       +
               {{x, y}, boxes}

     

       336
       336
       +
       

     

       337
       337
       +
             box = boxes[next] ->

     

       338
       338
       +
               if new_boxes = move_box(box, boxes, walls, dir) do

     

       339
       339
       +
                 {next, new_boxes}

     

       340
       340
       +
               else

     

       341
       341
       +
                 {{x, y}, boxes}

     

       342
       342
       +
               end

     

       343
       343
       +
       

     

       344
       344
       +
             true ->

     

       345
       345
       +
               {next, boxes}

     

       346
       346
       +
           end

     

       347
       347
       +
         end

     

       348
       348
       +
       

     

       349
       349
       +
         defp move_box(%{p: pos}, boxes, walls, dir) do

     

       350
       350
       +
           next = next(pos, dir)

     

       351
       351
       +
       

     

       352
       352
       +
           cond do

     

       353
       353
       +
             Enum.any?(pos, & &1 in walls) ->

     

       354
       354
       +
               throw(:wall)

     

       355
       355
       +
       

     

       356
       356
       +
             (next_boxes = select_boxes_at(pos, boxes)) != [] ->

     

       357
       357
       +
               if new_boxes = move_box(next, boxes, walls, dir) do

     

       358
       358
       +
                 new_boxes |> MapSet.delete(pos) |> MapSet.put(next)

     

       359
       359
       +
               end

     

       360
       360
       +
       

     

       361
       361
       +
             true ->

     

       362
       362
       +
               boxes |> Map.drop(pos) |> MapSet.put(next)

     

       363
       363
       +
           end

     

       364
       364
       +
         catch

     

       365
       365
       +
           :throw, :wall -> nil

     

       366
       366
       +
         end

     

       367
       367
       +
       

     

       368
       368
       +
         defp select_boxes_at(pos, boxes) do

     

       369
       369
       +
           boxes

     

       370
       370
       +
           |> Map.take(pos)

     

       371
       371
       +
           |> Enum.uniq()

     

       372
       372
       +
         end

     

       373
       373
       +
       

     

       374
       374
       +
         defp next({x, y}, ?^), do: {x, y - 1}

     

       375
       375
       +
         defp next({x, y}, ?>), do: {x + 1, y}

     

       376
       376
       +
         defp next({x, y}, ?v), do: {x, y + 1}

     

       377
       377
       +
         defp next({x, y}, ?<), do: {x - 1, y}

     

       378
       378
       +
       end

     

       379
       379
       +
       ```

     

       380
       380
       +
       

     

       381
       381
       +
       <!-- livebook:{"output":true} -->

     

       382
       382
       +
       

     

       383
       383
       +
       ```

     

       384
       384
       +
       warning: variable "next_boxes" is unused (if the variable is not meant to be used, prefix it with an underscore)

     

       385
       385
       +
       └─ Workspace/hauleth/advent-of-code/2024/day15.livemd#cell:3ajets4kgmkyknvu:59: Warehouse.B.move_box/4

     

       386
       386
       +
       

     

       387
       387
       +
       ```

     

       388
       388
       +
       

     

       389
       389
       +
       <!-- livebook:{"output":true} -->

     

       390
       390
       +
       

     

       391
       391
       +
       ```

     

       392
       392
       +
       {:module, Warehouse.B, <<70, 79, 82, 49, 0, 0, 20, ...>>, {:next, 2}}

     

       393
       393
       +
       ```

     

       394
       394
       +
       

     

       395
       395
       +
       <!-- livebook:{"offset":23559,"stamp":{"token":"XCP.GtnzBtRKuk3dCuG1gVPqYVHJwR27FPAQixvDel9XY7YKKtIR-fLOYjYE9q5s_RDyt_V8hQtSWHWE0pTlg7ukiaTmklnlkowdbH-y0AJ21EtpRoXXQ3C48_7vRp_64BdLpHY","version":2}} -->

+303

2024/day16.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 16

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc, :image])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Setup

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIxNiIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI0In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "16", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok,

     

       22
       22
       +
        "#############################################################################################################################################\n#.....#.......#.............#.........#.......................#.......#...#...............#.....#.#.................................#.#....E#\n#.#####.###.###.#######.###.#.#.#######.#.###.#####.###.#######.#.###.###.#.#####.#####.###.#.#.#.#.#####.###.#.###.#######.###.#.#.#.#.#.#.#\n#.......#...#...#.....#.#.#.#.#.#...#...#.....#...#.#...#.......#...#.#...#...#...#.#...#...............#...#...#.#.......#.#...#.#.#...#.#.#\n#########.#.#.###.#####.#.#.#.#.#.#.#.#########.#.#.###.#.#########.#.#.#.#.###.#.#.#.###.###.#####.###.###.#.#.#.###.###.#.#.###.#.#.###.#.#\n#.......#.#.#.#...#...#.#.#.#.#...#.....#.......#.#...#.#.#...#...#.#...#.#.#...#.....#...#.#...#...#.....#.#.....#.....#.#...#...#.#.#...#.#\n#.#####.#.###.#.#.#.#.#.#.#.###########.#######.#.###.#.#.###.#.#.#.#.#####.#.###.###.#.###.###.#.###.#.###.#.#.#.#.#.#.#.#.#.#.###.###.#####\n#...#...#.......#.#.#...#.#...........................#.#.#...#.#...#.#.....#.#.....#.#...#...#.....................#.#.#...................#\n#.#.#.#######.#####.#####.###########.#######.#####.#.###.#.###.#######.#####.###.#.#.###.#.#.#.#.#######.###.#.#####.#.#.#.#.###.###.#.###.#\n#.#...#.....#.#...#...#.......#.......#.....#...#...#.....#.#...#.....#...#...#.....#...#...#.#...#.......#...#.#...#.#.#.#.#...#.#...#...#.#\n#.#.###.###.###.#.#.#.###.###.#.#.#####.###.###.#.#########.#.###.###.###.#.###.#.###.#######.#####.#######.#.#.#.#.#.###.###.#.#.#.#######.#\n#.#.....#.......#.#.#...#.#...#.#...#...#.#.#.#.#.......#...#...#...#.......................#...#.#.#.....#.#.....#.#.........#...#.#.....#.#\n#.###.###########.#####.#.#####.#.#.#.#.#.#.#.#.###.###.#.#.###.###.#########.###.#.#.#.###.#.#.#.#.#####.#.#.#.#####.#######.#####.#.###.#.#\n#...#...................#.....#.#.#.#.#.#.....#.....#.#...#.#.#...#.....#...#.....#.#.#.#.#.....#.#.....#.#...#.#.........#...........#.....#\n#.#.#.#.###.#.###############.#.#.#.#.#.#############.#####.#.###.#####.#.#.#####.#.#.#.#.#######.#####.#.###.#.#.###.###.#.#.###.###########\n#.#.#.#.#.#.#.#.....#.......#.#...#...#...............#...#...#.#...#...#.#.......#.#.#.#.......#...#...#.....#.#.#.......#.#...#.#.........#\n#.#.###.#.#.###.###.###.#.#.#.###.#.#####.###.###.###.#.#.###.#.#.###.###.###.###.#.#.#.###.###.###.#.###.#####.#.#.#.###.#.#.#.###.#######.#\n#.#.....#.#...#.#.#...#.#.#.#...#.#.#...#...#...#...#...#...#...#.....#...#...#.......#.....#.#.....#...#.......#...#.#...#...#...#.#.#.....#\n#.#######.###.#.#.###.#.#.#.#.#.#.###.#.#####.#.#.#.#########.#.#######.#.#.#.#.#############.#####.###.#########.#####.###.#####.#.#.#.#.###\n#.#.......#.#.....#...#.#.#...#.#.#...#.....#.#.#.#.........#.#.........#.#.#.#.#.................#.#.#...#.......#.........#...#...#.#.....#\n#.#.#####.#.#######.#####.#######.#.#####.#.###.#.#########.#.#.#########.#.#.#.###.#######.#.#####.#.###.#.#######.#.###.###.#.#####.###.#.#\n#.#.....#.......#...#...#...#.....#.#...........#.#.......#...#.#...#.....#.#.#...#.#.......#.#...#...#...#.....#...#...#.#.................#\n#.#####.#######.#.###.#.###.#.#####.#######.#####.#.#.###.#####.#.#.###.###.#.###.###.#####.###.#.###.#.#######.#.#####.#.#####.#.#.###.#.#.#\n#.#...#.#.....#...#...#...#.#.......#.....#.#.....#.#...#.#...#.#.#...#.#...#.#.#...#.#...#.#...#...#.#.........#.....#.#.......#...#...#.#.#\n#.#.#.#.#.###.#.###.#####.#.#.#####.#.###.###.#########.###.#.#.#.###.#.#.###.#.###.#.#.#.###.###.###.###############.#.###########.#.###.#.#\n#.#.#.#.#.#.....#...#...#...#.....#...#.#...#.#...#...#.#...#.#...#...#.#.#.#.#.........#.#...#.#.....#.......#.......#.........#...#.#.....#\n#.#.#.#.#.#######.###.#.#.#.#####.###.#.###.#.#.#.#.#.#.#.###.#####.#####.#.#.#########.#.#.###.#######.#######.###############.#.###.#.#.###\n#.#.#...#.........#...#.#.#.....#...#...#.#.....#...#...#.#.#...#...#.....#.#.....#.....#...#.....#.....#.....#...#...#...#.....#...#.#.#...#\n#.#.#########.#######.#.#.#.###.###.###.#.###########.###.#.###.#.###.#.###.#####.#.#########.#.#.###.#.#.###.#.#.#.#.#." <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       %{?# => walls, ?S => [start], ?E => [finish]} =

     

       27
       27
       +
         puzzle_input

     

       28
       28
       +
         |> String.trim()

     

       29
       29
       +
         |> String.split("\n", trim: true)

     

       30
       30
       +
         |> Enum.with_index()

     

       31
       31
       +
         |> Enum.flat_map(fn {row, y} ->

     

       32
       32
       +
           row

     

       33
       33
       +
           |> String.trim()

     

       34
       34
       +
           |> String.to_charlist()

     

       35
       35
       +
           |> Enum.with_index()

     

       36
       36
       +
           |> Enum.map(fn {char, x} ->

     

       37
       37
       +
             {{x, y}, char}

     

       38
       38
       +
           end)

     

       39
       39
       +
         end)

     

       40
       40
       +
         |> Enum.group_by(&elem(&1, 1), &elem(&1, 0))

     

       41
       41
       +
       

     

       42
       42
       +
       walls = MapSet.new(walls)

     

       43
       43
       +
       ```

     

       44
       44
       +
       

     

       45
       45
       +
       <!-- livebook:{"output":true} -->

     

       46
       46
       +
       

     

       47
       47
       +
       ```

     

       48
       48
       +
       MapSet.new([

     

       49
       49
       +
         {76, 13},

     

       50
       50
       +
         {112, 138},

     

       51
       51
       +
         {38, 2},

     

       52
       52
       +
         {124, 56},

     

       53
       53
       +
         {83, 76},

     

       54
       54
       +
         {140, 11},

     

       55
       55
       +
         {100, 134},

     

       56
       56
       +
         {75, 140},

     

       57
       57
       +
         {103, 106},

     

       58
       58
       +
         {68, 134},

     

       59
       59
       +
         {124, 60},

     

       60
       60
       +
         {35, 30},

     

       61
       61
       +
         {2, 132},

     

       62
       62
       +
         {8, 50},

     

       63
       63
       +
         {78, 98},

     

       64
       64
       +
         {101, 62},

     

       65
       65
       +
         {98, 136},

     

       66
       66
       +
         {95, 56},

     

       67
       67
       +
         {74, 12},

     

       68
       68
       +
         {102, 74},

     

       69
       69
       +
         {22, 38},

     

       70
       70
       +
         {14, 86},

     

       71
       71
       +
         {12, 135},

     

       72
       72
       +
         {86, 10},

     

       73
       73
       +
         {29, 26},

     

       74
       74
       +
         {4, 81},

     

       75
       75
       +
         {31, 42},

     

       76
       76
       +
         {9, 34},

     

       77
       77
       +
         {137, 16},

     

       78
       78
       +
         {86, 138},

     

       79
       79
       +
         {90, 0},

     

       80
       80
       +
         {14, 122},

     

       81
       81
       +
         {120, 42},

     

       82
       82
       +
         {102, 57},

     

       83
       83
       +
         {84, 102},

     

       84
       84
       +
         {138, 124},

     

       85
       85
       +
         {0, 101},

     

       86
       86
       +
         {116, 96},

     

       87
       87
       +
         {54, 138},

     

       88
       88
       +
         {18, 134},

     

       89
       89
       +
         {82, 60},

     

       90
       90
       +
         {15, 92},

     

       91
       91
       +
         {58, 58},

     

       92
       92
       +
         {78, 75},

     

       93
       93
       +
         {75, 0},

     

       94
       94
       +
         {16, 73},

     

       95
       95
       +
         {76, 2},

     

       96
       96
       +
         {58, 84},

     

       97
       97
       +
         {138, ...},

     

       98
       98
       +
         {...},

     

       99
       99
       +
         ...

     

       100
       100
       +
       ])

     

       101
       101
       +
       ```

     

       102
       102
       +
       

     

       103
       103
       +
       ```elixir

     

       104
       104
       +
       {_, {w, h}} = Enum.min_max(walls)

     

       105
       105
       +
       

     

       106
       106
       +
       w = w + 1

     

       107
       107
       +
       h = h + 1

     

       108
       108
       +
       ```

     

       109
       109
       +
       

     

       110
       110
       +
       <!-- livebook:{"output":true} -->

     

       111
       111
       +
       

     

       112
       112
       +
       ```

     

       113
       113
       +
       141

     

       114
       114
       +
       ```

     

       115
       115
       +
       

     

       116
       116
       +
       ```elixir

     

       117
       117
       +
       put_in(%{}, [Access.key(:a, %{}), :b], 10)

     

       118
       118
       +
       ```

     

       119
       119
       +
       

     

       120
       120
       +
       <!-- livebook:{"output":true} -->

     

       121
       121
       +
       

     

       122
       122
       +
       ```

     

       123
       123
       +
       %{a: %{b: 10}}

     

       124
       124
       +
       ```

     

       125
       125
       +
       

     

       126
       126
       +
       ```elixir

     

       127
       127
       +
       defmodule Race.B do

     

       128
       128
       +
         @turns ~w'^ > v <'a

     

       129
       129
       +
       

     

       130
       130
       +
         defguardp score(elements, pos, dir) when :erlang.map_get({pos, dir}, elements).score

     

       131
       131
       +
       

     

       132
       132
       +
         def search_paths(start, finish, dir \\ :>, walls) when dir in @turns do

     

       133
       133
       +
           result = do_search([{0, [{start, dir}]}], walls, %{})

     

       134
       134
       +
       

     

       135
       135
       +
           %{paths: visited, score: score} = result[{finish, :>}]

     

       136
       136
       +
       

     

       137
       137
       +
           all = get_all(visited, result)

     

       138
       138
       +
       

     

       139
       139
       +
           {score, all}

     

       140
       140
       +
         end

     

       141
       141
       +
       

     

       142
       142
       +
         def get_all(path, seen) do

     

       143
       143
       +
           Enum.reduce(path, MapSet.new(), fn p, acc ->

     

       144
       144
       +
             path = MapSet.new(seen[p].paths, fn {p, _} -> p end)

     

       145
       145
       +
             MapSet.union(acc, path)

     

       146
       146
       +
           end)

     

       147
       147
       +
         end

     

       148
       148
       +
       

     

       149
       149
       +
         def do_search([], _, visited), do: visited

     

       150
       150
       +
       

     

       151
       151
       +
         def do_search([{cost, [{curr, dir} | _] = path} | rest], walls, visited)

     

       152
       152
       +
             when cost == score(visited, curr, dir) do

     

       153
       153
       +
           visited = Map.update!(visited, {curr, dir}, &%{&1 | paths: path})

     

       154
       154
       +
       

     

       155
       155
       +
           do_search(rest, walls, visited)

     

       156
       156
       +
         end

     

       157
       157
       +
       

     

       158
       158
       +
         def do_search([{cost, [{curr, prev} | _] = path} | rest], walls, visited)

     

       159
       159
       +
             when not is_map_key(visited, {curr, prev})

     

       160
       160
       +
             when cost < score(visited, curr, prev) do

     

       161
       161
       +
           visited = Map.put(visited, {curr, prev}, %{score: cost, paths: path})

     

       162
       162
       +
       

     

       163
       163
       +
           @turns

     

       164
       164
       +
           |> Enum.map(fn dir -> {cost + cost(prev, dir), [{step(curr, dir), dir} | path]} end)

     

       165
       165
       +
           |> Enum.reject(fn {_cost, [{pos, _} | _]} -> pos in walls end)

     

       166
       166
       +
           |> sort_merge(rest)

     

       167
       167
       +
           |> do_search(walls, visited)

     

       168
       168
       +
         end

     

       169
       169
       +
       

     

       170
       170
       +
         def do_search([{_, [_curr | _]} | rest], walls, visited),

     

       171
       171
       +
           do: do_search(rest, walls, visited)

     

       172
       172
       +
       

     

       173
       173
       +
         # Going straight is cheap and turning is costly

     

       174
       174
       +
         defp cost(a, a), do: 1

     

       175
       175
       +
         defp cost(_, _), do: 1001

     

       176
       176
       +
       

     

       177
       177
       +
         defp step({x, y}, :^), do: {x, y - 1}

     

       178
       178
       +
         defp step({x, y}, :>), do: {x + 1, y}

     

       179
       179
       +
         defp step({x, y}, :v), do: {x, y + 1}

     

       180
       180
       +
         defp step({x, y}, :<), do: {x - 1, y}

     

       181
       181
       +
       

     

       182
       182
       +
         defp sort_merge([], bs), do: bs

     

       183
       183
       +
         defp sort_merge(as, []), do: as

     

       184
       184
       +
       

     

       185
       185
       +
         defp sort_merge([a | as], [b | bs]) do

     

       186
       186
       +
           if a < b do

     

       187
       187
       +
             [a | sort_merge(as, [b | bs])]

     

       188
       188
       +
           else

     

       189
       189
       +
             [b | sort_merge([a | as], bs)]

     

       190
       190
       +
           end

     

       191
       191
       +
         end

     

       192
       192
       +
       end

     

       193
       193
       +
       ```

     

       194
       194
       +
       

     

       195
       195
       +
       <!-- livebook:{"output":true} -->

     

       196
       196
       +
       

     

       197
       197
       +
       ```

     

       198
       198
       +
       {:module, Race.B, <<70, 79, 82, 49, 0, 0, 23, ...>>, {:sort_merge, 2}}

     

       199
       199
       +
       ```

     

       200
       200
       +
       

     

       201
       201
       +
       ```elixir

     

       202
       202
       +
       {score, paths} = Race.B.search_paths(start, finish, walls)

     

       203
       203
       +
       ```

     

       204
       204
       +
       

     

       205
       205
       +
       <!-- livebook:{"output":true} -->

     

       206
       206
       +
       

     

       207
       207
       +
       ```

     

       208
       208
       +
       {134588,

     

       209
       209
       +
        MapSet.new([

     

       210
       210
       +
          {77, 129},

     

       211
       211
       +
          {17, 138},

     

       212
       212
       +
          {17, 137},

     

       213
       213
       +
          {37, 139},

     

       214
       214
       +
          {19, 137},

     

       215
       215
       +
          {100, 131},

     

       216
       216
       +
          {139, 68},

     

       217
       217
       +
          {14, 139},

     

       218
       218
       +
          {79, 128},

     

       219
       219
       +
          {19, 138},

     

       220
       220
       +
          {50, 137},

     

       221
       221
       +
          {139, 67},

     

       222
       222
       +
          {137, 104},

     

       223
       223
       +
          {137, 117},

     

       224
       224
       +
          {131, 49},

     

       225
       225
       +
          {107, 125},

     

       226
       226
       +
          {3, 127},

     

       227
       227
       +
          {135, 64},

     

       228
       228
       +
          {4, 131},

     

       229
       229
       +
          {21, 134},

     

       230
       230
       +
          {63, 127},

     

       231
       231
       +
          {101, 124},

     

       232
       232
       +
          {5, 139},

     

       233
       233
       +
          {125, 14},

     

       234
       234
       +
          {129, 48},

     

       235
       235
       +
          {139, 70},

     

       236
       236
       +
          {21, 119},

     

       237
       237
       +
          {17, 129},

     

       238
       238
       +
          {137, 120},

     

       239
       239
       +
          {17, 136},

     

       240
       240
       +
          {131, 120},

     

       241
       241
       +
          {32, 139},

     

       242
       242
       +
          {133, 21},

     

       243
       243
       +
          {102, 123},

     

       244
       244
       +
          {12, 111},

     

       245
       245
       +
          {123, 19},

     

       246
       246
       +
          {112, 127},

     

       247
       247
       +
          {73, 129},

     

       248
       248
       +
          {7, 116},

     

       249
       249
       +
          {127, 22},

     

       250
       250
       +
          {7, 137},

     

       251
       251
       +
          {9, 131},

     

       252
       252
       +
          {24, 133},

     

       253
       253
       +
          {137, 95},

     

       254
       254
       +
          {8, 133},

     

       255
       255
       +
          {134, 7},

     

       256
       256
       +
          {129, ...},

     

       257
       257
       +
          {...},

     

       258
       258
       +
          ...

     

       259
       259
       +
        ])}

     

       260
       260
       +
       ```

     

       261
       261
       +
       

     

       262
       262
       +
       ## Part 1

     

       263
       263
       +
       

     

       264
       264
       +
       ```elixir

     

       265
       265
       +
       score

     

       266
       266
       +
       ```

     

       267
       267
       +
       

     

       268
       268
       +
       <!-- livebook:{"output":true} -->

     

       269
       269
       +
       

     

       270
       270
       +
       ```

     

       271
       271
       +
       134588

     

       272
       272
       +
       ```

     

       273
       273
       +
       

     

       274
       274
       +
       ```elixir

     

       275
       275
       +
       Image.new!(w, h)

     

       276
       276
       +
       |> Image.mutate(fn img ->

     

       277
       277
       +
         for {x, y} <- walls do

     

       278
       278
       +
           Image.Draw.point(img, x, y, color: [128, 0, 0])

     

       279
       279
       +
         end

     

       280
       280
       +
       

     

       281
       281
       +
         for {x, y} <- paths do

     

       282
       282
       +
           Image.Draw.point(img, x, y, color: [0, 255, 0])

     

       283
       283
       +
         end

     

       284
       284
       +
       

     

       285
       285
       +
         img

     

       286
       286
       +
       end)

     

       287
       287
       +
       |> elem(1)

     

       288
       288
       +
       |> Image.resize!(6, interpolate: :nearest)

     

       289
       289
       +
       ```

     

       290
       290
       +
       

     

       291
       291
       +
       ## Part 2

     

       292
       292
       +
       

     

       293
       293
       +
       ```elixir

     

       294
       294
       +
       MapSet.size(paths)

     

       295
       295
       +
       ```

     

       296
       296
       +
       

     

       297
       297
       +
       <!-- livebook:{"output":true} -->

     

       298
       298
       +
       

     

       299
       299
       +
       ```

     

       300
       300
       +
       625

     

       301
       301
       +
       ```

     

       302
       302
       +
       

     

       303
       303
       +
       <!-- livebook:{"offset":9337,"stamp":{"token":"XCP.AVI7h-Nq9jZKx9YmL5qYerJkeKKqddhzKrKUkab-HwNDUM8nQItD1O_rd2ROsJxc96gwIzwrMAixlIdLeZAgOVhtCs22LZM44Wl1VwcpYbg3RNCdgwIjqGheO5YrCGrEGJc","version":2}} -->

+206

2024/day17.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 17

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIxNyIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI0In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "17", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok,

     

       22
       22
       +
        "Register A: 66245665\nRegister B: 0\nRegister C: 0\n\nProgram: 2,4,1,7,7,5,1,7,4,6,0,3,5,5,3,0"}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       defmodule Computer do

     

       27
       27
       +
         @instructions ~w[adv bxl bst jnz bxc out bdv cdv]a

     

       28
       28
       +
                       |> Enum.with_index()

     

       29
       29
       +
                       |> Map.new(fn {name, ins} -> {ins, name} end)

     

       30
       30
       +
       

     

       31
       31
       +
         def load(opcodes) do

     

       32
       32
       +
           opcodes

     

       33
       33
       +
           |> Enum.chunk_every(2)

     

       34
       34
       +
           |> Enum.map(fn [opcode, op] ->

     

       35
       35
       +
             {@instructions[opcode], op}

     

       36
       36
       +
           end)

     

       37
       37
       +
           |> List.to_tuple()

     

       38
       38
       +
         end

     

       39
       39
       +
       

     

       40
       40
       +
         def process(program, reg) do

     

       41
       41
       +
           reg = Map.merge(%{a: 0, b: 0, c: 0}, Map.new(reg))

     

       42
       42
       +
           do_process(program, 0, reg, [])

     

       43
       43
       +
         end

     

       44
       44
       +
       

     

       45
       45
       +
         defp do_process(program, idx, _reg, out) when idx >= tuple_size(program) do

     

       46
       46
       +
           Enum.reverse(out)

     

       47
       47
       +
         end

     

       48
       48
       +
       

     

       49
       49
       +
         defp do_process(program, idx, reg, out) do

     

       50
       50
       +
           ins = elem(program, idx)

     

       51
       51
       +
       

     

       52
       52
       +
           case compute(ins, reg) do

     

       53
       53
       +
             new_reg when is_map(new_reg) ->

     

       54
       54
       +
               do_process(program, idx + 1, new_reg, out)

     

       55
       55
       +
       

     

       56
       56
       +
             {:out, op} ->

     

       57
       57
       +
               do_process(program, idx + 1, reg, [op | out])

     

       58
       58
       +
       

     

       59
       59
       +
             {:jump, op} ->

     

       60
       60
       +
               do_process(program, op, reg, out)

     

       61
       61
       +
           end

     

       62
       62
       +
         end

     

       63
       63
       +
       

     

       64
       64
       +
         def compute({:adv, op}, reg),

     

       65
       65
       +
           do: %{reg | a: div(reg.a, 2 ** combo(op, reg))}

     

       66
       66
       +
       

     

       67
       67
       +
         def compute({:bdv, op}, reg),

     

       68
       68
       +
           do: %{reg | b: div(reg.a, 2 ** combo(op, reg))}

     

       69
       69
       +
       

     

       70
       70
       +
         def compute({:cdv, op}, reg),

     

       71
       71
       +
           do: %{reg | c: div(reg.a, 2 ** combo(op, reg))}

     

       72
       72
       +
       

     

       73
       73
       +
         def compute({:bxl, op}, reg),

     

       74
       74
       +
           do: %{reg | b: Bitwise.bxor(reg.b, op)}

     

       75
       75
       +
       

     

       76
       76
       +
         def compute({:bxc, _op}, reg),

     

       77
       77
       +
           do: %{reg | b: Bitwise.bxor(reg.b, reg.c)}

     

       78
       78
       +
       

     

       79
       79
       +
         def compute({:bst, op}, reg),

     

       80
       80
       +
           do: %{reg | b: Bitwise.band(combo(op, reg), 0b111)}

     

       81
       81
       +
       

     

       82
       82
       +
         def compute({:out, op}, reg),

     

       83
       83
       +
           do: {:out, Bitwise.band(combo(op, reg), 0b111)}

     

       84
       84
       +
       

     

       85
       85
       +
         def compute({:jnz, op}, reg) do

     

       86
       86
       +
           if reg.a != 0 do

     

       87
       87
       +
             {:jump, op}

     

       88
       88
       +
           else

     

       89
       89
       +
             reg

     

       90
       90
       +
           end

     

       91
       91
       +
         end

     

       92
       92
       +
       

     

       93
       93
       +
         defp combo(v, _) when v in 0..3, do: v

     

       94
       94
       +
         defp combo(4, %{a: a}), do: a

     

       95
       95
       +
         defp combo(5, %{b: b}), do: b

     

       96
       96
       +
         defp combo(6, %{c: c}), do: c

     

       97
       97
       +
       end

     

       98
       98
       +
       ```

     

       99
       99
       +
       

     

       100
       100
       +
       <!-- livebook:{"output":true} -->

     

       101
       101
       +
       

     

       102
       102
       +
       ```

     

       103
       103
       +
       {:module, Computer, <<70, 79, 82, 49, 0, 0, 21, ...>>, {:combo, 2}}

     

       104
       104
       +
       ```

     

       105
       105
       +
       

     

       106
       106
       +
       ```elixir

     

       107
       107
       +
       [

     

       108
       108
       +
         "Register A: " <> a,

     

       109
       109
       +
         "Register B: " <> b,

     

       110
       110
       +
         "Register C: " <> c,

     

       111
       111
       +
         "Program: " <> raw_code

     

       112
       112
       +
       ] = String.split(puzzle_input, "\n", trim: true)

     

       113
       113
       +
       

     

       114
       114
       +
       reg = %{

     

       115
       115
       +
         a: String.to_integer(a),

     

       116
       116
       +
         b: String.to_integer(b),

     

       117
       117
       +
         c: String.to_integer(c)

     

       118
       118
       +
       } |> dbg()

     

       119
       119
       +
       

     

       120
       120
       +
       code =

     

       121
       121
       +
         raw_code

     

       122
       122
       +
         |> String.split(",")

     

       123
       123
       +
         |> Enum.map(&String.to_integer/1)

     

       124
       124
       +
       

     

       125
       125
       +
       program = Computer.load(code)

     

       126
       126
       +
       ```

     

       127
       127
       +
       

     

       128
       128
       +
       <!-- livebook:{"output":true} -->

     

       129
       129
       +
       

     

       130
       130
       +
       ```

     

       131
       131
       +
       %{a: 66245665, b: 0, c: 0}

     

       132
       132
       +
       ```

     

       133
       133
       +
       

     

       134
       134
       +
       <!-- livebook:{"output":true} -->

     

       135
       135
       +
       

     

       136
       136
       +
       ```

     

       137
       137
       +
       {{:bst, 4}, {:bxl, 7}, {:cdv, 5}, {:bxl, 7}, {:bxc, 6}, {:adv, 3}, {:out, 5}, {:jnz, 0}}

     

       138
       138
       +
       ```

     

       139
       139
       +
       

     

       140
       140
       +
       ## Part 1

     

       141
       141
       +
       

     

       142
       142
       +
       ```elixir

     

       143
       143
       +
       out = Computer.process(program, reg)

     

       144
       144
       +
       ```

     

       145
       145
       +
       

     

       146
       146
       +
       <!-- livebook:{"output":true} -->

     

       147
       147
       +
       

     

       148
       148
       +
       ```

     

       149
       149
       +
       [1, 4, 6, 1, 6, 4, 3, 0, 3]

     

       150
       150
       +
       ```

     

       151
       151
       +
       

     

       152
       152
       +
       ```elixir

     

       153
       153
       +
       IO.puts(Enum.join(out, ","))

     

       154
       154
       +
       ```

     

       155
       155
       +
       

     

       156
       156
       +
       <!-- livebook:{"output":true} -->

     

       157
       157
       +
       

     

       158
       158
       +
       ```

     

       159
       159
       +
       1,4,6,1,6,4,3,0,3

     

       160
       160
       +
       ```

     

       161
       161
       +
       

     

       162
       162
       +
       <!-- livebook:{"output":true} -->

     

       163
       163
       +
       

     

       164
       164
       +
       ```

     

       165
       165
       +
       :ok

     

       166
       166
       +
       ```

     

       167
       167
       +
       

     

       168
       168
       +
       ## Part 2

     

       169
       169
       +
       

     

       170
       170
       +
       ```elixir

     

       171
       171
       +
       defmodule Quine do

     

       172
       172
       +
         def find(program, target) do

     

       173
       173
       +
           do_find(program, Enum.reverse(target), Enum.to_list(0..7))

     

       174
       174
       +
         end

     

       175
       175
       +
       

     

       176
       176
       +
         def do_find(_program, [], out), do: out

     

       177
       177
       +
       

     

       178
       178
       +
         def do_find(program, [n | rest], out) do

     

       179
       179
       +
           potential =

     

       180
       180
       +
             for a <- out,

     

       181
       181
       +
                 i <- 0..7,

     

       182
       182
       +
                 hd(Computer.process(program, a: a * 8 + i)) == n,

     

       183
       183
       +
                 do: a * 8 + i

     

       184
       184
       +
       

     

       185
       185
       +
           do_find(program, rest, potential)

     

       186
       186
       +
         end

     

       187
       187
       +
       end

     

       188
       188
       +
       ```

     

       189
       189
       +
       

     

       190
       190
       +
       <!-- livebook:{"output":true} -->

     

       191
       191
       +
       

     

       192
       192
       +
       ```

     

       193
       193
       +
       {:module, Quine, <<70, 79, 82, 49, 0, 0, 10, ...>>, {:do_find, 3}}

     

       194
       194
       +
       ```

     

       195
       195
       +
       

     

       196
       196
       +
       ```elixir

     

       197
       197
       +
       Quine.find(program, code) |> Enum.min()

     

       198
       198
       +
       ```

     

       199
       199
       +
       

     

       200
       200
       +
       <!-- livebook:{"output":true} -->

     

       201
       201
       +
       

     

       202
       202
       +
       ```

     

       203
       203
       +
       265061364597659

     

       204
       204
       +
       ```

     

       205
       205
       +
       

     

       206
       206
       +
       <!-- livebook:{"offset":4021,"stamp":{"token":"XCP.PwUWTErrjClVJj6ZS87ZLrfbzleELwxqD__HBvfB1y_Yc633Wj72_Jigo2Z3T7V2ONi1nVguQ_AE_NSyLCF5sjSmWldUKuW294o_wsQqiM_gKhXOjSLzJOnslN9iIEFIEww","version":2}} -->

+194

2024/day18.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 18

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc, :image])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIxOCIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI0In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "18", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok,

     

       22
       22
       +
        "21,9\n69,53\n31,24\n2,9\n50,53\n2,5\n3,44\n69,49\n25,26\n50,31\n68,41\n54,67\n19,8\n11,9\n9,29\n1,31\n13,12\n28,5\n69,41\n51,66\n53,43\n65,35\n40,67\n43,13\n21,34\n49,3\n65,61\n25,9\n39,21\n59,37\n11,24\n9,30\n63,62\n41,69\n6,29\n68,47\n45,1\n9,1\n11,14\n59,19\n67,54\n12,5\n41,44\n59,45\n3,28\n57,42\n7,25\n43,11\n31,19\n9,6\n53,60\n29,8\n53,67\n17,1\n11,17\n31,3\n55,35\n2,21\n67,61\n37,5\n6,1\n51,24\n39,1\n31,1\n69,58\n61,19\n49,63\n40,21\n28,25\n59,59\n66,69\n30,1\n7,5\n53,49\n4,17\n39,23\n23,20\n62,67\n51,36\n55,39\n41,3\n57,30\n18,7\n6,37\n29,25\n55,48\n37,16\n65,69\n21,5\n43,48\n3,11\n3,9\n63,39\n23,23\n43,67\n47,3\n69,47\n67,53\n65,24\n67,52\n35,20\n46,45\n57,26\n15,32\n35,68\n15,16\n41,1\n63,29\n15,3\n15,18\n51,50\n60,43\n50,1\n35,12\n41,10\n58,39\n27,18\n50,69\n55,40\n2,3\n51,47\n1,11\n16,9\n23,9\n19,7\n29,12\n37,3\n1,15\n11,1\n25,11\n65,56\n37,70\n60,41\n48,69\n62,29\n53,38\n12,35\n67,42\n49,67\n31,5\n39,7\n65,43\n5,25\n23,24\n43,68\n11,11\n9,32\n62,39\n69,39\n51,46\n38,21\n67,37\n5,26\n62,19\n27,21\n48,51\n55,62\n11,33\n25,4\n13,20\n61,58\n62,55\n41,66\n11,40\n16,7\n9,17\n67,65\n1,1\n9,33\n7,35\n1,3\n11,4\n29,21\n47,47\n61,67\n41,70\n42,65\n55,47\n54,49\n36,13\n61,36\n18,23\n26,23\n45,5\n9,18\n61,27\n36,21\n59,32\n4,9\n6,35\n51,23\n1,17\n12,11\n65,67\n41,65\n37,65\n1,24\n21,8\n59,28\n17,14\n63,68\n20,19\n17,10\n63,69\n57,44\n55,56\n45,64\n25,27\n27,4\n22,23\n5,13\n19,14\n47,46\n49,4\n21,15\n63,58\n60,31\n25,28\n6,3\n61,38\n33,5\n58,37\n11,32\n21,7\n44,61\n55,45\n55,37\n35,22\n10,15\n36,5\n19,11\n59,31\n33,19\n30,5\n69,69\n69,63\n57,69\n5,33\n60,27\n29,7\n57,43\n61,61\n3,26\n13,33\n57,59\n66,39\n63,27\n33,11\n51,1\n52,67\n5,29\n35,3\n17,2\n9,31\n37,24\n61,23\n9,5\n68,35\n21,28\n2,25\n51,48\n68,49\n4,19\n43,66\n7,34\n13,15\n36,1\n42,63\n13,0\n23,7\n48,47\n56,31\n55,43\n47,45\n18,15\n56,45\n61,64\n48,45\n69,65\n40,11\n51,68\n51,51\n53,46\n3,30\n49,62\n4,13\n17,27\n38,69\n41,0\n5,23\n65,32\n9,35\n55,21\n65,55\n51,39\n67,51\n5,9\n39,5\n58,49\n21,17\n63,41\n21,18\n57,65\n53,51\n2,13\n53,0\n53,6\n27,17\n55,59\n61,42\n27,7\n25,25\n39,13\n62,53\n51,44\n2,27\n19,17\n58,65\n8,1\n30,23\n14,5\n33,3\n43,65\n18,27\n35,7\n11,35\n12,29\n57,68\n59,63\n44,19\n36,25\n68,37\n15,19\n53,39\n62,69\n35,4\n61,55\n59,43\n23,17\n69,45\n18,5\n50,59\n39,6\n69,32\n17,5\n11,8\n21,2\n39,4\n64,65\n33,2\n17,22\n33,50\n25,24\n44,51\n31,7\n11,38\n11,25\n63,59\n25,21\n42,7\n8,11\n33,9\n45,63\n62,63\n33,4\n66,59\n61,29\n5,27\n59,27\n55,20\n38,9\n8,7\n51,3\n23,1\n53,65\n69,55\n1,34\n70,49\n61,57\n22,9\n17,26\n17,12\n61,69\n49,43\n9,28\n33,26\n15,35\n13,34\n55,27\n68,45\n45,61\n59,47\n13,29\n59,33\n65,53\n10,1\n35,21\n13,27\n28,1\n23,10\n61,37\n69,57\n23,21\n5,28\n57,48\n41,21\n11,13\n20,11\n1,21\n61,66\n66,47\n63,26\n5,15\n3,20\n17,4\n43,5\n16,29\n63,44\n63,55\n55,69\n5,22\n37,11\n50,39\n59,39\n25,16\n48,1\n43,60\n13,6\n49,37\n3,32\n57,23\n46,69\n2,35\n37,1\n53,27\n31,22\n63,36\n46,43\n68,57\n45,67\n32,9\n48,65\n15,15\n8,29\n13,1\n55,41\n65,65\n13,31\n49,69\n19,6\n29,19\n32,23\n49,41\n15,24\n65,22\n15,33\n6,21\n7,9\n69,64\n63,23\n5,21\n15,1\n44,1\n11,27\n63,34\n15,13\n39,9\n63,20\n58,29\n28,21\n7,37\n39,65\n41,16\n21,6\n49,47\n47,61\n50,63\n23,15\n68,67\n64,57\n19,13\n69,61\n1,22\n27,3\n28,13\n19,31\n23,2\n3,31\n25,6\n61,47\n51,63\n59,64\n27,2\n7,33\n63,63\n65,42\n5,12\n12,15\n27,9\n15,7\n6,17\n17,17\n15,2\n59,61\n63,47\n57,33\n13,17\n47,67\n11,26\n20,3\n13,7\n17,33\n10,5\n57,32\n58,53\n7,18\n66,65\n6,5\n11,5\n41,9\n21,21\n69,43\n11,20\n41,14\n38,3\n67,69\n15,17\n45,58\n51,61\n54,23\n49,39\n59,29\n53,63\n45,69\n16,1\n55,51\n21,13\n56,47\n63,40\n63,37\n37,19\n43,3\n7,17\n27,5\n14,25\n17,3\n44,69\n31,8\n14,9\n14,7\n63,45\n4,1\n49,34\n19,44\n46,53\n38,17\n33,0\n50,55\n27,25\n63,21\n19,12\n35,10\n54,3\n65,50\n47,62\n38,65\n61,39\n33,1\n65,52\n5,5\n0,3\n63,33\n30,27\n29,27\n29,1\n48,67\n33,23\n46,5\n60,35\n39,14\n59,46\n51,49\n64,21\n69,60\n3,3\n59,58\n9,36\n9,37\n48,41\n23,5\n7,3\n61,65\n61,22\n3,15\n4,37\n43,20\n66,45\n69,66\n43,12\n54,43\n52,49\n15,23\n33,21\n36,67\n61,24\n5,7\n37,7\n60,55\n53,70\n52,1\n21,33\n53,69\n67,43\n61,34\n6,31\n55,55\n59,40\n16,17\n65,25\n24,29\n59,21\n66,63\n61,41\n17,24\n0,15\n17,19\n1,13\n23,3\n49,45\n39,2\n59,49\n31,25\n65,40\n7,7\n70,43\n57,63\n65,54\n18,1\n41,15\n25,19\n33,18\n5,24\n13,3\n64,37\n43,7\n31,9\n30,11\n56,63\n65,34\n67,39\n17,18\n65,37\n49,56\n59,25\n7,11\n65,38\n37,18\n5,3\n21,22\n47,69\n19,9\n70,39\n15,14\n40,3\n5,31\n19,21\n55,34\n67,49\n45,11\n17,23\n41,5\n33,6\n37,10\n55,2\n17,9\n57,39\n5,1\n9,10\n17,7\n60,23\n55,68\n5,11\n63,67\n59,65\n7,19\n51,56\n26,1\n30,3\n15,20\n19,15\n3,21\n59,51\n11,7\n61,26\n19,23\n22,11\n25,8\n18,17\n27,26\n17,29\n7,13\n65,33\n44,5\n22,13\n56,65\n24,19\n25,17\n55,66\n65,39\n32,19\n3,19\n9,15\n54,63\n55,23\n61,59\n21,11\n46,39\n57,40\n65,19\n65,59\n65,48\n64,47\n32,21\n1,5\n15,11\n65,23\n4,2" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       bytes =

     

       27
       27
       +
         puzzle_input

     

       28
       28
       +
         |> String.split("\n", trim: true)

     

       29
       29
       +
         |> Enum.map(fn row ->

     

       30
       30
       +
           [x, y] = String.split(row, ",")

     

       31
       31
       +
       

     

       32
       32
       +
           {String.to_integer(x), String.to_integer(y)}

     

       33
       33
       +
         end)

     

       34
       34
       +
       ```

     

       35
       35
       +
       

     

       36
       36
       +
       <!-- livebook:{"output":true} -->

     

       37
       37
       +
       

     

       38
       38
       +
       ```

     

       39
       39
       +
       [

     

       40
       40
       +
         {21, 9},

     

       41
       41
       +
         {69, 53},

     

       42
       42
       +
         {31, 24},

     

       43
       43
       +
         {2, 9},

     

       44
       44
       +
         {50, 53},

     

       45
       45
       +
         {2, 5},

     

       46
       46
       +
         {3, 44},

     

       47
       47
       +
         {69, 49},

     

       48
       48
       +
         {25, 26},

     

       49
       49
       +
         {50, 31},

     

       50
       50
       +
         {68, 41},

     

       51
       51
       +
         {54, 67},

     

       52
       52
       +
         {19, 8},

     

       53
       53
       +
         {11, 9},

     

       54
       54
       +
         {9, 29},

     

       55
       55
       +
         {1, 31},

     

       56
       56
       +
         {13, 12},

     

       57
       57
       +
         {28, 5},

     

       58
       58
       +
         {69, 41},

     

       59
       59
       +
         {51, 66},

     

       60
       60
       +
         {53, 43},

     

       61
       61
       +
         {65, 35},

     

       62
       62
       +
         {40, 67},

     

       63
       63
       +
         {43, 13},

     

       64
       64
       +
         {21, 34},

     

       65
       65
       +
         {49, 3},

     

       66
       66
       +
         {65, 61},

     

       67
       67
       +
         {25, 9},

     

       68
       68
       +
         {39, 21},

     

       69
       69
       +
         {59, 37},

     

       70
       70
       +
         {11, 24},

     

       71
       71
       +
         {9, 30},

     

       72
       72
       +
         {63, 62},

     

       73
       73
       +
         {41, 69},

     

       74
       74
       +
         {6, 29},

     

       75
       75
       +
         {68, 47},

     

       76
       76
       +
         {45, 1},

     

       77
       77
       +
         {9, 1},

     

       78
       78
       +
         {11, 14},

     

       79
       79
       +
         {59, 19},

     

       80
       80
       +
         {67, 54},

     

       81
       81
       +
         {12, 5},

     

       82
       82
       +
         {41, 44},

     

       83
       83
       +
         {59, 45},

     

       84
       84
       +
         {3, 28},

     

       85
       85
       +
         {57, 42},

     

       86
       86
       +
         {7, 25},

     

       87
       87
       +
         {43, 11},

     

       88
       88
       +
         {31, ...},

     

       89
       89
       +
         {...},

     

       90
       90
       +
         ...

     

       91
       91
       +
       ]

     

       92
       92
       +
       ```

     

       93
       93
       +
       

     

       94
       94
       +
       ```elixir

     

       95
       95
       +
       Image.new!(71, 71, color: :forestgreen)

     

       96
       96
       +
       |> Image.mutate(fn img ->

     

       97
       97
       +
         for x <- 0..70, y <- 0..70, {x, y} in Enum.take(bytes, 1024) do

     

       98
       98
       +
           Image.Draw.point(img, x, y, color: :firebrick)

     

       99
       99
       +
         end

     

       100
       100
       +
       

     

       101
       101
       +
         img

     

       102
       102
       +
       end)

     

       103
       103
       +
       |> elem(1)

     

       104
       104
       +
       |> Image.resize!(4, interpolate: :nearest)

     

       105
       105
       +
       ```

     

       106
       106
       +
       

     

       107
       107
       +
       ```elixir

     

       108
       108
       +
       defmodule Memory do

     

       109
       109
       +
         @d [{-1, 0}, {1, 0}, {0, -1}, {0, 1}]

     

       110
       110
       +
         def find_path(from, to, bytes), do: do_find([{0, from}], to, MapSet.new(bytes), %{})

     

       111
       111
       +
       

     

       112
       112
       +
         def do_find([], _, _, _), do: :none

     

       113
       113
       +
       

     

       114
       114
       +
         def do_find([{dist, to} | _], to, _, _visited), do: dist

     

       115
       115
       +
       

     

       116
       116
       +
         def do_find([{dist, {x, y} = p} | rest], {w, h} = to, bytes, visited)

     

       117
       117
       +
             when not is_map_key(visited, p)

     

       118
       118
       +
             when dist < :erlang.map_get(p, visited)

     

       119
       119
       +
         do

     

       120
       120
       +
           visited = Map.put(visited, p, dist)

     

       121
       121
       +
       

     

       122
       122
       +
           next =

     

       123
       123
       +
             for {dx, dy} <- @d,

     

       124
       124
       +
                 (x + dx) in 0..w,

     

       125
       125
       +
                 (y + dy) in 0..h,

     

       126
       126
       +
                 p = {x + dx, y + dy},

     

       127
       127
       +
                 p not in bytes,

     

       128
       128
       +
                 not is_map_key(visited, p),

     

       129
       129
       +
                 do: {dist + 1, p}

     

       130
       130
       +
       

     

       131
       131
       +
           next

     

       132
       132
       +
           |> Enum.concat(rest)

     

       133
       133
       +
           |> Enum.sort()

     

       134
       134
       +
           |> do_find(to, bytes, visited)

     

       135
       135
       +
         end

     

       136
       136
       +
       

     

       137
       137
       +
         def do_find([_ | rest], to, bytes, visited), do: do_find(rest, to, bytes, visited)

     

       138
       138
       +
       end

     

       139
       139
       +
       ```

     

       140
       140
       +
       

     

       141
       141
       +
       <!-- livebook:{"output":true} -->

     

       142
       142
       +
       

     

       143
       143
       +
       ```

     

       144
       144
       +
       {:module, Memory, <<70, 79, 82, 49, 0, 0, 13, ...>>, {:do_find, 4}}

     

       145
       145
       +
       ```

     

       146
       146
       +
       

     

       147
       147
       +
       ## Part 1

     

       148
       148
       +
       

     

       149
       149
       +
       ## Part 1

     

       150
       150
       +
       

     

       151
       151
       +
       ```elixir

     

       152
       152
       +
       Memory.find_path({0, 0}, {70, 70}, Enum.take(bytes, 1024))

     

       153
       153
       +
       ```

     

       154
       154
       +
       

     

       155
       155
       +
       <!-- livebook:{"output":true} -->

     

       156
       156
       +
       

     

       157
       157
       +
       ```

     

       158
       158
       +
       250

     

       159
       159
       +
       ```

     

       160
       160
       +
       

     

       161
       161
       +
       ## Part 2

     

       162
       162
       +
       

     

       163
       163
       +
       ```elixir

     

       164
       164
       +
       {x, y} =

     

       165
       165
       +
         bytes

     

       166
       166
       +
         |> Enum.reverse()

     

       167
       167
       +
         |> Stream.unfold(fn

     

       168
       168
       +
           [] -> nil

     

       169
       169
       +
           [_ | rest] = curr -> {curr, rest}

     

       170
       170
       +
         end)

     

       171
       171
       +
         |> Enum.find_value(fn [pos | fallen] ->

     

       172
       172
       +
           path = Memory.find_path({0, 0}, {70, 70}, fallen)

     

       173
       173
       +
       

     

       174
       174
       +
           if path != :none do

     

       175
       175
       +
             pos

     

       176
       176
       +
           end

     

       177
       177
       +
         end)

     

       178
       178
       +
       

     

       179
       179
       +
       IO.puts("#{x},#{y}")

     

       180
       180
       +
       ```

     

       181
       181
       +
       

     

       182
       182
       +
       <!-- livebook:{"output":true} -->

     

       183
       183
       +
       

     

       184
       184
       +
       ```

     

       185
       185
       +
       56,8

     

       186
       186
       +
       ```

     

       187
       187
       +
       

     

       188
       188
       +
       <!-- livebook:{"output":true} -->

     

       189
       189
       +
       

     

       190
       190
       +
       ```

     

       191
       191
       +
       :ok

     

       192
       192
       +
       ```

     

       193
       193
       +
       

     

       194
       194
       +
       <!-- livebook:{"offset":7984,"stamp":{"token":"XCP.CPT4l_BNbZGxGbR_fK_dYfzmCSPzRQfyiJPfaGWsNChhlNQI36bgn8XXEOmsc56qlDi2H-j-H4aYpxwTYXzlirEAyckZaTUuHdujjNaTLq1pQEjB3uTTMbVmMkdf1KvN3g0","version":2}} -->

+126

2024/day19.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 19

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIxOSIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI0In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "19", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok,

     

       22
       22
       +
        "rrbb, rgrb, rbbwbw, ruw, grwb, wbg, rrggu, wugbb, gwr, rrgu, wbbb, bwrgugb, rgww, brrw, gwwg, brgbb, ubbbu, rbgruw, bwub, rru, grbu, grw, bwrbr, wrwbwu, bgbr, urrb, bbb, guggb, gwuwuw, ubu, wbr, bb, ubwwrb, bruuwu, buw, wrr, gbgrr, ggw, ru, wub, uub, gbrw, uwrwrb, uwuu, wbbu, gwu, brrr, grggur, wugrbrw, rwuurgg, wrbg, wuugrgw, brr, wrgwu, rwwuur, wgug, guu, brru, bgr, buwruw, bbg, bw, brwuwbb, buwbrgrb, wrwuw, ubb, rgu, wru, ugw, rruubrr, bwur, rrb, uwg, wwbbuwu, rbw, uwrgbr, ubuw, uurwr, uggw, uuguur, guuww, bbrgw, ubuwbuu, buwgg, gru, uuu, u, wgguw, bruu, bu, gwurrw, rbgwur, gubg, ubgrubw, buwrgw, uu, rwgw, rrw, wgru, gwrb, bgguu, gwugwu, urrbg, ruwwb, wuw, wwgg, wwbbu, gggb, rgrruwrw, uugr, rwb, rggw, gbr, guuurru, wurubggw, gww, wuugb, rbbww, urwgb, wrruurr, guuurgg, bwbgbg, bubwb, ggrwwg, gugr, uwrrr, guurbu, uruw, gbguruu, grb, bwr, wrubggr, rbu, wgwgru, buuww, gub, wu, uw, rrbrb, ur, wrgbb, gbbu, wgw, ggwbgwb, wb, urwr, uggwbwu, wwwg, rbru, bwbw, brb, wbugw, r, gbb, rw, bru, wbbwbr, gwww, wgrr, rugg, bgrbrub, w, gwwb, wrwgu, wwgb, uwgbgwwb, wrrwb, ubw, rr, gbbuug, bbr, wugb, rbuww, uur, wgur, ugg, wwu, wwrww, uuwur, rwbbww, gbu, bgbuur, rrbugguw, ugrgwg, wurruu, rrrgww, ggbbgbb, bgbb, brrb, rwwr, brwwr, ubrbru, uburwwb, ggwu, rwbgrbu, bbwuwbr, urwggbwr, bbrgu, wbbuww, rbwwuwr, gu, brbb, wbwgu, ugbrrguw, urbu, gbgbbrub, gbuuuww, rww, gwwgwwg, buwu, bur, uubrw, rur, rgurr, rwbgrg, urr, wugw, wuur, wuub, wbgb, bgb, uubrbur, rrbugbu, ugru, guwr, uwu, uru, wbw, wugrwgb, ggwg, guw, ubbbg, grbuwg, gw, wgb, bbrbwgub, gr, rbruu, urwwu, gbuwbw, bug, rgrgb, uwr, wrw, urb, wgbw, rbbgr, rwww, wbubur, buubw, ruwgwbug, wwwgggub, uuwrwbww, burr, rubg, wgub, bww, urbuubb, bubugrb, rgwbbw, rb, ggu, gwg, rgw, ruwggbg, wrrwbg, gur, wwbgugb, ruu, rrgg, rwrr, uwb, bwbbwbg, rbgg, rwgwg, rrgrwg, gb, bgbg, urubwugb, ruww, grbbg, gwb, bugrr, wgwr, wuug, b, gbwgr, uugw, wwr, wuu, ggr, bbwb, ubbbwrg, wugbw, gguuw, bbw, ugr, wbbrrbu, grbub, ubuwuw, bwgw, bggw, bwu, ub, bwubw, rgru, brg, uruwr, rug, wrwwuubg, brw, wggurb, br, wgr, gug, wrww, gg, uuw, bguwbru, rrrw, uubgb, gbww, buu, rbbuw, bgru, ubbwr, bg, gbgrww, wrg, ugubw, rgrg, bwbbgw, ggubrwbg, uurgwg, gbw, ww, wr, wbgu, bbu, brrwb, wug, uurug, rgb, gwbwbgg, uuubg, ugub, bruw, rub, rgggrr, ruubrwuw, brguru, wbrbg, rrwr, bgrwbbr, ugu, grwbb, rgg, wwg, rgbuwr, wuwur, bbgub, ubg, rrg, wrur, bggbr, wgg, bbwbbru, bwwbrgu, rugrr, rgwbu, ugubwbgu, wwb, ggg, bwwu, gwuguu, rrwgwg, uuwu, rrug, bgwruw, brrgrb, rurg, bugb, grwbg, rwr, urug, rwg, bgg, gbggr, rrr, gbbrw, wgu, bwbg, bbgurggg, wuwguw, wwwuru, grg, grggbw, rubu, burw, grr, bgbbw, wgrbgg, rwrww, gwurgr, bruww, bub, wbu, rbb, uwgbb, rgr, ugb, buubb, wg, wwwgr, bgw, wbwr, wuwruu, wrgrrrw, rbr, wuwwr, wrwb, ggwgwbrw, urw, uwrubb, wuwg, wguu, ugwwuw, ggb, rrggr, wrb, urwgub, bgwwrw, rwu, wurug, gbgu, brrwbb, wwbub, uwrgw, bwb, ubr, uww, gbg, wgrugwbb, bwg, wbb, bbwwgr, www\n\nbgrwwwbuugwrruurrwgbgrbwrrruurgbuwbgbwuuruubwuubruwgubw\nugguwugrwrgwruwguuwurubggwgwbrwwwubburwrburg\nrbbbgwgbbbrrrubguwggubwburbrrwgbbuwgbwwuwrbwugurbbwuubruu\nwuuuwbwuwuwgbugwggwwuwurrgwubbugbbuuubbrwbgbubr\nubbrubwuurgbuwgguubgbrguwbguuwbwruguubwbbgguwrrgwwbubwb\nrbbwuwrrrgwrwwbwgwrruubggrrggbbgwuwbrgubgwwrbwwbggwwrwrwgb\nbgggbruguuguwwwurruwgubrwrruubgbrbwwwgrrgurb\ngubugrguurwgwwubrwguggbgbbuubbubuwurgbgugrubgrgggruugw\ngwrggrbrrrbwwrrggwrwggrwuguubgggrrwwrggubruwrrgbubg\nbgubggrrbuwwwggbwbrbguwuwwbburgururuguwuwgbguuwwwub\nuuggggggurgrgugugrwbrbrwururwurburrurggwgwbrwrwwwuuugwu\nuuubwrurwwrbbgrbrrbuwbrbwrurgrrwwwgugugrbugwu\nwbbbwrgbwrbgggwgbbwbbwrwbbbwwbbwbgbwuwubbrrggurbugwrgwbuug\nuruwrwugbbwruugrguuwrrbbguwwrrrruubrwgwrruug\nbguurwugrrgurubbuwbrgrbwggrrgrwguwgrwubgbubbw\nwwgubbbbgggrgrwwwuwwwbbbbbbrwwwguggrwurgwbguwgwubww\nwgbrwgbbgwuuwbwwuwwrruruwururwbwbguuwgbrgw\nwbrgwrrurwuubrruruwwbgwrgwrbbrwrbbbrwwbwwrgwbr\nggwgwrrwwruubruwgbwwuwrbwbgurubwugbbwurwbwrbuggubwwww\nbuurbrbwrgbgbgwgwbruwubbbgwgguruggrrwwgwgwuruwggrbbbbbugw\nbubgwugwubwwwgrurgurbubwbguurrwbubuubggbgbrbuwgrwbbgbuwr\ngggbbwgugrguguwubrbwbrgwwbubwuwwgbwrbrgbuugwrrb\nbgguuuwwbrubgrubwrwugbbwwrruwrgrrubwwuubgwrwwrgrgbgbg\nw" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       [towels | patterns] = String.split(puzzle_input, "\n", trim: true)

     

       27
       27
       +
       

     

       28
       28
       +
       towels =

     

       29
       29
       +
         towels

     

       30
       30
       +
         |> String.split(", ")

     

       31
       31
       +
       ```

     

       32
       32
       +
       

     

       33
       33
       +
       <!-- livebook:{"output":true} -->

     

       34
       34
       +
       

     

       35
       35
       +
       ```

     

       36
       36
       +
       ["rrbb", "rgrb", "rbbwbw", "ruw", "grwb", "wbg", "rrggu", "wugbb", "gwr", "rrgu", "wbbb", "bwrgugb",

     

       37
       37
       +
        "rgww", "brrw", "gwwg", "brgbb", "ubbbu", "rbgruw", "bwub", "rru", "grbu", "grw", "bwrbr",

     

       38
       38
       +
        "wrwbwu", "bgbr", "urrb", "bbb", "guggb", "gwuwuw", "ubu", "wbr", "bb", "ubwwrb", "bruuwu", "buw",

     

       39
       39
       +
        "wrr", "gbgrr", "ggw", "ru", "wub", "uub", "gbrw", "uwrwrb", "uwuu", "wbbu", "gwu", "brrr",

     

       40
       40
       +
        "grggur", "wugrbrw", "rwuurgg", ...]

     

       41
       41
       +
       ```

     

       42
       42
       +
       

     

       43
       43
       +
       ```elixir

     

       44
       44
       +
       defmodule Towels do

     

       45
       45
       +
         def count(target, towels) do

     

       46
       46
       +
           possible =

     

       47
       47
       +
             towels

     

       48
       48
       +
             |> Enum.filter(&String.contains?(target, &1))

     

       49
       49
       +
             |> Enum.sort()

     

       50
       50
       +
       

     

       51
       51
       +
           do_count([{target, 1}], possible)

     

       52
       52
       +
         end

     

       53
       53
       +
       

     

       54
       54
       +
         defp do_count([], _), do: 0

     

       55
       55
       +
         defp do_count([{"", count} | _], _), do: count

     

       56
       56
       +
       

     

       57
       57
       +
         defp do_count([{target, score} | rest], towels) do

     

       58
       58
       +
           towels

     

       59
       59
       +
           |> Enum.reduce(rest, fn h, acc ->

     

       60
       60
       +
             case target do

     

       61
       61
       +
               ^h <> rest -> insert(acc, {rest, score})

     

       62
       62
       +
               _ -> acc

     

       63
       63
       +
             end

     

       64
       64
       +
           end)

     

       65
       65
       +
           |> do_count(towels)

     

       66
       66
       +
         end

     

       67
       67
       +
       

     

       68
       68
       +
         defp insert([{longest, _} = top | t], {text, _} = new)

     

       69
       69
       +
              when byte_size(text) < byte_size(longest) do

     

       70
       70
       +
           [top | insert(t, new)]

     

       71
       71
       +
         end

     

       72
       72
       +
       

     

       73
       73
       +
         defp insert([{same, count} | t], {same, add}),

     

       74
       74
       +
           do: [{same, count + add} | t]

     

       75
       75
       +
       

     

       76
       76
       +
         defp insert(t, new), do: [new | t]

     

       77
       77
       +
       end

     

       78
       78
       +
       ```

     

       79
       79
       +
       

     

       80
       80
       +
       <!-- livebook:{"output":true} -->

     

       81
       81
       +
       

     

       82
       82
       +
       ```

     

       83
       83
       +
       {:module, Towels, <<70, 79, 82, 49, 0, 0, 12, ...>>, {:insert, 2}}

     

       84
       84
       +
       ```

     

       85
       85
       +
       

     

       86
       86
       +
       ```elixir

     

       87
       87
       +
       ways = Enum.map(patterns, &Towels.count(&1, towels))

     

       88
       88
       +
       ```

     

       89
       89
       +
       

     

       90
       90
       +
       <!-- livebook:{"output":true} -->

     

       91
       91
       +
       

     

       92
       92
       +
       ```

     

       93
       93
       +
       [6620974293119, 0, 35074418436970, 51307147748, 1695253946038, 12806406135744, 4413048272,

     

       94
       94
       +
        52744440529, 21533960420, 189633269638, 308662314336, 28930988196, 0, 0, 2335754782, 105920229640,

     

       95
       95
       +
        6464319032, 87075196587, 3720984622862, 2177845982468, 5546717284590, 8535586138, 834112091460,

     

       96
       96
       +
        6647844832, 21252082644, 5923960105816, 22344301329, 0, 0, 582455705324, 5162034941182,

     

       97
       97
       +
        368835846080, 30797645913, 0, 5315701730, 1953742172864, 910841596, 5512526952, 673582370688,

     

       98
       98
       +
        2029241325402, 13227054560, 81761616492, 0, 184404641300, 19196318323832, 773246829645,

     

       99
       99
       +
        97032877104, 0, 0, 0, ...]

     

       100
       100
       +
       ```

     

       101
       101
       +
       

     

       102
       102
       +
       ## Part 1

     

       103
       103
       +
       

     

       104
       104
       +
       ```elixir

     

       105
       105
       +
       Enum.count(ways, & &1 > 0)

     

       106
       106
       +
       ```

     

       107
       107
       +
       

     

       108
       108
       +
       <!-- livebook:{"output":true} -->

     

       109
       109
       +
       

     

       110
       110
       +
       ```

     

       111
       111
       +
       306

     

       112
       112
       +
       ```

     

       113
       113
       +
       

     

       114
       114
       +
       ## Part 2

     

       115
       115
       +
       

     

       116
       116
       +
       ```elixir

     

       117
       117
       +
       Enum.sum(ways)

     

       118
       118
       +
       ```

     

       119
       119
       +
       

     

       120
       120
       +
       <!-- livebook:{"output":true} -->

     

       121
       121
       +
       

     

       122
       122
       +
       ```

     

       123
       123
       +
       604622004681855

     

       124
       124
       +
       ```

     

       125
       125
       +
       

     

       126
       126
       +
       <!-- livebook:{"offset":7059,"stamp":{"token":"XCP.002DySFes8xjfbs_CVpc_QP75dkQcDFc5l37WdKhIJnRNctYjy9B2s3kTIev5coTlF4OCw1O-s8QuxIAU1HRaVoeZUHdw248FBapl1Ki5EyAYF1LHsn0MfuWbSukOOamT4I","version":2}} -->

+420

2024/day20.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 20

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIyMCIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI0In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "20", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok,

     

       22
       22
       +
        "#############################################################################################################################################\n#...#...#...#...#.........#.........###...#.....#...#.....#...#.......#...#...###...#...#...###.......#.........#...#...#...#...............#\n#.#.#.#.#.#.#.#.#.#######.#.#######.###.#.#.###.#.#.#.###.#.#.#.#####.#.#.#.#.###.#.#.#.#.#.###.#####.#.#######.#.#.#.#.#.#.#.#############.#\n#.#.#.#.#.#...#.#.....#...#.#.......#...#.#...#.#.#.#...#...#.#.#.....#.#.#.#.#...#...#.#.#...#...#...#.....#...#.#.#.#...#...#.........#...#\n#.#.#.#.#.#####.#####.#.###.#.#######.###.###.#.#.#.###.#####.#.#.#####.#.#.#.#.#######.#.###.###.#.#######.#.###.#.#.#########.#######.#.###\n#.#.#.#.#...#...#...#.#...#.#.#.....#...#...#.#.#.#...#.#.....#.#.###...#.#.#.#.......#.#.#...#...#.....###.#.....#...#...#...#.......#...###\n#.#.#.#.###.#.###.#.#.###.#.#.#.###.###.###.#.#.#.###.#.#.#####.#.###.###.#.#.#######.#.#.#.###.#######.###.###########.#.#.#.#######.#######\n#.#.#.#.#...#...#.#.#.#...#.#.#.#...###...#.#.#.#.#...#.#...#...#...#...#...#.....###.#.#.#...#.....#...#...#.......#...#...#...#.....#.....#\n#.#.#.#.#.#####.#.#.#.#.###.#.#.#.#######.#.#.#.#.#.###.###.#.#####.###.#########.###.#.#.###.#####.#.###.###.#####.#.#########.#.#####.###.#\n#.#.#.#.#.....#.#.#...#.#...#...#.....#...#...#.#.#...#.#...#.....#...#...#.......#...#...#...#.....#...#...#.....#.#.........#...#.....#...#\n#.#.#.#.#####.#.#.#####.#.###########.#.#######.#.###.#.#.#######.###.###.#.#######.#######.###.#######.###.#####.#.#########.#####.#####.###\n#.#...#.....#.#.#.#.....#...#.....#...#...#.....#...#.#.#...#...#...#.#...#.......#.......#...#.......#.....#.....#...........#...#.....#...#\n#.#########.#.#.#.#.#######.#.###.#.#####.#.#######.#.#.###.#.#.###.#.#.#########.#######.###.#######.#######.#################.#.#####.###.#\n#.#...#...#...#...#...#####.#...#...#####.#.###...#.#.#.#...#.#.....#...#...#.....###...#.#...#...###...#...#.#...#...#.....###.#.###...#...#\n#.#.#.#.#.###########.#####.###.#########.#.###.#.#.#.#.#.###.###########.#.#.#######.#.#.#.###.#.#####.#.#.#.#.#.#.#.#.###.###.#.###.###.###\n#...#...#...#.......#...#...#...#...###...#...#.#.#.#.#.#.###.......#.....#...#...#...#.#.#.###.#.#...#.#.#.#...#...#...#...#...#...#...#...#\n###########.#.#####.###.#.###.###.#.###.#####.#.#.#.#.#.#.#########.#.#########.#.#.###.#.#.###.#.#.#.#.#.#.#############.###.#####.###.###.#\n#...###...#...#...#...#...#...#...#.#...#...#.#.#.#.#...#...###...#.#.....#.....#.#...#...#.#...#.#.#.#.#.#...#...........#...#.....#...#...#\n#.#.###.#.#####.#.###.#####.###.###.#.###.#.#.#.#.#.#######.###.#.#.#####.#.#####.###.#####.#.###.#.#.#.#.###.#.###########.###.#####.###.###\n#.#.#...#.....#.#...#.....#...#.#...#...#.#...#.#...#.......#...#.#.#.....#.....#.###.....#.#...#.#.#.#...#...#...........#...#.....#.#...###\n#.#.#.#######.#.###.#####.###.#.#.#####.#.#####.#####.#######.###.#.#.#########.#.#######.#.###.#.#.#.#####.#############.###.#####.#.#.#####\n#.#...#.....#.#.#...#...#...#...#.#...#.#...#...#.....#.....#...#.#.#.......#...#...#...#.#.....#.#.#.#.....#.............#...#.....#.#.#...#\n#.#####.###.#.#.#.###.#.###.#####.#.#.#.###.#.###.#####.###.###.#.#.#######.#.#####.#.#.#.#######.#.#.#.#####.#############.###.#####.#.#.#.#\n#.#...#.#...#...#.....#.....#.....#.#.#.#...#...#.#...#...#.....#.#.#.....#.#.....#...#.#...#.....#.#.#.....#.#...###...###.#...#...#.#.#.#.#\n#.#.#.#.#.###################.#####.#.#.#.#####.#.#.#.###.#######.#.#.###.#.#####.#####.###.#.#####.#.#####.#.#.#.###.#.###.#.###.#.#.#.#.#.#\n#.#.#...#.................#...#...#.#.#.#.#.....#.#.#.###.......#.#.#...#...#...#...#...#...#.#.....#.#...#.#.#.#.....#.....#.....#...#...#.#\n#.#.#####################.#.###.#.#.#.#.#.#.#####.#.#.#########.#.#.###.#####.#.###.#.###.###.#.#####.#.#.#.#.#.###########################.#\n#.#.....#.................#.###.#.#.#.#.#.#...#...#.#...#...#...#.#.#...#...#.#.#...#...#...#.#...#...#.#.#.#.#.#.....#.......#.....#...#...#\n#.#####.#.#################.###.#.#.#.#.#.###.#.###.###.#.#.#.###.#.#.###.#.#.#.#.#####.###.#.###.#.###.#.#.#.#.#.###.#." <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       #puzzle_input =

     

       27
       27
       +
         """

     

       28
       28
       +
       ###############

     

       29
       29
       +
       #...#...#.....#

     

       30
       30
       +
       #.#.#.#.#.###.#

     

       31
       31
       +
       #S#...#.#.#...#

     

       32
       32
       +
       #######.#.#.###

     

       33
       33
       +
       #######.#.#...#

     

       34
       34
       +
       #######.#.###.#

     

       35
       35
       +
       ###..E#...#...#

     

       36
       36
       +
       ###.#######.###

     

       37
       37
       +
       #...###...#...#

     

       38
       38
       +
       #.#####.#.###.#

     

       39
       39
       +
       #.#...#.#.#...#

     

       40
       40
       +
       #.#.#.#.#.#.###

     

       41
       41
       +
       #...#...#...###

     

       42
       42
       +
       ###############

     

       43
       43
       +
         """

     

       44
       44
       +
       ```

     

       45
       45
       +
       

     

       46
       46
       +
       <!-- livebook:{"output":true} -->

     

       47
       47
       +
       

     

       48
       48
       +
       ```

     

       49
       49
       +
       warning: outdented heredoc line. The contents inside the heredoc should be indented at the same level as the closing """. The following is forbidden:

     

       50
       50
       +
       

     

       51
       51
       +
           def text do

     

       52
       52
       +
             """

     

       53
       53
       +
           contents

     

       54
       54
       +
             """

     

       55
       55
       +
           end

     

       56
       56
       +
       

     

       57
       57
       +
       Instead make sure the contents are indented as much as the heredoc closing:

     

       58
       58
       +
       

     

       59
       59
       +
           def text do

     

       60
       60
       +
             """

     

       61
       61
       +
             contents

     

       62
       62
       +
             """

     

       63
       63
       +
           end

     

       64
       64
       +
       

     

       65
       65
       +
       The current heredoc line is indented too little

     

       66
       66
       +
       └─ Workspace/hauleth/advent-of-code/2024/day20.livemd#cell:iyjl3w4kz3srtwoq:3:3

     

       67
       67
       +
       

     

       68
       68
       +
       ```

     

       69
       69
       +
       

     

       70
       70
       +
       <!-- livebook:{"output":true} -->

     

       71
       71
       +
       

     

       72
       72
       +
       ```

     

       73
       73
       +
       "###############\n#...#...#.....#\n#.#.#.#.#.###.#\n#S#...#.#.#...#\n#######.#.#.###\n#######.#.#...#\n#######.#.###.#\n###..E#...#...#\n###.#######.###\n#...###...#...#\n#.#####.#.###.#\n#.#...#.#.#...#\n#.#.#.#.#.#.###\n#...#...#...###\n###############\n"

     

       74
       74
       +
       ```

     

       75
       75
       +
       

     

       76
       76
       +
       ```elixir

     

       77
       77
       +
       map =

     

       78
       78
       +
         puzzle_input

     

       79
       79
       +
         |> String.split("\n")

     

       80
       80
       +
         |> Enum.with_index()

     

       81
       81
       +
         |> Enum.flat_map(fn {row, y} ->

     

       82
       82
       +
           row

     

       83
       83
       +
           |> String.split("", trim: true)

     

       84
       84
       +
           |> Enum.with_index()

     

       85
       85
       +
           |> Enum.map(fn {c, x} ->

     

       86
       86
       +
             {{x, y}, c}

     

       87
       87
       +
           end)

     

       88
       88
       +
         end)

     

       89
       89
       +
       ```

     

       90
       90
       +
       

     

       91
       91
       +
       <!-- livebook:{"output":true} -->

     

       92
       92
       +
       

     

       93
       93
       +
       ```

     

       94
       94
       +
       [

     

       95
       95
       +
         {{0, 0}, "#"},

     

       96
       96
       +
         {{1, 0}, "#"},

     

       97
       97
       +
         {{2, 0}, "#"},

     

       98
       98
       +
         {{3, 0}, "#"},

     

       99
       99
       +
         {{4, 0}, "#"},

     

       100
       100
       +
         {{5, 0}, "#"},

     

       101
       101
       +
         {{6, 0}, "#"},

     

       102
       102
       +
         {{7, 0}, "#"},

     

       103
       103
       +
         {{8, 0}, "#"},

     

       104
       104
       +
         {{9, 0}, "#"},

     

       105
       105
       +
         {{10, 0}, "#"},

     

       106
       106
       +
         {{11, 0}, "#"},

     

       107
       107
       +
         {{12, 0}, "#"},

     

       108
       108
       +
         {{13, 0}, "#"},

     

       109
       109
       +
         {{14, 0}, "#"},

     

       110
       110
       +
         {{15, 0}, "#"},

     

       111
       111
       +
         {{16, 0}, "#"},

     

       112
       112
       +
         {{17, 0}, "#"},

     

       113
       113
       +
         {{18, 0}, "#"},

     

       114
       114
       +
         {{19, 0}, "#"},

     

       115
       115
       +
         {{20, 0}, "#"},

     

       116
       116
       +
         {{21, 0}, "#"},

     

       117
       117
       +
         {{22, 0}, "#"},

     

       118
       118
       +
         {{23, 0}, "#"},

     

       119
       119
       +
         {{24, 0}, "#"},

     

       120
       120
       +
         {{25, 0}, "#"},

     

       121
       121
       +
         {{26, 0}, "#"},

     

       122
       122
       +
         {{27, 0}, "#"},

     

       123
       123
       +
         {{28, 0}, "#"},

     

       124
       124
       +
         {{29, 0}, "#"},

     

       125
       125
       +
         {{30, 0}, "#"},

     

       126
       126
       +
         {{31, 0}, "#"},

     

       127
       127
       +
         {{32, 0}, "#"},

     

       128
       128
       +
         {{33, 0}, "#"},

     

       129
       129
       +
         {{34, 0}, "#"},

     

       130
       130
       +
         {{35, 0}, "#"},

     

       131
       131
       +
         {{36, 0}, "#"},

     

       132
       132
       +
         {{37, 0}, "#"},

     

       133
       133
       +
         {{38, 0}, "#"},

     

       134
       134
       +
         {{39, 0}, "#"},

     

       135
       135
       +
         {{40, 0}, "#"},

     

       136
       136
       +
         {{41, 0}, "#"},

     

       137
       137
       +
         {{42, 0}, "#"},

     

       138
       138
       +
         {{43, 0}, "#"},

     

       139
       139
       +
         {{44, 0}, "#"},

     

       140
       140
       +
         {{45, 0}, "#"},

     

       141
       141
       +
         {{46, 0}, "#"},

     

       142
       142
       +
         {{47, ...}, "#"},

     

       143
       143
       +
         {{...}, ...},

     

       144
       144
       +
         {...},

     

       145
       145
       +
         ...

     

       146
       146
       +
       ]

     

       147
       147
       +
       ```

     

       148
       148
       +
       

     

       149
       149
       +
       ```elixir

     

       150
       150
       +
       %{"#" => walls, "." => road, "S" => [start], "E" => [finish]} =

     

       151
       151
       +
         Enum.group_by(map, &elem(&1, 1), &elem(&1, 0))

     

       152
       152
       +
       ```

     

       153
       153
       +
       

     

       154
       154
       +
       <!-- livebook:{"output":true} -->

     

       155
       155
       +
       

     

       156
       156
       +
       ```

     

       157
       157
       +
       %{

     

       158
       158
       +
         "#" => [

     

       159
       159
       +
           {0, 0},

     

       160
       160
       +
           {1, 0},

     

       161
       161
       +
           {2, 0},

     

       162
       162
       +
           {3, 0},

     

       163
       163
       +
           {4, 0},

     

       164
       164
       +
           {5, 0},

     

       165
       165
       +
           {6, 0},

     

       166
       166
       +
           {7, 0},

     

       167
       167
       +
           {8, 0},

     

       168
       168
       +
           {9, 0},

     

       169
       169
       +
           {10, 0},

     

       170
       170
       +
           {11, 0},

     

       171
       171
       +
           {12, 0},

     

       172
       172
       +
           {13, 0},

     

       173
       173
       +
           {14, 0},

     

       174
       174
       +
           {15, 0},

     

       175
       175
       +
           {16, 0},

     

       176
       176
       +
           {17, 0},

     

       177
       177
       +
           {18, 0},

     

       178
       178
       +
           {19, 0},

     

       179
       179
       +
           {20, 0},

     

       180
       180
       +
           {21, 0},

     

       181
       181
       +
           {22, 0},

     

       182
       182
       +
           {23, 0},

     

       183
       183
       +
           {24, 0},

     

       184
       184
       +
           {25, 0},

     

       185
       185
       +
           {26, 0},

     

       186
       186
       +
           {27, 0},

     

       187
       187
       +
           {28, 0},

     

       188
       188
       +
           {29, 0},

     

       189
       189
       +
           {30, 0},

     

       190
       190
       +
           {31, 0},

     

       191
       191
       +
           {32, 0},

     

       192
       192
       +
           {33, 0},

     

       193
       193
       +
           {34, 0},

     

       194
       194
       +
           {35, 0},

     

       195
       195
       +
           {36, 0},

     

       196
       196
       +
           {37, 0},

     

       197
       197
       +
           {38, 0},

     

       198
       198
       +
           {39, 0},

     

       199
       199
       +
           {40, 0},

     

       200
       200
       +
           {41, 0},

     

       201
       201
       +
           {42, 0},

     

       202
       202
       +
           {43, 0},

     

       203
       203
       +
           {44, 0},

     

       204
       204
       +
           {45, 0},

     

       205
       205
       +
           {46, 0},

     

       206
       206
       +
           {47, ...},

     

       207
       207
       +
           {...},

     

       208
       208
       +
           ...

     

       209
       209
       +
         ],

     

       210
       210
       +
         "." => [

     

       211
       211
       +
           {1, 1},

     

       212
       212
       +
           {2, 1},

     

       213
       213
       +
           {3, 1},

     

       214
       214
       +
           {5, 1},

     

       215
       215
       +
           {6, 1},

     

       216
       216
       +
           {7, 1},

     

       217
       217
       +
           {9, 1},

     

       218
       218
       +
           {10, 1},

     

       219
       219
       +
           {11, 1},

     

       220
       220
       +
           {13, 1},

     

       221
       221
       +
           {14, 1},

     

       222
       222
       +
           {15, 1},

     

       223
       223
       +
           {17, 1},

     

       224
       224
       +
           {18, 1},

     

       225
       225
       +
           {19, 1},

     

       226
       226
       +
           {20, 1},

     

       227
       227
       +
           {21, 1},

     

       228
       228
       +
           {22, 1},

     

       229
       229
       +
           {23, 1},

     

       230
       230
       +
           {24, 1},

     

       231
       231
       +
           {25, 1},

     

       232
       232
       +
           {27, 1},

     

       233
       233
       +
           {28, 1},

     

       234
       234
       +
           {29, 1},

     

       235
       235
       +
           {30, 1},

     

       236
       236
       +
           {31, 1},

     

       237
       237
       +
           {32, 1},

     

       238
       238
       +
           {33, 1},

     

       239
       239
       +
           {34, 1},

     

       240
       240
       +
           {35, 1},

     

       241
       241
       +
           {39, 1},

     

       242
       242
       +
           {40, 1},

     

       243
       243
       +
           {41, 1},

     

       244
       244
       +
           {43, 1},

     

       245
       245
       +
           {44, 1},

     

       246
       246
       +
           {45, 1},

     

       247
       247
       +
           {46, 1},

     

       248
       248
       +
           {47, 1},

     

       249
       249
       +
           {49, 1},

     

       250
       250
       +
           {50, 1},

     

       251
       251
       +
           {51, 1},

     

       252
       252
       +
           {53, 1},

     

       253
       253
       +
           {54, 1},

     

       254
       254
       +
           {55, 1},

     

       255
       255
       +
           {56, 1},

     

       256
       256
       +
           {57, 1},

     

       257
       257
       +
           {59, ...},

     

       258
       258
       +
           {...},

     

       259
       259
       +
           ...

     

       260
       260
       +
         ],

     

       261
       261
       +
         "E" => [{27, 59}],

     

       262
       262
       +
         "S" => [{49, 53}]

     

       263
       263
       +
       }

     

       264
       264
       +
       ```

     

       265
       265
       +
       

     

       266
       266
       +
       ```elixir

     

       267
       267
       +
       defmodule Race do

     

       268
       268
       +
         def distances(start, finish, walls) do

     

       269
       269
       +
           do_distances(start, finish, 0, MapSet.new(walls), %{})

     

       270
       270
       +
         end

     

       271
       271
       +
       

     

       272
       272
       +
         defp do_distances(finish, finish, n, _, acc),

     

       273
       273
       +
           do: Map.put(acc, finish, n)

     

       274
       274
       +
       

     

       275
       275
       +
         defp do_distances(current, finish, n, walls, acc) do

     

       276
       276
       +
           acc = Map.put(acc, current, n)

     

       277
       277
       +
       

     

       278
       278
       +
           current

     

       279
       279
       +
           |> neigh()

     

       280
       280
       +
           |> Enum.reject(&(&1 in walls or Map.has_key?(acc, &1)))

     

       281
       281
       +
           |> hd()

     

       282
       282
       +
           |> do_distances(finish, n + 1, walls, acc)

     

       283
       283
       +
         end

     

       284
       284
       +
       

     

       285
       285
       +
         def neigh({x, y}, d \\ 1) do

     

       286
       286
       +
           for {dx, dy} <- [{0, d}, {0, -d}, {d, 0}, {-d, 0}], do: {x + dx, y + dy}

     

       287
       287
       +
         end

     

       288
       288
       +
       

     

       289
       289
       +
         def neighbours({x, y}, r \\ 1) do

     

       290
       290
       +
           for dx <- -r..r,

     

       291
       291
       +
               dy <- -r..r,

     

       292
       292
       +
               {dx, dy} != {0, 0},

     

       293
       293
       +
               d = abs(dx) + abs(dy),

     

       294
       294
       +
               d <= r,

     

       295
       295
       +
               do: {x + dx, y + dy}

     

       296
       296
       +
         end

     

       297
       297
       +
       

     

       298
       298
       +
         def d({xa, ya}, {xb, yb}) do

     

       299
       299
       +
           abs(xa - xb) + abs(ya - yb)

     

       300
       300
       +
         end

     

       301
       301
       +
       end

     

       302
       302
       +
       ```

     

       303
       303
       +
       

     

       304
       304
       +
       <!-- livebook:{"output":true} -->

     

       305
       305
       +
       

     

       306
       306
       +
       ```

     

       307
       307
       +
       {:module, Race, <<70, 79, 82, 49, 0, 0, 17, ...>>, {:d, 2}}

     

       308
       308
       +
       ```

     

       309
       309
       +
       

     

       310
       310
       +
       ```elixir

     

       311
       311
       +
       steps = Race.distances(start, finish, walls)

     

       312
       312
       +
       ```

     

       313
       313
       +
       

     

       314
       314
       +
       <!-- livebook:{"output":true} -->

     

       315
       315
       +
       

     

       316
       316
       +
       ```

     

       317
       317
       +
       %{

     

       318
       318
       +
         {18, 103} => 8261,

     

       319
       319
       +
         {61, 121} => 7060,

     

       320
       320
       +
         {65, 63} => 2098,

     

       321
       321
       +
         {77, 129} => 6964,

     

       322
       322
       +
         {1, 26} => 695,

     

       323
       323
       +
         {116, 69} => 4441,

     

       324
       324
       +
         {83, 76} => 4281,

     

       325
       325
       +
         {117, 125} => 5656,

     

       326
       326
       +
         {103, 106} => 5785,

     

       327
       327
       +
         {30, 113} => 8041,

     

       328
       328
       +
         {89, 14} => 2511,

     

       329
       329
       +
         {35, 30} => 1133,

     

       330
       330
       +
         {37, 53} => 32,

     

       331
       331
       +
         {11, 39} => 384,

     

       332
       332
       +
         {131, 5} => 2998,

     

       333
       333
       +
         {65, 43} => 1754,

     

       334
       334
       +
         {139, 46} => 3615,

     

       335
       335
       +
         {12, 135} => 7871,

     

       336
       336
       +
         {65, 131} => 7046,

     

       337
       337
       +
         {49, 117} => 7412,

     

       338
       338
       +
         {29, 25} => 1108,

     

       339
       339
       +
         {83, 36} => 2319,

     

       340
       340
       +
         {47, 27} => 1556,

     

       341
       341
       +
         {4, 81} => 8645,

     

       342
       342
       +
         {13, 124} => 8295,

     

       343
       343
       +
         {121, 77} => 4608,

     

       344
       344
       +
         {103, 39} => 3756,

     

       345
       345
       +
         {119, 60} => 4389,

     

       346
       346
       +
         {13, 85} => 8604,

     

       347
       347
       +
         {63, 81} => 6682,

     

       348
       348
       +
         {111, 108} => 5755,

     

       349
       349
       +
         {111, 103} => 5764,

     

       350
       350
       +
         {15, 92} => 8587,

     

       351
       351
       +
         {1, 101} => 8500,

     

       352
       352
       +
         {20, 3} => 939,

     

       353
       353
       +
         {61, 95} => 6878,

     

       354
       354
       +
         {23, 67} => 9208,

     

       355
       355
       +
         {78, 75} => 6545,

     

       356
       356
       +
         {79, 17} => 2358,

     

       357
       357
       +
         {17, 137} => 7852,

     

       358
       358
       +
         {124, 93} => 4933,

     

       359
       359
       +
         {138, 9} => 3283,

     

       360
       360
       +
         {58, 33} => 1667,

     

       361
       361
       +
         {67, 105} => 6818,

     

       362
       362
       +
         {47, 44} => 1195,

     

       363
       363
       +
         {122, 137} => 5595,

     

       364
       364
       +
         {13, 55} => 154,

     

       365
       365
       +
         {97, 138} => 6129,

     

       366
       366
       +
         {75, ...} => 2165,

     

       367
       367
       +
         {...} => 1616,

     

       368
       368
       +
         ...

     

       369
       369
       +
       }

     

       370
       370
       +
       ```

     

       371
       371
       +
       

     

       372
       372
       +
       ## Part 1

     

       373
       373
       +
       

     

       374
       374
       +
       ```elixir

     

       375
       375
       +
       Enum.reduce(steps, 0, fn {pos, start}, acc ->

     

       376
       376
       +
         count =

     

       377
       377
       +
           steps

     

       378
       378
       +
           |> Map.take(Race.neighbours(pos, 2))

     

       379
       379
       +
           |> Enum.count(fn {last, finish} ->

     

       380
       380
       +
             finish - start - Race.d(pos, last) >= 100

     

       381
       381
       +
           end)

     

       382
       382
       +
       

     

       383
       383
       +
         count + acc

     

       384
       384
       +
       end)

     

       385
       385
       +
       ```

     

       386
       386
       +
       

     

       387
       387
       +
       <!-- livebook:{"output":true} -->

     

       388
       388
       +
       

     

       389
       389
       +
       ```

     

       390
       390
       +
       1393

     

       391
       391
       +
       ```

     

       392
       392
       +
       

     

       393
       393
       +
       ## Part 2

     

       394
       394
       +
       

     

       395
       395
       +
       We can notice that we are looking for shortcuts in circle of radius $r$ defined in Taxicab metric ($d(a, b) = \sum_{i} |a_i - b_i|$). That makes code pretty simple and allows us to reuse ideas from Part 1.

     

       396
       396
       +
       

     

       397
       397
       +
       ```elixir

     

       398
       398
       +
       steps

     

       399
       399
       +
       |> Task.async_stream(

     

       400
       400
       +
         fn {pos, start} ->

     

       401
       401
       +
           steps

     

       402
       402
       +
           |> Map.take(Race.neighbours(pos, 20))

     

       403
       403
       +
           |> Enum.count(fn {last, finish} ->

     

       404
       404
       +
             finish - start - Race.d(pos, last) >= 100

     

       405
       405
       +
           end)

     

       406
       406
       +
         end,

     

       407
       407
       +
         ordered: false

     

       408
       408
       +
       )

     

       409
       409
       +
       |> Enum.reduce(0, fn {:ok, count}, acc ->

     

       410
       410
       +
         count + acc

     

       411
       411
       +
       end)

     

       412
       412
       +
       ```

     

       413
       413
       +
       

     

       414
       414
       +
       <!-- livebook:{"output":true} -->

     

       415
       415
       +
       

     

       416
       416
       +
       ```

     

       417
       417
       +
       990096

     

       418
       418
       +
       ```

     

       419
       419
       +
       

     

       420
       420
       +
       <!-- livebook:{"offset":11400,"stamp":{"token":"XCP.ONwDp6zRpWXsXASH95Q0puANk15Li1hG2FDCrv6Gqu42Q7k9pb_Te_6RDoUE0dp3yYbG7jry8-6iHGJvcZtsDFstlznyVHk9HVhXRZiC2uQczaOfF4K8HQL9QuzNguTht7A","version":2}} -->

+182

2024/day21.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 21

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIyMSIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI0In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "21", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok, "638A\n965A\n780A\n803A\n246A"}

     

       22
       22
       +
       ```

     

       23
       23
       +
       

     

       24
       24
       +
       ```elixir

     

       25
       25
       +
       codes =

     

       26
       26
       +
         puzzle_input

     

       27
       27
       +
         |> String.split("\n", trim: true)

     

       28
       28
       +
         |> Enum.map(fn <<num::3-binary>> <> "A" = code ->

     

       29
       29
       +
           {String.to_charlist(code), String.to_integer(num)}

     

       30
       30
       +
         end)

     

       31
       31
       +
       ```

     

       32
       32
       +
       

     

       33
       33
       +
       <!-- livebook:{"output":true} -->

     

       34
       34
       +
       

     

       35
       35
       +
       ```

     

       36
       36
       +
       [{~c"638A", 638}, {~c"965A", 965}, {~c"780A", 780}, {~c"803A", 803}, {~c"246A", 246}]

     

       37
       37
       +
       ```

     

       38
       38
       +
       

     

       39
       39
       +
       ```elixir

     

       40
       40
       +
       dirpad = %{

     

       41
       41
       +
         [?A, ?>] => ~c[vA],

     

       42
       42
       +
         [?A, ?^] => ~c[<A],

     

       43
       43
       +
         [?A, ?v] => ~c[<vA],

     

       44
       44
       +
         [?A, ?<] => ~c[v<<A],

     

       45
       45
       +
       

     

       46
       46
       +
         [?>, ?A] => ~c[^A],

     

       47
       47
       +
         [?>, ?^] => ~c[<^A],

     

       48
       48
       +
         [?>, ?v] => ~c[<A],

     

       49
       49
       +
         [?>, ?<] => ~c[<<A],

     

       50
       50
       +
       

     

       51
       51
       +
         [?^, ?A] => ~c[>A],

     

       52
       52
       +
         [?^, ?>] => ~c[v>A],

     

       53
       53
       +
         [?^, ?v] => ~c[vA],

     

       54
       54
       +
         [?^, ?<] => ~c[v<A],

     

       55
       55
       +
       

     

       56
       56
       +
         [?<, ?A] => ~c[>>^A],

     

       57
       57
       +
         [?<, ?^] => ~c[>^A],

     

       58
       58
       +
         [?<, ?v] => ~c[>A],

     

       59
       59
       +
         [?<, ?>] => ~c[>>A],

     

       60
       60
       +
       

     

       61
       61
       +
         [?v, ?A] => ~c[>^A],

     

       62
       62
       +
         [?v, ?^] => ~c[^A],

     

       63
       63
       +
         [?v, ?<] => ~c[<A],

     

       64
       64
       +
         [?v, ?>] => ~c[>A]

     

       65
       65
       +
       }

     

       66
       66
       +
       ```

     

       67
       67
       +
       

     

       68
       68
       +
       <!-- livebook:{"output":true} -->

     

       69
       69
       +
       

     

       70
       70
       +
       ```

     

       71
       71
       +
       %{

     

       72
       72
       +
         ~c"<>" => ~c">>A",

     

       73
       73
       +
         ~c"<A" => ~c">>^A",

     

       74
       74
       +
         ~c"<^" => ~c">^A",

     

       75
       75
       +
         ~c"<v" => ~c">A",

     

       76
       76
       +
         ~c"><" => ~c"<<A",

     

       77
       77
       +
         ~c">A" => ~c"^A",

     

       78
       78
       +
         ~c">^" => ~c"<^A",

     

       79
       79
       +
         ~c">v" => ~c"<A",

     

       80
       80
       +
         ~c"A<" => ~c"v<<A",

     

       81
       81
       +
         ~c"A>" => ~c"vA",

     

       82
       82
       +
         ~c"A^" => ~c"<A",

     

       83
       83
       +
         ~c"Av" => ~c"<vA",

     

       84
       84
       +
         ~c"^<" => ~c"v<A",

     

       85
       85
       +
         ~c"^>" => ~c"v>A",

     

       86
       86
       +
         ~c"^A" => ~c">A",

     

       87
       87
       +
         ~c"^v" => ~c"vA",

     

       88
       88
       +
         ~c"v<" => ~c"<A",

     

       89
       89
       +
         ~c"v>" => ~c">A",

     

       90
       90
       +
         ~c"vA" => ~c">^A",

     

       91
       91
       +
         ~c"v^" => ~c"^A"

     

       92
       92
       +
       }

     

       93
       93
       +
       ```

     

       94
       94
       +
       

     

       95
       95
       +
       ```elixir

     

       96
       96
       +
       

     

       97
       97
       +
       ```

     

       98
       98
       +
       

     

       99
       99
       +
       <!-- livebook:{"output":true} -->

     

       100
       100
       +
       

     

       101
       101
       +
       ```

     

       102
       102
       +
       nil

     

       103
       103
       +
       ```

     

       104
       104
       +
       

     

       105
       105
       +
       ```elixir

     

       106
       106
       +
       defmodule Keypad do

     

       107
       107
       +
         def naive(input, lut) do

     

       108
       108
       +
           [?A | input]

     

       109
       109
       +
           |> Enum.chunk_every(2, 1, :discard)

     

       110
       110
       +
           |> Enum.flat_map(&Map.get(lut, &1, [?A]))

     

       111
       111
       +
         end

     

       112
       112
       +
       

     

       113
       113
       +
         def expand(input, lut) do

     

       114
       114
       +
           Stream.concat([?A], input)

     

       115
       115
       +
           |> Stream.chunk_every(2, 1, :discard)

     

       116
       116
       +
           |> Stream.flat_map(&Map.get(lut, &1, [?A]))

     

       117
       117
       +
         end

     

       118
       118
       +
       end

     

       119
       119
       +
       ```

     

       120
       120
       +
       

     

       121
       121
       +
       <!-- livebook:{"output":true} -->

     

       122
       122
       +
       

     

       123
       123
       +
       ```

     

       124
       124
       +
       {:module, Keypad, <<70, 79, 82, 49, 0, 0, 9, ...>>, {:expand, 2}}

     

       125
       125
       +
       ```

     

       126
       126
       +
       

     

       127
       127
       +
       ```elixir

     

       128
       128
       +
       

     

       129
       129
       +
       ```

     

       130
       130
       +
       

     

       131
       131
       +
       <!-- livebook:{"output":true} -->

     

       132
       132
       +
       

     

       133
       133
       +
       ```

     

       134
       134
       +
       nil

     

       135
       135
       +
       ```

     

       136
       136
       +
       

     

       137
       137
       +
       ```elixir

     

       138
       138
       +
       Keypad.expand(~c[<A^A>^^AvvvA], dirpad)

     

       139
       139
       +
       |> Enum.count()

     

       140
       140
       +
       

     

       141
       141
       +
       #|> Enum.map(fn {k, v} ->

     

       142
       142
       +
       #  [?A | Map.get(dirpad, k, [?A])]

     

       143
       143
       +
       #  |> Enum.chunk_every(2, 1, :discard)

     

       144
       144
       +
       #  |> Enum.map()

     

       145
       145
       +
       #end)

     

       146
       146
       +
       #|> Enum.group_by(&elem(&1, 0), &elem(&1, 1))

     

       147
       147
       +
       #|> Map.new(fn {k, v} -> {k, Enum.sum(v)} end)

     

       148
       148
       +
       ```

     

       149
       149
       +
       

     

       150
       150
       +
       <!-- livebook:{"output":true} -->

     

       151
       151
       +
       

     

       152
       152
       +
       ```

     

       153
       153
       +
       28

     

       154
       154
       +
       ```

     

       155
       155
       +
       

     

       156
       156
       +
       ```elixir

     

       157
       157
       +
       Keypad.naive(~c[<A^A>^^AvvvA], dirpad)

     

       158
       158
       +
       |> Keypad.naive(dirpad)

     

       159
       159
       +
       |> Enum.chunk_every(2, 1, [?A])

     

       160
       160
       +
       |> Enum.frequencies()

     

       161
       161
       +
       |> Map.values()

     

       162
       162
       +
       |> Enum.sum()

     

       163
       163
       +
       ```

     

       164
       164
       +
       

     

       165
       165
       +
       <!-- livebook:{"output":true} -->

     

       166
       166
       +
       

     

       167
       167
       +
       ```

     

       168
       168
       +
       68

     

       169
       169
       +
       ```

     

       170
       170
       +
       

     

       171
       171
       +
       ```elixir

     

       172
       172
       +
       ~c"<vA<AA>>^AvAA<^A>Av<<A>>^AvA^A<vA>^Av<<A>^A>AAvA^Av<<A>A>^AAAvA<^A>A"

     

       173
       173
       +
       ~c"<vA<AA>>^AvAA<^A>A<v<A>>^AvA^A<vA>^A<v<A>^A>AAvA^A<v<A>A>^AAAvA<^A>A" |> length

     

       174
       174
       +
       ```

     

       175
       175
       +
       

     

       176
       176
       +
       <!-- livebook:{"output":true} -->

     

       177
       177
       +
       

     

       178
       178
       +
       ```

     

       179
       179
       +
       68

     

       180
       180
       +
       ```

     

       181
       181
       +
       

     

       182
       182
       +
       <!-- livebook:{"offset":3144,"stamp":{"token":"XCP.rEBKR0PbENlE02mf_Mo6R3RTWsHU-tFuA9VTPd907vq3-8e37LytxC6qWBmZAHZHLc_e1t3ZaG85X5KBWsYq0WGEzo7HC0U9-oE0dpPKGKeF7oBGgFeiEoDsX6GDKTwp76o","version":2}} -->

+198

2024/day22.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 22

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIyMiIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI0In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "22", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok,

     

       22
       22
       +
        "4832674\n14802956\n7210529\n7709095\n6063251\n12294789\n15666951\n12074106\n15427686\n1214891\n15165649\n3609602\n10200989\n16451437\n10915511\n3479515\n173864\n1238342\n3381843\n14767788\n16088065\n15637051\n15981887\n15854806\n4988920\n7980791\n11263142\n8044640\n4572291\n328777\n11851557\n13706949\n16451719\n15991644\n14668984\n8852039\n1685443\n13814197\n14117797\n6281998\n12395020\n1681090\n16476099\n2171296\n10155667\n15490827\n6723206\n7272972\n1788575\n2950054\n10917267\n6862495\n8153949\n16559239\n8572595\n1821668\n3417901\n11375457\n3878450\n10863466\n10890116\n13055126\n7451580\n5815531\n8335506\n431487\n201975\n5841753\n11744013\n4498615\n9261071\n9953929\n4630027\n2227105\n6260342\n10375281\n3015284\n3789175\n15843612\n14432075\n14847622\n11501912\n9079366\n2550341\n6931972\n13371306\n9601571\n14504463\n6162939\n5361897\n14900517\n12748562\n7519640\n14694035\n5566950\n7688680\n13810532\n5654369\n10957671\n6886767\n13114128\n9355299\n14808826\n11001280\n4983663\n9915373\n3356476\n16519750\n15826279\n11122172\n12902904\n1010762\n16214923\n9519057\n15931832\n15664252\n12750269\n1110882\n7854151\n3509827\n10328167\n1494530\n8712493\n396534\n15995697\n7396815\n3419574\n14789278\n14099072\n15389372\n6910648\n649063\n3609071\n6004556\n5054128\n13730203\n3554012\n2766085\n7133343\n7566747\n1194302\n10446649\n1529903\n9036124\n11725198\n6479244\n10287711\n2219155\n2360315\n8169407\n7841353\n7486466\n15297309\n9336789\n7225072\n6248515\n16154198\n11100038\n8584563\n3753173\n7371112\n2481160\n10954049\n8009781\n7381801\n280810\n11001420\n14114713\n4242475\n1237360\n6496866\n15267044\n1880781\n8798544\n5033766\n5079684\n11633848\n16509688\n8226900\n15858455\n16041151\n5334220\n15421957\n2633967\n8343560\n14729378\n9702409\n5482505\n2041087\n9712582\n3430735\n10644043\n9195957\n1784419\n14046333\n2031279\n12766582\n12165573\n14207224\n14929506\n11436548\n13623882\n12370036\n7592923\n228169\n8988171\n6688080\n5492092\n8212636\n3736928\n15352784\n2612376\n14843761\n12308540\n8404032\n11632730\n4404470\n2599992\n6807809\n12044159\n9795957\n5307557\n13144362\n13941181\n9362743\n4957570\n9950852\n4069207\n699043\n13667685\n12869414\n5834836\n8434557\n13512362\n5446646\n16663243\n10059682\n231185\n14405863\n10532295\n13752653\n3266523\n12926376\n9013886\n15683001\n10524950\n325867\n15226063\n15175724\n15991383\n13961546\n15823957\n9310375\n5534565\n2674761\n13444598\n9915920\n1755544\n1429896\n14788650\n5453166\n10081466\n2149840\n16613385\n2519989\n7555351\n7295534\n12099546\n3223009\n2684428\n8436395\n5406395\n836225\n9962036\n2847179\n12880336\n13215841\n3498334\n5985622\n7700379\n5785351\n9938722\n15810882\n2349820\n906893\n2513825\n10432278\n13789913\n2913486\n9683268\n2862417\n4807276\n16264545\n6607564\n10222512\n2190055\n11839341\n2132714\n153996\n10874457\n12023939\n7748310\n13452955\n3246986\n2892967\n9561561\n3280827\n991231\n13105708\n16641479\n273523\n4832864\n13832855\n7903624\n13242917\n13379831\n9085055\n1473661\n11031255\n4126827\n12754058\n456062\n14316218\n6580848\n11147440\n1828704\n15262845\n557484\n2406569\n10393027\n3363996\n15821838\n16365523\n5566374\n3723957\n5186897\n501767\n10639559\n3256585\n2354615\n1888438\n11574106\n11798800\n12629659\n6316600\n3119025\n14801938\n7025953\n14949782\n7577552\n14785389\n8868837\n11642113\n14574465\n8689963\n16223594\n14705685\n16363438\n1393194\n5961465\n16603208\n8121071\n15143692\n7531645\n6777163\n8168251\n15905711\n2373414\n1269213\n2506356\n1080789\n2154403\n11578189\n6232867\n10065427\n15116084\n15449140\n12675436\n14126594\n8470014\n2106625\n12556109\n12771090\n1437370\n16145074\n6244539\n6832665\n13217078\n5152936\n15205635\n12092447\n15115231\n2112929\n13215959\n11124896\n14598714\n15256810\n9994507\n11687859\n11599901\n5330801\n13829820\n1720133\n11040068\n4351948\n9597919\n10673331\n6148104\n12360792\n9687192\n11668420\n10272257\n7823976\n6113203\n8827921\n5600165\n6950138\n9581746\n15917691\n6453798\n11788226\n15057269\n9639028\n5073513\n15459362\n14118507\n7979569\n4210224\n5726357\n10649449\n14645020\n3062620\n14613306\n13963982\n14770179\n15097265\n1789308\n12405157\n7360698\n6983540\n9752726\n8200080\n5784060\n13456865\n4677699\n3783161\n13650051\n9865655\n13066800\n1868022\n5855823\n15061710\n11742417\n2116233\n15002417\n904747\n9455335\n5203086\n704685\n902384\n15284593\n8328120\n13587250\n11550241\n10950646\n14876694\n11393724\n14576237\n898540\n8874901\n5548732\n11351523\n2315166\n9532824\n11462685\n1297628\n3862586\n16331382\n9291789\n2887008\n2582973\n4861709\n15301133\n8978897\n533818\n1565155\n3829639\n8438476\n11901529" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       inits =

     

       27
       27
       +
         puzzle_input

     

       28
       28
       +
         |> String.split("\n", trim: true)

     

       29
       29
       +
         |> Enum.map(&String.to_integer/1)

     

       30
       30
       +
       ```

     

       31
       31
       +
       

     

       32
       32
       +
       <!-- livebook:{"output":true} -->

     

       33
       33
       +
       

     

       34
       34
       +
       ```

     

       35
       35
       +
       [4832674, 14802956, 7210529, 7709095, 6063251, 12294789, 15666951, 12074106, 15427686, 1214891,

     

       36
       36
       +
        15165649, 3609602, 10200989, 16451437, 10915511, 3479515, 173864, 1238342, 3381843, 14767788,

     

       37
       37
       +
        16088065, 15637051, 15981887, 15854806, 4988920, 7980791, 11263142, 8044640, 4572291, 328777,

     

       38
       38
       +
        11851557, 13706949, 16451719, 15991644, 14668984, 8852039, 1685443, 13814197, 14117797, 6281998,

     

       39
       39
       +
        12395020, 1681090, 16476099, 2171296, 10155667, 15490827, 6723206, 7272972, 1788575, 2950054, ...]

     

       40
       40
       +
       ```

     

       41
       41
       +
       

     

       42
       42
       +
       ```elixir

     

       43
       43
       +
       defmodule Buyer do

     

       44
       44
       +
         def hash(number, rounds \\ 2000) do

     

       45
       45
       +
           Enum.map_reduce(1..rounds//1, number, fn _, acc ->

     

       46
       46
       +
             r = do_round(acc)

     

       47
       47
       +
             {rem(r, 10), r}

     

       48
       48
       +
           end)

     

       49
       49
       +
         end

     

       50
       50
       +
       

     

       51
       51
       +
         defp do_round(num) do

     

       52
       52
       +
           num = subround(num, num * 64)

     

       53
       53
       +
           num = subround(num, div(num, 32))

     

       54
       54
       +
           subround(num, num * 2048)

     

       55
       55
       +
         end

     

       56
       56
       +
       

     

       57
       57
       +
         defp subround(a, b), do: rem(Bitwise.bxor(a, b), 16_777_216)

     

       58
       58
       +
       

     

       59
       59
       +
         def sequences(prices) do

     

       60
       60
       +
           prices

     

       61
       61
       +
           |> Enum.chunk_every(5, 1, :discard)

     

       62
       62
       +
           |> Enum.reduce(%{}, fn seq, map ->

     

       63
       63
       +
             Map.put_new(map, diffs(seq), List.last(seq))

     

       64
       64
       +
           end)

     

       65
       65
       +
         end

     

       66
       66
       +
       

     

       67
       67
       +
         defp diffs(vals) do

     

       68
       68
       +
           vals

     

       69
       69
       +
           |> Enum.chunk_every(2, 1, :discard)

     

       70
       70
       +
           |> Enum.map(fn [a, b] -> b - a end)

     

       71
       71
       +
           |> Integer.undigits(256)

     

       72
       72
       +
         end

     

       73
       73
       +
       end

     

       74
       74
       +
       ```

     

       75
       75
       +
       

     

       76
       76
       +
       <!-- livebook:{"output":true} -->

     

       77
       77
       +
       

     

       78
       78
       +
       ```

     

       79
       79
       +
       {:module, Buyer, <<70, 79, 82, 49, 0, 0, 13, ...>>, {:diffs, 1}}

     

       80
       80
       +
       ```

     

       81
       81
       +
       

     

       82
       82
       +
       ```elixir

     

       83
       83
       +
       hashes = Enum.map(inits, &Buyer.hash(&1))

     

       84
       84
       +
       ```

     

       85
       85
       +
       

     

       86
       86
       +
       <!-- livebook:{"output":true} -->

     

       87
       87
       +
       

     

       88
       88
       +
       ```

     

       89
       89
       +
       [

     

       90
       90
       +
         {[5, 9, 7, 9, 4, 6, 2, 9, 4, 3, 6, 5, 0, 6, 5, 7, 2, 7, 9, 7, 0, 2, 5, 8, 8, 2, 0, 8, 4, 8, 3, 1,

     

       91
       91
       +
           4, 3, 3, 8, 0, 5, 2, 1, 2, 8, 6, 2, 2, 3, 6, 9, ...], 8186085},

     

       92
       92
       +
         {[8, 6, 8, 8, 3, 4, 6, 9, 0, 1, 1, 5, 4, 9, 5, 4, 1, 2, 5, 2, 6, 7, 8, 7, 5, 4, 4, 2, 5, 6, 4, 6,

     

       93
       93
       +
           2, 4, 5, 9, 5, 8, 5, 0, 6, 9, 3, 2, 3, 4, 4, ...], 16060909},

     

       94
       94
       +
         {[6, 0, 5, 8, 8, 7, 3, 6, 0, 9, 1, 0, 7, 2, 7, 5, 6, 4, 0, 5, 4, 0, 1, 9, 6, 5, 7, 1, 7, 9, 9, 9,

     

       95
       95
       +
           5, 6, 0, 7, 3, 0, 9, 4, 8, 4, 0, 2, 2, 7, ...], 3581487},

     

       96
       96
       +
         {[6, 3, 1, 0, 2, 6, 8, 9, 1, 6, 7, 4, 5, 0, 9, 9, 8, 9, 1, 0, 6, 4, 9, 0, 1, 0, 9, 3, 0, 0, 9, 1,

     

       97
       97
       +
           9, 6, 6, 7, 2, 1, 7, 2, 7, 3, 2, 7, 3, ...], 14331752},

     

       98
       98
       +
         {[3, 5, 1, 7, 1, 4, 6, 0, 4, 9, 8, 3, 7, 3, 3, 2, 2, 9, 1, 3, 3, 4, 9, 2, 3, 2, 5, 6, 9, 4, 3, 8,

     

       99
       99
       +
           1, 6, 7, 3, 8, 8, 7, 5, 3, 3, 2, 3, ...], 11096256},

     

       100
       100
       +
         {[9, 5, 4, 8, 1, 3, 9, 8, 2, 6, 7, 9, 0, 8, 6, 3, 4, 8, 7, 0, 0, 2, 2, 7, 2, 2, 0, 9, 7, 4, 9, 5,

     

       101
       101
       +
           7, 1, 3, 1, 7, 9, 3, 3, 6, 2, 4, ...], 8119288},

     

       102
       102
       +
         {[3, 0, 8, 6, 0, 0, 3, 4, 2, 0, 0, 8, 7, 6, 3, 7, 5, 2, 4, 8, 4, 4, 5, 4, 8, 9, 2, 1, 6, 8, 3, 9,

     

       103
       103
       +
           2, 8, 0, 5, 0, 9, 7, 2, 5, 9, ...], 4175670},

     

       104
       104
       +
         {[9, 6, 3, 2, 9, 6, 8, 1, 7, 8, 0, 7, 2, 2, 0, 8, 6, 5, 5, 3, 9, 6, 5, 7, 1, 4, 6, 7, 9, 7, 2, 4,

     

       105
       105
       +
           6, 2, 0, 2, 9, 7, 8, 0, 9, ...], 9128738},

     

       106
       106
       +
         {[5, 8, 5, 2, 2, 9, 4, 4, 8, 8, 9, 9, 8, 3, 4, 9, 2, 2, 9, 1, 2, 2, 0, 8, 1, 2, 3, 4, 0, 4, 6, 4,

     

       107
       107
       +
           3, 6, 8, 1, 9, 6, 1, 5, ...], 13899897},

     

       108
       108
       +
         {[0, 9, 4, 3, 5, 9, 1, 2, 1, 1, 8, 1, 8, 8, 3, 8, 4, 4, 3, 7, 7, 2, 9, 8, 5, 8, 8, 4, 4, 8, 4, 0,

     

       109
       109
       +
           5, 9, 7, 0, 3, 3, 6, ...], 12087848},

     

       110
       110
       +
         {[5, 6, 7, 3, 2, 0, 5, 4, 8, 8, 2, 6, 8, 4, 9, 7, 2, 0, 9, 3, 4, 1, 3, 0, 6, 5, 2, 6, 4, 6, 9, 4,

     

       111
       111
       +
           3, 9, 9, 9, 7, 2, ...], 11514818},

     

       112
       112
       +
         {[0, 9, 7, 9, 2, 6, 4, 9, 7, 0, 3, 1, 6, 4, 3, 2, 0, 2, 8, 4, 7, 6, 7, 7, 1, 1, 5, 2, 6, 6, 1, 4,

     

       113
       113
       +
           9, 5, 6, 9, 3, ...], 4150418},

     

       114
       114
       +
         {[5, 5, 0, 8, 5, 6, 2, 7, 0, 5, 4, 2, 1, 0, 5, 6, 6, 3, 6, 2, 4, 3, 9, 4, 3, 0, 8, 0, 6, 7, 1, 8,

     

       115
       115
       +
           0, 2, 7, 1, ...], 2679493},

     

       116
       116
       +
         {[4, 0, 8, 1, 5, 9, 0, 3, 6, 0, 2, 8, 5, 7, 1, 1, 9, 1, 5, 1, 5, 0, 7, 3, 5, 5, 4, 3, 9, 4, 3, 9,

     

       117
       117
       +
           6, 9, 6, ...], 84072},

     

       118
       118
       +
         {[0, 5, 2, 6, 6, 4, 1, 2, 5, 2, 3, 8, 4, 1, 2, 4, 7, 5, 2, 7, 7, 0, 8, 0, 6, 0, 6, 3, 4, 3, 7, 0,

     

       119
       119
       +
           5, 8, ...], 3938870},

     

       120
       120
       +
         {[5, 5, 5, 5, 6, 0, 6, 9, 2, 0, 0, 5, 3, 0, 3, 3, 0, 7, 7, 0, 1, 5, 8, 8, 6, 5, 3, 3, 2, 5, 8, 8,

     

       121
       121
       +
           8, ...], 15186439},

     

       122
       122
       +
         {[5, 1, 6, 4, 5, 2, 2, 2, 0, 9, 6, 3, 2, 1, 5, 6, 2, 6, 0, 4, 2, 8, 9, 2, 8, 7, 8, 7, 9, 2, 5, 1,

     

       123
       123
       +
           ...], 4224277},

     

       124
       124
       +
         {[8, 7, 6, 6, 8, 0, 1, 8, 9, 1, 7, 5, 0, 6, 4, 4, 9, 2, 1, 6, 1, 5, 4, 1, 9, 9, 9, 4, 7, 3, 0,

     

       125
       125
       +
           ...], 6637814},

     

       126
       126
       +
         {[7, 4, 4, 8, 3, 9, 5, 6, 1, 1, 7, 4, 7, 2, 5, 3, 8, 5, 3, 4, 7, 7, 0, 0, 4, 1, 7, 1, 4, 5, ...],

     

       127
       127
       +
          15335578},

     

       128
       128
       +
         {[1, 3, 9, 5, 1, 4, 9, 6, 9, 0, 6, 7, 7, 5, 4, 8, 8, 4, 4, 0, 3, 0, 0, 2, 8, 8, 8, 7, 5, ...],

     

       129
       129
       +
          14808063},

     

       130
       130
       +
         {[3, 8, 6, 7, 8, 8, 1, 5, 4, 2, 3, 3, 6, 0, 4, 4, 6, 3, 6, 3, 5, 3, 3, 7, 4, 7, 1, 8, ...],

     

       131
       131
       +
          2236221},

     

       132
       132
       +
         {[4, 2, 4, 3, 0, 3, 6, 2, 7, 9, 6, 6, 9, 3, 2, 0, 1, 8, 1, 5, 7, 7, 3, 8, 8, 1, 9, ...], 9777274},

     

       133
       133
       +
         {[8, 5, 1, 6, 9, 9, 1, 6, 3, 9, 9, 4, 5, 9, 4, 2, 8, 5, 7, 9, 2, 1, 6, 9, 0, 9, ...], 14777742},

     

       134
       134
       +
         {[4, 6, 0, 4, 6, 3, 2, 3, 8, 0, 2, 3, 2, 2, 0, 7, 7, 4, 5, 8, 8, 2, 8, 9, 4, ...], 3528684},

     

       135
       135
       +
         {[3, 6, 3, 3, 3, 2, 5, 2, 8, 8, 8, 0, 3, 1, 2, 2, 6, 2, 3, 1, 2, 6, 1, 9, ...], 15225220},

     

       136
       136
       +
         {[2, 1, 2, 4, 0, 6, 0, 8, 6, 5, 9, 5, 1, 7, 1, 3, 9, 3, 2, 8, 5, 4, 8, ...], 4484251},

     

       137
       137
       +
         {[1, 5, 9, 2, 0, 5, 7, 4, 6, 2, 3, 4, 7, 9, 9, 7, 9, 8, 3, 4, 2, 3, ...], 12505941},

     

       138
       138
       +
         {[3, 2, 8, 0, 7, 6, 7, 8, 6, 2, 0, 4, 7, 6, 2, 8, 2, 7, 3, 0, 3, ...], 12324709},

     

       139
       139
       +
         {[3, 6, 3, 2, 2, 5, 4, 5, 3, 2, 2, 8, 5, 8, 7, 6, 5, 9, 3, 0, ...], 12840916},

     

       140
       140
       +
         {[7, 4, 1, 3, 5, 7, 1, 9, 4, 8, 2, 0, 2, 6, 7, 1, 7, 8, 4, ...], 13939301},

     

       141
       141
       +
         {[0, 4, 4, 4, 6, 9, 8, 0, 2, 3, 9, 9, 4, 0, 6, 0, 4, 2, ...], 7392065},

     

       142
       142
       +
         {[7, 8, 0, 0, 4, 1, 6, 1, 5, 9, 0, 3, 1, 4, 5, 8, 9, ...], 13395486},

     

       143
       143
       +
         {[5, 5, 1, 7, 9, 8, 0, 1, 5, 5, 6, 2, 1, 6, 6, 5, ...], 14846825},

     

       144
       144
       +
         {[4, 1, 5, 9, 7, 1, 3, 6, 6, 5, 8, 9, 1, 0, 7, ...], 15647415},

     

       145
       145
       +
         {[5, 0, 0, 5, 4, 4, 9, 3, 4, 0, 4, 9, 0, 0, ...], 15491670},

     

       146
       146
       +
         {[5, 3, 1, 3, 6, 7, 3, 2, 8, 6, 2, 5, 0, ...], 12602693},

     

       147
       147
       +
         {[9, 6, 3, 2, 6, 3, 9, 6, 6, 5, 2, 6, ...], 16470307},

     

       148
       148
       +
         {[8, 4, 3, 6, 0, 4, 0, 8, 5, 5, 9, ...], 10819101},

     

       149
       149
       +
         {[0, 9, 4, 4, 6, 0, 2, 4, 0, 3, ...], 8658998},

     

       150
       150
       +
         {[0, 2, 8, 3, 0, 4, 5, 0, 5, ...], 11616760},

     

       151
       151
       +
         {[4, 8, 3, 5, 2, 8, 0, 8, ...], 4294043},

     

       152
       152
       +
         {[8, 1, 0, 8, 2, 1, 0, ...], 11210309},

     

       153
       153
       +
         {[5, 8, 6, 9, 6, 8, ...], 1113711},

     

       154
       154
       +
         {[1, 6, 5, 5, 4, ...], 16530315},

     

       155
       155
       +
         {[5, 1, 3, 9, ...], 8014000},

     

       156
       156
       +
         {[7, 4, 5, ...], 13932057},

     

       157
       157
       +
         {[8, 9, ...], 9987703},

     

       158
       158
       +
         {[4, ...], 10745797},

     

       159
       159
       +
         {[...], ...},

     

       160
       160
       +
         {...},

     

       161
       161
       +
         ...

     

       162
       162
       +
       ]

     

       163
       163
       +
       ```

     

       164
       164
       +
       

     

       165
       165
       +
       ## Part 1

     

       166
       166
       +
       

     

       167
       167
       +
       ```elixir

     

       168
       168
       +
       hashes

     

       169
       169
       +
       |> Enum.map(&elem(&1, 1))

     

       170
       170
       +
       |> Enum.sum()

     

       171
       171
       +
       ```

     

       172
       172
       +
       

     

       173
       173
       +
       <!-- livebook:{"output":true} -->

     

       174
       174
       +
       

     

       175
       175
       +
       ```

     

       176
       176
       +
       13461553007

     

       177
       177
       +
       ```

     

       178
       178
       +
       

     

       179
       179
       +
       ## Part 2

     

       180
       180
       +
       

     

       181
       181
       +
       ```elixir

     

       182
       182
       +
       hashes

     

       183
       183
       +
       |> Task.async_stream(

     

       184
       184
       +
         fn {prices, _} -> Buyer.sequences(prices) end,

     

       185
       185
       +
         ordered: false

     

       186
       186
       +
       )

     

       187
       187
       +
       |> Enum.reduce(%{}, fn {:ok, a}, b -> Map.merge(a, b, fn _k, v, k -> v + k end) end)

     

       188
       188
       +
       |> Enum.max_by(&elem(&1, 1))

     

       189
       189
       +
       |> elem(1)

     

       190
       190
       +
       ```

     

       191
       191
       +
       

     

       192
       192
       +
       <!-- livebook:{"output":true} -->

     

       193
       193
       +
       

     

       194
       194
       +
       ```

     

       195
       195
       +
       1499

     

       196
       196
       +
       ```

     

       197
       197
       +
       

     

       198
       198
       +
       <!-- livebook:{"offset":11738,"stamp":{"token":"XCP.GjkWCjlMBRZbt2b3Ic6te1lRoiRN-o788mezmoiandQKEk9mR1MC2aSWY6otgof8lHDa_afMMYYnBV9YHmLjoK0wooHF17OPyx6ruqV5hYpKoVBVZuhSx_gT8_2Ac2S73Pk","version":2}} -->

+203

2024/day23.livemd

···

       1
       1
       +
       <!-- livebook:{"persist_outputs":true} -->

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 23

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

       6
       6
       +
       Mix.install([:kino_aoc, {:libgraph, github: "bitwalker/libgraph"}, :combination])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIyMyIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI0In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       12
       12
       +
       

     

       13
       13
       +
       ```elixir

     

       14
       14
       +
       {:ok, puzzle_input} =

     

       15
       15
       +
         KinoAOC.download_puzzle("2024", "23", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       16
       16
       +
       ```

     

       17
       17
       +
       

     

       18
       18
       +
       <!-- livebook:{"output":true} -->

     

       19
       19
       +
       

     

       20
       20
       +
       ```

     

       21
       21
       +
       {:ok,

     

       22
       22
       +
        "on-za\nbp-hs\nvc-bg\ntm-us\nzf-ox\nib-lc\nuo-zs\nov-qj\nll-eb\niy-tq\nbg-by\nun-ix\ngi-do\nrv-ou\nyp-qu\nqb-um\nqs-dn\nru-ro\net-fw\nyx-jt\nns-iz\nod-rc\nny-ap\nvb-fd\nwf-wr\nyh-qy\nfa-ct\nqo-fv\nig-jv\nqi-ff\nnj-ii\nsa-gg\ncp-un\nez-kh\nvs-du\ngp-qs\npt-qj\nyp-my\njf-sz\nyo-gm\nfn-xw\niu-xr\nse-ox\nmw-ie\nfw-br\nxy-iu\nqw-wi\nxc-dq\nvb-cq\ntw-zj\nka-aq\ngo-ds\nvi-cn\npz-kz\npy-nd\npt-ws\nog-lw\nlb-hj\nef-ac\ncv-qa\nsq-jv\nfw-xk\nlu-fc\nbj-bp\nzh-fi\ntg-nm\nsp-at\nke-dh\nut-ly\ngr-vr\nko-qg\nxg-df\nrc-up\nbd-it\ngz-en\nqj-ev\nwf-dx\nxn-hi\npq-th\nkr-gw\ngu-sm\ncv-xr\nzq-fp\nep-kq\nfv-dx\nlc-rw\ney-ef\nek-rw\ntw-eg\nfc-zw\nxm-ho\ngj-oy\nhy-og\nec-tw\npy-hw\nqr-jh\nvh-ea\nvz-ja\nov-ev\nyh-vh\nyk-fc\nfm-yi\nyf-kx\ner-bi\nbi-qq\ngc-fk\nie-gf\njk-fn\nxl-il\nbs-dl\nsh-op\npy-vx\ncn-jl\ntl-ee\nxw-wn\nzv-br\nkr-yn\ndj-wd\nwj-bz\nhf-bg\nzh-ql\nbs-ls\ntq-jk\nmz-dz\nav-jr\ngj-dr\npo-iy\nof-aq\nun-fw\nnv-bx\njz-nl\nze-ae\nvd-df\nix-et\nrn-ik\ndz-ou\nmz-ej\nec-kx\nxr-cf\njt-vr\nix-fw\nes-er\nbv-no\nwj-df\nyv-cl\njd-xl\nlu-vo\nxo-td\nvq-ow\nlc-vm\nca-lf\noq-on\nwj-xg\nfn-rp\nka-np\nbx-ez\ndz-sz\nkt-xl\ndd-jd\nla-qn\nqe-pt\ngl-ly\nqj-cc\nat-rf\nke-om\ndc-hu\nqb-rr\nov-ku\ntq-xw\nfz-tn\nma-hi\nbr-yw\nno-sp\ndj-kn\nyn-gw\ngo-ir\nbz-xg\nwo-se\nrz-wa\nqy-sx\nqn-ym\npo-tq\nxr-jh\ndf-tn\noe-vi\nsw-el\nvm-vr\ntg-nf\ncg-zt\nwf-fl\ncd-nc\nsw-qa\nfo-jg\nhj-av\nwd-rn\nwc-wq\noq-vw\nkx-ux\nop-nq\nsm-ru\nch-fw\nqx-uy\nti-fw\nrp-qm\npo-tj\nse-nw\npj-rs\nbo-sn\nsy-ur\niy-jb\ntm-rz\ndg-jt\nfa-sq\nok-th\nzq-ps\nhr-kr\npz-zs\nwq-ze\nms-an\nnp-aq\ntl-ka\npw-dh\nbm-sz\nuu-gm\nft-vb\nau-ab\nlx-lw\ncp-ri\nep-xm\nry-hk\nyi-gf\ncj-qr\nfl-lu\nbv-za\nyw-xk\nne-ss\nln-wv\nwf-vo\nlx-jy\noy-xy\nkq-fa\neh-lv\nuq-mi\nis-mx\nwn-eo\nqr-xy\nlr-ms\nkt-jd\nyk-lu\nqe-cc\naj-si\nqq-bp\nlw-xa\nus-pp\nen-mq\nct-te\nod-db\ncp-br\nrg-ou\nev-ku\nqg-ec\nuv-np\njn-sw\nxj-ie\nqr-xr\ntr-zp\nha-gg\nrx-pz\nsa-fl\ngx-vz\nmg-oi\nyc-zn\nxw-jo\nae-ou\nhj-gn\nix-ri\nsq-ct\nwo-xr\nbl-wl\ntt-ac\nbs-ij\nmh-re\nhg-lv\nwu-fh\nrt-rq\nsn-vq\nzy-vh\nyh-zy\ntu-oz\nbk-ai\nds-gq\nss-ob\ndv-di\nvw-on\nxr-zb\nfr-jl\nro-om\nrk-mg\nyc-hi\nvv-nf\nkz-nt\nrt-qw\nzj-ux\nox-wv\nfz-dc\nya-xo\ngq-du\nmx-fk\nsi-mo\nmo-ef\ndb-ex\nhw-rc\njy-qd\noz-lb\nvi-cm\nvx-ec\nxr-aa\nnx-ni\nny-fv\nta-vc\nnq-yi\nzt-gp\nnd-iu\nvv-yd\nsh-gf\nyf-hm\ndq-ee\nbg-bt\nnc-kz\ngq-py\nek-sy\nty-le\njo-eo\ndy-ko\nxa-qd\nrm-ns\ngk-xp\ngz-jr\ncr-ez\nwr-fc\nhe-cg\nin-og\ndw-sh\nuk-bf\nbr-un\nok-gi\nch-gr\ncx-gz\ndv-ho\nbx-cr\nex-go\nik-nv\nkh-wb\nol-vk\nhg-bf\nod-du\nvj-qk\nyd-uj\nfu-lq\nbi-bj\nvl-il\ncd-ob\nax-us\nmw-nq\nvr-rw\nhx-uf\nwz-vb\nem-xe\nee-of\nhm-ec\nek-ds\nys-sy\nqq-jq\ngu-jg\nzc-oi\nji-yb\nou-kw\nep-lh\nid-nx\ngp-wp\nph-ns\ncn-io\nwn-tq\nrw-vm\nnx-fv\nce-gn\nvr-lt\nxl-dd\nzw-sa\nwr-ty\nkz-jx\njd-rx\nna-hk\nnc-ob\nnw-re\nwt-jq\naj-sw\nkc-bi\nwq-qx\njt-ib\ncb-ly\nuj-zp\ncy-ps\nsm-om\nbu-bd\nux-ko\nxa-hy\nbc-uq\nsi-sw\nyc-ma\nyk-sa\ngf-mw\nbp-eq\nfh-zh\nmn-bo\nbw-hj\nes-bj\nop-xj\nup-hh\nds-db\ngx-qu\nyo-fp\nwg-ls\net-zc\ndn-vw\nyb-bt\nsk-sb\nxe-ea\nni-ap\nhw-go\ndn-zc\nno-vw\npt-cc\nrv-wc\nwc-xq\njg-ke\noo-jg\ndo-ss\nie-nq\npq-is\nrf-oq\nzn-vb\neb-ef\ngp-rs\npt-pf\nmd-lb\nle-zw\nxn-tf\nui-cb\nbz-fz\npj-gp\nzr-ee\npp-ax\nkl-jq\nxc-of\nox-lr\nuy-rv\nvd-sb\nyy-bh\nvn-dq\ndt-hg\nnp-vn\nla-fh\ngw-eh\ncq-wz\nno-ia\nqj-ws\npl-pt\ndf-ge\nzq-vj\njg-om\nnq-sh\nzy-kr\npv-im\naq-vn\nsq-yx\nsb-df\nih-gx\ngn-av\ndc-ff\nwg-ph\nsm-fo\nux-dk\ngi-kv\nhr-dt\nrc-go\nax-tm\npp-bo\nnn-xe\njf-mz\nvl-jd\nfs-cl\ngz-gn\nui-ly\nrx-hy\nrn-dj\nqe-pf\njx-gy\ntr-qb\neu-lr\nyt-ih\ntr-oi\nnc-ss\nnh-pb\nir-nd\nel-qf\ntl-aq\nkj-es\nru-fo\nfw-bu\nps-qk\nlq-lx\ncm-fg\nel-si\nvs-hw\neg-ux\nmt-lh\ntt-yy\njz-sq\nfm-nq\nvx-ko\nbl-lx\nrc-ex\nby-ji\neq-kl\ntk-vd\nmo-qf\nzr-xd\nbt-vc\nux-mi\nha-us\nvr-ib\nhx-rq\nat-no\nui-tx\nvs-od\nfp-ay\nzj-kx\nvs-ds\nqo-vk\nhw-db\npf-ku\nmd-jr\nfp-fe\nyg-tx\nmz-gs\nnl-ct\ncn-oe\nxj-ri\nya-ku\nnw-mh\nvh-ff\nft-hz\nen-md\nps-fp\naf-rx\nvx-kx\nkv-fd\nkr-lf\nae-rg\nsp-vw\nvn-zr\nea-pi\nat-vw\nrw-ax\nkg-vh\nxy-cv\nca-gw\nem-nn\nhj-en\ngw-ra\nfr-cy\ned-wu\nyf-tw\nuo-lz\ngc-pq\ntw-ux\nqy-kg\ncx-fo\nit-ly\nuj-mg\nrp-po\nsq-yv\nzh-zs\nth-ne\nes-fe\nrn-nv\naa-gj\nzb-aa\nwt-kl\nwu-uo\nbb-ce\nby-bt\nqb-gv\nbp-es\nbd-tx\nma-cq\nyt-qu\nuu-mn\nke-fa\nmx-jn\ndq-ew\nax-ow\nhv-dx\nyh-sx\ngx-ry\njz-jv\nsb-wj\ndo-ok\ngj-qn\nbr-ri\nlu-zw\nsb-ge\nkg-ao\nuu-fp\nus-xh\ndd-jb\nxp-wi\ncf-cj\nhm-zj\nle-sa\nwf-ty\nqx-xq\noi-rr\nbl-og\nmq-hj\ndw-xi\naw-ap\nsk-cs\nwu-yq\ngm-zq\nna-ry\nwp-pj\nne-gy\ndt-yn\nau-bm\nrk-ur\nnm-oi\naf-zm\ncd-ss\ndj-ez\ncf-oy\nce-md\nth-kz\nnt-cd\nrm-iz\njz-fs\nni-qo\njx-do\nzy-xe\nls-uq\nsy-jt\nwa-xh\nlf-lv\nys-jt\nij-wg\njw-mw\nbk-ef\nyx-ek\nvr-cm\njv-sk\ndw-ej\nmo-pq\nov-pl\nfz-ge\nmt-ep\ncq-hz\nza-zc\nlj-uy\nrv-ae\nse-ln\nkw-ze\nwo-ln\nvo-zw\nwd-fd\nxo-pl\nmx-gc\nln-lr\nsy-rw\ngy-fs\nzy-ea\nkc-er\nfl-l" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       connections =

     

       27
       27
       +
         puzzle_input

     

       28
       28
       +
         |> String.split("\n", trim: true)

     

       29
       29
       +
         |> Enum.map(fn <<a::binary-2, "-", b::binary-2>> ->

     

       30
       30
       +
           {a, b}

     

       31
       31
       +
         end)

     

       32
       32
       +
       ```

     

       33
       33
       +
       

     

       34
       34
       +
       <!-- livebook:{"output":true} -->

     

       35
       35
       +
       

     

       36
       36
       +
       ```

     

       37
       37
       +
       [

     

       38
       38
       +
         {"on", "za"},

     

       39
       39
       +
         {"bp", "hs"},

     

       40
       40
       +
         {"vc", "bg"},

     

       41
       41
       +
         {"tm", "us"},

     

       42
       42
       +
         {"zf", "ox"},

     

       43
       43
       +
         {"ib", "lc"},

     

       44
       44
       +
         {"uo", "zs"},

     

       45
       45
       +
         {"ov", "qj"},

     

       46
       46
       +
         {"ll", "eb"},

     

       47
       47
       +
         {"iy", "tq"},

     

       48
       48
       +
         {"bg", "by"},

     

       49
       49
       +
         {"un", "ix"},

     

       50
       50
       +
         {"gi", "do"},

     

       51
       51
       +
         {"rv", "ou"},

     

       52
       52
       +
         {"yp", "qu"},

     

       53
       53
       +
         {"qb", "um"},

     

       54
       54
       +
         {"qs", "dn"},

     

       55
       55
       +
         {"ru", "ro"},

     

       56
       56
       +
         {"et", "fw"},

     

       57
       57
       +
         {"yx", "jt"},

     

       58
       58
       +
         {"ns", "iz"},

     

       59
       59
       +
         {"od", "rc"},

     

       60
       60
       +
         {"ny", "ap"},

     

       61
       61
       +
         {"vb", "fd"},

     

       62
       62
       +
         {"wf", "wr"},

     

       63
       63
       +
         {"yh", "qy"},

     

       64
       64
       +
         {"fa", "ct"},

     

       65
       65
       +
         {"qo", "fv"},

     

       66
       66
       +
         {"ig", "jv"},

     

       67
       67
       +
         {"qi", "ff"},

     

       68
       68
       +
         {"nj", "ii"},

     

       69
       69
       +
         {"sa", "gg"},

     

       70
       70
       +
         {"cp", "un"},

     

       71
       71
       +
         {"ez", "kh"},

     

       72
       72
       +
         {"vs", "du"},

     

       73
       73
       +
         {"gp", "qs"},

     

       74
       74
       +
         {"pt", "qj"},

     

       75
       75
       +
         {"yp", "my"},

     

       76
       76
       +
         {"jf", "sz"},

     

       77
       77
       +
         {"yo", "gm"},

     

       78
       78
       +
         {"fn", "xw"},

     

       79
       79
       +
         {"iu", "xr"},

     

       80
       80
       +
         {"se", "ox"},

     

       81
       81
       +
         {"mw", "ie"},

     

       82
       82
       +
         {"fw", "br"},

     

       83
       83
       +
         {"xy", "iu"},

     

       84
       84
       +
         {"qw", "wi"},

     

       85
       85
       +
         {"xc", "dq"},

     

       86
       86
       +
         {"vb", ...},

     

       87
       87
       +
         {...},

     

       88
       88
       +
         ...

     

       89
       89
       +
       ]

     

       90
       90
       +
       ```

     

       91
       91
       +
       

     

       92
       92
       +
       ```elixir

     

       93
       93
       +
       party =

     

       94
       94
       +
         Graph.new(type: :undirected)

     

       95
       95
       +
         |> Graph.add_edges(connections)

     

       96
       96
       +
       ```

     

       97
       97
       +
       

     

       98
       98
       +
       <!-- livebook:{"output":true} -->

     

       99
       99
       +
       

     

       100
       100
       +
       ```

     

       101
       101
       +
       #Graph<type: undirected, num_vertices: 520, num_edges: 3380>

     

       102
       102
       +
       ```

     

       103
       103
       +
       

     

       104
       104
       +
       ```elixir

     

       105
       105
       +
       cliques = Graph.cliques(party)

     

       106
       106
       +
       ```

     

       107
       107
       +
       

     

       108
       108
       +
       <!-- livebook:{"output":true} -->

     

       109
       109
       +
       

     

       110
       110
       +
       ```

     

       111
       111
       +
       [

     

       112
       112
       +
         ["yf", "dk", "dy", "hm", "vx", "zj", "ec", "eg", "ko", "kx", "tw", "ux"],

     

       113
       113
       +
         ["yf", "dk", "hm", "vx", "zj", "ec", "eg", "qg", "ko", "kx", "tw", "ux"],

     

       114
       114
       +
         ["yf", "ob"],

     

       115
       115
       +
         ["xa", "wl", "lx", "lq", "jy", "in", "hy", "lw", "qd", "fu", "ub", "og"],

     

       116
       116
       +
         ["xa", "wl", "lx", "jy", "bl", "in", "hy", "lw", "qd", "fu", "ub", "og"],

     

       117
       117
       +
         ["xa", "wi"],

     

       118
       118
       +
         ["bd", "cb", "it", "ut", "fq", "hs", "ur", "ly", "tx", "yg", "ui", "gl"],

     

       119
       119
       +
         ["bd", "cb", "it", "ut", "fq", "ur", "ly", "tx", "yg", "ui", "gl", "rk"],

     

       120
       120
       +
         ["bd", "bu"],

     

       121
       121
       +
         ["nm", "qb", "gv", "nf", "oi", "tg", "uj", "yd", "rr", "tr", "vv", "mg"],

     

       122
       122
       +
         ["nm", "qb", "gv", "nf", "oi", "tg", "uj", "yd", "rr", "tr", "vv", "zp"],

     

       123
       123
       +
         ["nm", "ge"],

     

       124
       124
       +
         ["dk", "jn"],

     

       125
       125
       +
         ["cn", "lh", "di", "xm", "cm", "oe", "vi", "ho", "fg", "mt", "io", "dv"],

     

       126
       126
       +
         ["cn", "zt"],

     

       127
       127
       +
         ["cn", "jl"],

     

       128
       128
       +
         ["qp", "xd"],

     

       129
       129
       +
         ["qp", "zq", "qk", "uu", "cy", "fp", "ay", "yo", "gm", "vj", "ps", "fr"],

     

       130
       130
       +
         ["qp", "zq", "qk", "uu", "cy", "ay", "yo", "gm", "vj", "jl", "ps", "fr"],

     

       131
       131
       +
         ["xq", "qx", "rg", "wc", "um", "rv", "ae", "kw", "lj", "ze", "wq", "ou"],

     

       132
       132
       +
         ["xq", "kg"],

     

       133
       133
       +
         ["xq", "qo"],

     

       134
       134
       +
         ["ti", "et", "bu", "xk", "ix", "fw", "un", "ri", "cp", "br", "gr", "ch"],

     

       135
       135
       +
         ["ti", "et", "bu", "xk", "fw", "un", "ri", "cp", "br", "gr", "ch", "yw"],

     

       136
       136
       +
         ["ti", "ab"],

     

       137
       137
       +
         ["nh", "hv", "id", "ap", "fv", "ny", "pb", "ni", "aw", "nx", "vk", "qo"],

     

       138
       138
       +
         ["nh", "pj"],

     

       139
       139
       +
         ["nh", "lk"],

     

       140
       140
       +
         ["ys", "ib", "dg", "vr", "yx", "jt", "ek", "lt", "sy", "vm", "lc", "rw"],

     

       141
       141
       +
         ["ys", "ib", "dg", "yx", "jt", "pg", "ek", "lt", "sy", "vm", "lc", "rw"],

     

       142
       142
       +
         ["ys", "tl"],

     

       143
       143
       +
         ["cb", "ha"],

     

       144
       144
       +
         ["ue", "dd", "kd", "zm", "kt", "il", "af", "xx", "vl", "xl", "jd", "rx"],

     

       145
       145
       +
         ["ue", "dd", "kd", "kt", "il", "af", "xx", "vl", "xl", "jd", "rx", "pz"],

     

       146
       146
       +
         ["ue", "bh"],

     

       147
       147
       +
         ["jg", "cx", "fo", "ro", "ru", "oo", "dh", "as", "zx", "ke", "om", "gu"],

     

       148
       148
       +
         ["jg", "cx", "fo", "ro", "ru", "dh", "as", "sm", "zx", "ke", "om", "gu"],

     

       149
       149
       +
         ["jg", "cy"],

     

       150
       150
       +
         ["bz", "fz", "qi", "tn", "xg", "dc", "ge", "sb", "df", "hu", "vd", ...],

     

       151
       151
       +
         ["bz", "ae"],

     

       152
       152
       +
         ["bz", "gm"],

     

       153
       153
       +
         ["im", "dz", "ab", "sz", "ej", "mz", "pv", "rj", ...],

     

       154
       154
       +
         ["im", "dz", "sz", "ej", "mz", "pv", "rj", ...],

     

       155
       155
       +
         ["im", "ps"],

     

       156
       156
       +
         ["sw", "gc", "si", "aj", "is", ...],

     

       157
       157
       +
         ["sw", "gc", "si", "aj", ...],

     

       158
       158
       +
         ["sw", "fn"],

     

       159
       159
       +
         ["cg", "zt", ...],

     

       160
       160
       +
         ["cg", ...],

     

       161
       161
       +
         [...],

     

       162
       162
       +
         ...

     

       163
       163
       +
       ]

     

       164
       164
       +
       ```

     

       165
       165
       +
       

     

       166
       166
       +
       ## Part 1

     

       167
       167
       +
       

     

       168
       168
       +
       ```elixir

     

       169
       169
       +
       cliques

     

       170
       170
       +
       |> Stream.flat_map(fn clique ->

     

       171
       171
       +
         if length(clique) >= 3 do

     

       172
       172
       +
           Combination.combine(clique, 3)

     

       173
       173
       +
         else

     

       174
       174
       +
           []

     

       175
       175
       +
         end

     

       176
       176
       +
       end)

     

       177
       177
       +
       |> Stream.filter(fn clique -> Enum.any?(clique, &String.starts_with?(&1, "t")) end)

     

       178
       178
       +
       |> MapSet.new()

     

       179
       179
       +
       |> MapSet.size()

     

       180
       180
       +
       ```

     

       181
       181
       +
       

     

       182
       182
       +
       <!-- livebook:{"output":true} -->

     

       183
       183
       +
       

     

       184
       184
       +
       ```

     

       185
       185
       +
       1248

     

       186
       186
       +
       ```

     

       187
       187
       +
       

     

       188
       188
       +
       ## Part 2

     

       189
       189
       +
       

     

       190
       190
       +
       ```elixir

     

       191
       191
       +
       cliques

     

       192
       192
       +
       |> Enum.max_by(&length/1)

     

       193
       193
       +
       |> Enum.sort()

     

       194
       194
       +
       |> Enum.join(",")

     

       195
       195
       +
       ```

     

       196
       196
       +
       

     

       197
       197
       +
       <!-- livebook:{"output":true} -->

     

       198
       198
       +
       

     

       199
       199
       +
       ```

     

       200
       200
       +
       "aa,cf,cj,cv,dr,gj,iu,jh,oy,qr,xr,xy,zb"

     

       201
       201
       +
       ```

     

       202
       202
       +
       

     

       203
       203
       +
       <!-- livebook:{"offset":9387,"stamp":{"token":"XCP.YMMjV81j86GOTx0hGVW-U0w7aqvuBdig59tmj2pqELbNIP0HXjbZA1WSQwLRMCUIuzZ1PLs6_0ehAVdgp7sj4Wuc6QaM8KCZ3j-zJrTUmr2_hxaACLOnkijsz6m2hIS8E6Q","version":2}} -->

+67

2025/day01.livemd

···

       1
       1
       +
       # Day 01

     

       2
       2
       +
       

     

       3
       3
       +
       ```elixir

     

       4
       4
       +
       Mix.install([:kino_aoc])

     

       5
       5
       +
       ```

     

       6
       6
       +
       

     

       7
       7
       +
       ## Setup

     

       8
       8
       +
       

     

       9
       9
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIxIiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjUifQ","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       10
       10
       +
       

     

       11
       11
       +
       ```elixir

     

       12
       12
       +
       {:ok, puzzle_input} =

     

       13
       13
       +
         KinoAOC.download_puzzle("2025", "1", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       14
       14
       +
       ```

     

       15
       15
       +
       

     

       16
       16
       +
       ```elixir

     

       17
       17
       +
       instructions =

     

       18
       18
       +
         puzzle_input

     

       19
       19
       +
         |> String.split("\n", trim: true)

     

       20
       20
       +
         |> Enum.map(fn <<dir>> <> rest ->

     

       21
       21
       +
           num = String.to_integer(rest)

     

       22
       22
       +
       

     

       23
       23
       +
           if dir == ?R do

     

       24
       24
       +
             {div(num, 100), rem(num, 100)}

     

       25
       25
       +
           else

     

       26
       26
       +
             {div(num, 100), -rem(num, 100)}

     

       27
       27
       +
           end

     

       28
       28
       +
         end)

     

       29
       29
       +
       ```

     

       30
       30
       +
       

     

       31
       31
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       32
       32
       +
       

     

       33
       33
       +
       ## Part 1

     

       34
       34
       +
       

     

       35
       35
       +
       ```elixir

     

       36
       36
       +
       Enum.scan(instructions, 50, fn {_rot, val}, curr ->

     

       37
       37
       +
         Integer.mod(curr + val, 100)

     

       38
       38
       +
       end)

     

       39
       39
       +
       |> Enum.count(& &1 == 0)

     

       40
       40
       +
       ```

     

       41
       41
       +
       

     

       42
       42
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       43
       43
       +
       

     

       44
       44
       +
       ## Part 2

     

       45
       45
       +
       

     

       46
       46
       +
       ```elixir

     

       47
       47
       +
       <<0x434C49434B::40>>

     

       48
       48
       +
       ```

     

       49
       49
       +
       

     

       50
       50
       +
       ```elixir

     

       51
       51
       +
       Enum.reduce(instructions, {50, 0}, fn {rot, val}, {curr, sum} ->

     

       52
       52
       +
         next = curr + val

     

       53
       53
       +
       

     

       54
       54
       +
         pass =

     

       55
       55
       +
           cond do

     

       56
       56
       +
             curr == 0 and next < 0 -> 0

     

       57
       57
       +
             next not in 0..99 -> 1

     

       58
       58
       +
             rem(next, 100) == 0 -> 1

     

       59
       59
       +
             true -> 0

     

       60
       60
       +
           end

     

       61
       61
       +
       

     

       62
       62
       +
         {Integer.mod(next, 100), sum + pass + rot}

     

       63
       63
       +
       end)

     

       64
       64
       +
       |> elem(1)

     

       65
       65
       +
       ```

     

       66
       66
       +
       

     

       67
       67
       +
       <!-- livebook:{"offset":1270,"stamp":{"token":"XCP.fAfBqYepop325WQHLC6mJPz_Wpl7bDiz0qRbslvjG31mRJWcHALfstxgj_iOj3nf9_GCzh_WmPiNR4MnzZidF2bz_zMMXHTEo18hp1z3gQDdi5hTSO8UG4YSYnUEtGxO2g","version":2}} -->

+85

2025/day02.livemd

···

       1
       1
       +
       # Day 02

     

       2
       2
       +
       

     

       3
       3
       +
       ```elixir

     

       4
       4
       +
       Mix.install([:kino_aoc])

     

       5
       5
       +
       ```

     

       6
       6
       +
       

     

       7
       7
       +
       ## Parsing

     

       8
       8
       +
       

     

       9
       9
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIyIiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjUifQ","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       10
       10
       +
       

     

       11
       11
       +
       ```elixir

     

       12
       12
       +
       {:ok, puzzle_input} =

     

       13
       13
       +
         KinoAOC.download_puzzle("2025", "2", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       14
       14
       +
       ```

     

       15
       15
       +
       

     

       16
       16
       +
       ```elixir

     

       17
       17
       +
       ranges =

     

       18
       18
       +
         puzzle_input

     

       19
       19
       +
         |> String.trim()

     

       20
       20
       +
         |> String.split(",")

     

       21
       21
       +
         |> Enum.map(fn range ->

     

       22
       22
       +
           range

     

       23
       23
       +
           |> String.split("-")

     

       24
       24
       +
           |> Enum.map(&String.to_integer/1)

     

       25
       25
       +
           |> then(&apply(Range, :new, &1))

     

       26
       26
       +
         end)

     

       27
       27
       +
       |> Enum.sort_by(& &1.last)

     

       28
       28
       +
       ```

     

       29
       29
       +
       

     

       30
       30
       +
       ## Implementation

     

       31
       31
       +
       

     

       32
       32
       +
       ```elixir

     

       33
       33
       +
       defmodule ElfRanges do

     

       34
       34
       +
         def valid?(num) do

     

       35
       35
       +
           len = floor(:math.log10(num)) + 1

     

       36
       36
       +
       

     

       37
       37
       +
           valid_n?(num, len, 2)

     

       38
       38
       +
         end

     

       39
       39
       +
       

     

       40
       40
       +
         def valid_any?(num) do

     

       41
       41
       +
           len = floor(:math.log10(num)) + 1

     

       42
       42
       +
       

     

       43
       43
       +
           Enum.all?(2..len//1, &valid_n?(num, len, &1))

     

       44
       44
       +
         end

     

       45
       45
       +
       

     

       46
       46
       +
         def valid_n?(num, len, n) do

     

       47
       47
       +
           if rem(len, n) == 0 do

     

       48
       48
       +
             step = 10 ** div(len, n)

     

       49
       49
       +
       

     

       50
       50
       +
             Stream.unfold(num, fn

     

       51
       51
       +
               0 -> nil

     

       52
       52
       +
               val -> {rem(val, step), div(val, step)}

     

       53
       53
       +
             end)

     

       54
       54
       +
             |> Enum.dedup()

     

       55
       55
       +
             |> then(&(not match?([_], &1)))

     

       56
       56
       +
           else

     

       57
       57
       +
             true

     

       58
       58
       +
           end

     

       59
       59
       +
         end

     

       60
       60
       +
       end

     

       61
       61
       +
       ```

     

       62
       62
       +
       

     

       63
       63
       +
       <!-- livebook:{"branch_parent_index":1} -->

     

       64
       64
       +
       

     

       65
       65
       +
       ## Part 1

     

       66
       66
       +
       

     

       67
       67
       +
       ```elixir

     

       68
       68
       +
       ranges

     

       69
       69
       +
       |> Stream.flat_map(& &1)

     

       70
       70
       +
       |> Stream.reject(&ElfRanges.valid?/1)

     

       71
       71
       +
       |> Enum.sum()

     

       72
       72
       +
       ```

     

       73
       73
       +
       

     

       74
       74
       +
       <!-- livebook:{"branch_parent_index":1} -->

     

       75
       75
       +
       

     

       76
       76
       +
       ## Part 2

     

       77
       77
       +
       

     

       78
       78
       +
       ```elixir

     

       79
       79
       +
       ranges

     

       80
       80
       +
       |> Stream.flat_map(& &1)

     

       81
       81
       +
       |> Stream.reject(&ElfRanges.valid_any?/1)

     

       82
       82
       +
       |> Enum.sum()

     

       83
       83
       +
       ```

     

       84
       84
       +
       

     

       85
       85
       +
       <!-- livebook:{"offset":1551,"stamp":{"token":"XCP.GvC7N5ZC0xuQ3hRuVxd-rh5rJDKVZKJfmwspDkAuCFbjn8qdOUksP9Iy1GRtd7t5yLCV6nkfhXZlp_lTw8eZZBcwItn6IlML-jrjiORJQvkuXOHvzlOY17rIAaASRKvS3w","version":2}} -->

+56

2025/day03.livemd

···

       1
       1
       +
       # Day 03

     

       2
       2
       +
       

     

       3
       3
       +
       ```elixir

     

       4
       4
       +
       Mix.install([:kino_aoc])

     

       5
       5
       +
       ```

     

       6
       6
       +
       

     

       7
       7
       +
       ## Parse

     

       8
       8
       +
       

     

       9
       9
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIzIiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjUifQ","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       10
       10
       +
       

     

       11
       11
       +
       ```elixir

     

       12
       12
       +
       {:ok, puzzle_input} =

     

       13
       13
       +
         KinoAOC.download_puzzle("2025", "3", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       14
       14
       +
       ```

     

       15
       15
       +
       

     

       16
       16
       +
       ```elixir

     

       17
       17
       +
       batteries =

     

       18
       18
       +
         puzzle_input

     

       19
       19
       +
         |> String.split("\n", trim: true)

     

       20
       20
       +
         |> Enum.map(fn row ->

     

       21
       21
       +
           row

     

       22
       22
       +
           |> String.to_charlist()

     

       23
       23
       +
           |> Enum.map(& &1 - ?0)

     

       24
       24
       +
         end)

     

       25
       25
       +
       ```

     

       26
       26
       +
       

     

       27
       27
       +
       ```elixir

     

       28
       28
       +
       defmodule Joltage do

     

       29
       29
       +
         def make_largest(list, n) do

     

       30
       30
       +
           to_remove = length(list) - n

     

       31
       31
       +
           Enum.reduce(1..to_remove, list, fn _, acc -> make_larger(acc) end)

     

       32
       32
       +
         end

     

       33
       33
       +
         

     

       34
       34
       +
         def make_larger([_]), do: []

     

       35
       35
       +
         def make_larger([a, b | rest]) when a < b, do: [b | rest]

     

       36
       36
       +
         def make_larger([b | rest]), do: [b | make_larger(rest)]

     

       37
       37
       +
       end

     

       38
       38
       +
       ```

     

       39
       39
       +
       

     

       40
       40
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       41
       41
       +
       

     

       42
       42
       +
       ## Part 1

     

       43
       43
       +
       

     

       44
       44
       +
       ```elixir

     

       45
       45
       +
       Enum.sum_by(batteries, &Integer.undigits(Joltage.make_largest(&1, 2)))

     

       46
       46
       +
       ```

     

       47
       47
       +
       

     

       48
       48
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       49
       49
       +
       

     

       50
       50
       +
       ## Part 2

     

       51
       51
       +
       

     

       52
       52
       +
       ```elixir

     

       53
       53
       +
       Enum.sum_by(batteries, &Integer.undigits(Joltage.make_largest(&1, 12)))

     

       54
       54
       +
       ```

     

       55
       55
       +
       

     

       56
       56
       +
       <!-- livebook:{"offset":1212,"stamp":{"token":"XCP.fo1ohV8LylIz8VmOAj7rlJ4Jn5KPGtiiFfsDRmp0pFSXCESjhfmQ11wOwEVmq9HM-Zn8fozQDsOoJbfgbM5LJPVE9c0pw2tYKbteOOGNqHI3PTIkuBnv8ZPW6oYwWAZy4A","version":2}} -->

+82

2025/day04.livemd

···

       1
       1
       +
       # Day 04

     

       2
       2
       +
       

     

       3
       3
       +
       ```elixir

     

       4
       4
       +
       Mix.install([:kino_aoc])

     

       5
       5
       +
       ```

     

       6
       6
       +
       

     

       7
       7
       +
       ## Parse

     

       8
       8
       +
       

     

       9
       9
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiI0Iiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjUifQ","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       10
       10
       +
       

     

       11
       11
       +
       ```elixir

     

       12
       12
       +
       {:ok, puzzle_input} =

     

       13
       13
       +
         KinoAOC.download_puzzle("2025", "4", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       14
       14
       +
       ```

     

       15
       15
       +
       

     

       16
       16
       +
       ```elixir

     

       17
       17
       +
       rolls =

     

       18
       18
       +
         puzzle_input

     

       19
       19
       +
         |> String.split("\n", trim: true)

     

       20
       20
       +
         |> Enum.with_index()

     

       21
       21
       +
         |> Enum.flat_map(fn {line, row} ->

     

       22
       22
       +
           line

     

       23
       23
       +
           |> String.to_charlist()

     

       24
       24
       +
           |> Enum.with_index()

     

       25
       25
       +
           |> Enum.filter(&(elem(&1, 0) == ?@))

     

       26
       26
       +
           |> Enum.map(&{elem(&1, 1), row})

     

       27
       27
       +
         end)

     

       28
       28
       +
         |> MapSet.new()

     

       29
       29
       +
       ```

     

       30
       30
       +
       

     

       31
       31
       +
       ## Implementation

     

       32
       32
       +
       

     

       33
       33
       +
       ```elixir

     

       34
       34
       +
       defmodule PaperRolls do

     

       35
       35
       +
         defp adjacent({x, y}) do

     

       36
       36
       +
           for dx <- -1..1,

     

       37
       37
       +
               dy <- -1..1,

     

       38
       38
       +
               {dx, dy} != {0, 0},

     

       39
       39
       +
               do: {x + dx, y + dy}

     

       40
       40
       +
         end

     

       41
       41
       +
       

     

       42
       42
       +
         def movable?(pos, map) do

     

       43
       43
       +
           pos

     

       44
       44
       +
           |> adjacent()

     

       45
       45
       +
           |> Enum.count(&(&1 in map))

     

       46
       46
       +
           |> then(&(&1 < 4))

     

       47
       47
       +
         end

     

       48
       48
       +
       end

     

       49
       49
       +
       ```

     

       50
       50
       +
       

     

       51
       51
       +
       <!-- livebook:{"branch_parent_index":1} -->

     

       52
       52
       +
       

     

       53
       53
       +
       ## Part 1

     

       54
       54
       +
       

     

       55
       55
       +
       ```elixir

     

       56
       56
       +
       Enum.count(rolls, &PaperRolls.movable?(&1, rolls))

     

       57
       57
       +
       ```

     

       58
       58
       +
       

     

       59
       59
       +
       <!-- livebook:{"branch_parent_index":1} -->

     

       60
       60
       +
       

     

       61
       61
       +
       ## Part 2

     

       62
       62
       +
       

     

       63
       63
       +
       ```elixir

     

       64
       64
       +
       cleaned =

     

       65
       65
       +
         Stream.repeatedly(fn -> [] end)

     

       66
       66
       +
         |> Enum.reduce_while(rolls, fn _, acc ->

     

       67
       67
       +
           removable =

     

       68
       68
       +
             Enum.filter(acc, &PaperRolls.movable?(&1, acc))

     

       69
       69
       +
             |> MapSet.new()

     

       70
       70
       +
       

     

       71
       71
       +
           case MapSet.difference(acc, removable) do

     

       72
       72
       +
             ^acc -> {:halt, acc}

     

       73
       73
       +
             remaining -> {:cont, remaining}

     

       74
       74
       +
           end

     

       75
       75
       +
         end)

     

       76
       76
       +
       ```

     

       77
       77
       +
       

     

       78
       78
       +
       ```elixir

     

       79
       79
       +
       MapSet.size(rolls) - MapSet.size(cleaned)

     

       80
       80
       +
       ```

     

       81
       81
       +
       

     

       82
       82
       +
       <!-- livebook:{"offset":1586,"stamp":{"token":"XCP.-_kcJR24r3dthl7SnpOh24JBI5hDpqMlFjQQDQ0pxtv4UHyaTlGoG4rG5iZxKtgxQoNAxw0K-mowSwehidDfrqewK3r9FHoOcAOIDbOMFd3QGH2X2Ta6KeXd4PlzWSYDBw","version":2}} -->

+54

2025/day05.livemd

···

       1
       1
       +
       # Day 05

     

       2
       2
       +
       

     

       3
       3
       +
       ```elixir

     

       4
       4
       +
       Mix.install([

     

       5
       5
       +
         :kino_aoc,

     

       6
       6
       +
         :range_set

     

       7
       7
       +
       ])

     

       8
       8
       +
       ```

     

       9
       9
       +
       

     

       10
       10
       +
       ## Parse

     

       11
       11
       +
       

     

       12
       12
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiI1Iiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjUifQ","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       13
       13
       +
       

     

       14
       14
       +
       ```elixir

     

       15
       15
       +
       {:ok, puzzle_input} =

     

       16
       16
       +
         KinoAOC.download_puzzle("2025", "5", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       17
       17
       +
       ```

     

       18
       18
       +
       

     

       19
       19
       +
       ```elixir

     

       20
       20
       +
       [fresh, ingridients] = String.split(puzzle_input, "\n\n")

     

       21
       21
       +
       

     

       22
       22
       +
       fresh =

     

       23
       23
       +
         fresh

     

       24
       24
       +
         |> String.split()

     

       25
       25
       +
         |> Enum.map(fn range ->

     

       26
       26
       +
           [a, b] = range |> String.split("-") |> Enum.map(&String.to_integer/1)

     

       27
       27
       +
       

     

       28
       28
       +
           a..b//1

     

       29
       29
       +
         end)

     

       30
       30
       +
         |> RangeSet.new()

     

       31
       31
       +
       

     

       32
       32
       +
       ingridients =

     

       33
       33
       +
         ingridients

     

       34
       34
       +
         |> String.split()

     

       35
       35
       +
         |> Enum.map(&String.to_integer/1)

     

       36
       36
       +
       ```

     

       37
       37
       +
       

     

       38
       38
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       39
       39
       +
       

     

       40
       40
       +
       ## Part 1

     

       41
       41
       +
       

     

       42
       42
       +
       ```elixir

     

       43
       43
       +
       Enum.count(ingridients, & &1 in fresh)

     

       44
       44
       +
       ```

     

       45
       45
       +
       

     

       46
       46
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       47
       47
       +
       

     

       48
       48
       +
       ## Part 2

     

       49
       49
       +
       

     

       50
       50
       +
       ```elixir

     

       51
       51
       +
       Enum.count(fresh)

     

       52
       52
       +
       ```

     

       53
       53
       +
       

     

       54
       54
       +
       <!-- livebook:{"offset":973,"stamp":{"token":"XCP.GHEtbWlG6LHz6I0d5Y_d4738EDILulvQyP1NtPISLeYWo9atG0Ailm43-eswn0JGS5h2z5Yxb8Xi8nGJLqUkj41eqpnT_u7NxVCT4ceeKMBsd5R-EuxBw0P7vLlBab68MA","version":2}} -->

+68

2025/day06.livemd

···

       1
       1
       +
       # Day 06

     

       2
       2
       +
       

     

       3
       3
       +
       ```elixir

     

       4
       4
       +
       Mix.install([:kino_aoc])

     

       5
       5
       +
       ```

     

       6
       6
       +
       

     

       7
       7
       +
       ## Setup

     

       8
       8
       +
       

     

       9
       9
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiI2Iiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjUifQ","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       10
       10
       +
       

     

       11
       11
       +
       ```elixir

     

       12
       12
       +
       {:ok, puzzle_input} =

     

       13
       13
       +
         KinoAOC.download_puzzle("2025", "6", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       14
       14
       +
       ```

     

       15
       15
       +
       

     

       16
       16
       +
       ```elixir

     

       17
       17
       +
       {tasks, [ops]} =

     

       18
       18
       +
         puzzle_input

     

       19
       19
       +
         |> String.split("\n", trim: true)

     

       20
       20
       +
         |> Enum.split(-1)

     

       21
       21
       +
       ```

     

       22
       22
       +
       

     

       23
       23
       +
       ```elixir

     

       24
       24
       +
       ops =

     

       25
       25
       +
         ops

     

       26
       26
       +
         |> String.split()

     

       27
       27
       +
         |> Enum.map(&String.to_atom/1)

     

       28
       28
       +
       ```

     

       29
       29
       +
       

     

       30
       30
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       31
       31
       +
       

     

       32
       32
       +
       ## Part 1

     

       33
       33
       +
       

     

       34
       34
       +
       ```elixir

     

       35
       35
       +
       tasks

     

       36
       36
       +
       |> Enum.map(&String.split/1)

     

       37
       37
       +
       |> Enum.zip_with(fn numbers -> Enum.map(numbers, &String.to_integer/1) end)

     

       38
       38
       +
       |> Enum.zip(ops)

     

       39
       39
       +
       |> Enum.sum_by(fn

     

       40
       40
       +
         {nums, :+} -> Enum.sum(nums)

     

       41
       41
       +
         {nums, :*} -> Enum.product(nums)

     

       42
       42
       +
       end)

     

       43
       43
       +
       ```

     

       44
       44
       +
       

     

       45
       45
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       46
       46
       +
       

     

       47
       47
       +
       ## Part 2

     

       48
       48
       +
       

     

       49
       49
       +
       ```elixir

     

       50
       50
       +
       tasks

     

       51
       51
       +
       |> Enum.map(&String.to_charlist/1)

     

       52
       52
       +
       |> Enum.zip_with(&(&1 |> List.to_string() |> String.trim()))

     

       53
       53
       +
       |> Enum.chunk_while(

     

       54
       54
       +
         [],

     

       55
       55
       +
         fn

     

       56
       56
       +
           "", acc -> {:cont, acc, []}

     

       57
       57
       +
           num, acc -> {:cont, [String.to_integer(num) | acc]}

     

       58
       58
       +
         end,

     

       59
       59
       +
         &{:cont, &1, []}

     

       60
       60
       +
       )

     

       61
       61
       +
       |> Enum.zip(ops)

     

       62
       62
       +
       |> Enum.sum_by(fn

     

       63
       63
       +
         {nums, :+} -> Enum.sum(nums)

     

       64
       64
       +
         {nums, :*} -> Enum.product(nums)

     

       65
       65
       +
       end)

     

       66
       66
       +
       ```

     

       67
       67
       +
       

     

       68
       68
       +
       <!-- livebook:{"offset":1319,"stamp":{"token":"XCP.wqKPUf7KHN-UzqY1O8_n61vLL2ksAE_kGnIsQL0IpamJTD-NEX9_HbYK4H0y_NM8lKhqDz4rZ-TMFsXjuQ3n2-URGSNh_SCmDtJIbJBAP3mbiCwyN52oyGL0Nq5eD424MQ","version":2}} -->

+117

2025/day07.livemd

···

       1
       1
       +
       # Day 07

     

       2
       2
       +
       

     

       3
       3
       +
       ```elixir

     

       4
       4
       +
       Mix.install([:kino_aoc, :image])

     

       5
       5
       +
       ```

     

       6
       6
       +
       

     

       7
       7
       +
       ## Parse

     

       8
       8
       +
       

     

       9
       9
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiI3Iiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjUifQ","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       10
       10
       +
       

     

       11
       11
       +
       ```elixir

     

       12
       12
       +
       {:ok, puzzle_input} =

     

       13
       13
       +
         KinoAOC.download_puzzle("2025", "7", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       14
       14
       +
       ```

     

       15
       15
       +
       

     

       16
       16
       +
       ```elixir

     

       17
       17
       +
       [start | rest] = String.split(puzzle_input)

     

       18
       18
       +
       

     

       19
       19
       +
       start_col = byte_size(start) - byte_size(String.trim_leading(start, "."))

     

       20
       20
       +
       ```

     

       21
       21
       +
       

     

       22
       22
       +
       ```elixir

     

       23
       23
       +
       splitters =

     

       24
       24
       +
         Enum.map(rest, fn row ->

     

       25
       25
       +
           row

     

       26
       26
       +
           |> String.to_charlist()

     

       27
       27
       +
           |> Enum.with_index()

     

       28
       28
       +
           |> Enum.filter(&(elem(&1, 0) == ?^))

     

       29
       29
       +
           |> MapSet.new(&elem(&1, 1))

     

       30
       30
       +
         end)

     

       31
       31
       +
       ```

     

       32
       32
       +
       

     

       33
       33
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       34
       34
       +
       

     

       35
       35
       +
       ## Part 1

     

       36
       36
       +
       

     

       37
       37
       +
       ```elixir

     

       38
       38
       +
       Enum.reduce(splitters, {MapSet.new([start_col]), 0}, fn splits, {beams, count} ->

     

       39
       39
       +
         import MapSet, only: [intersection: 2, difference: 2, union: 2]

     

       40
       40
       +
         

     

       41
       41
       +
         hits = intersection(beams, splits)

     

       42
       42
       +
         new_beams = for hit <- hits, dx <- [-1, 1], into: MapSet.new(), do: hit + dx

     

       43
       43
       +
         beams = beams |> difference(hits) |> union(new_beams)

     

       44
       44
       +
       

     

       45
       45
       +
         {beams, MapSet.size(hits) + count}

     

       46
       46
       +
       end)

     

       47
       47
       +
       ```

     

       48
       48
       +
       

     

       49
       49
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       50
       50
       +
       

     

       51
       51
       +
       ## Part 2

     

       52
       52
       +
       

     

       53
       53
       +
       ```elixir

     

       54
       54
       +
       Enum.reduce(splitters, %{start_col => 1}, fn splits, beams ->

     

       55
       55
       +
         Enum.reduce(splits, beams, fn s, acc ->

     

       56
       56
       +
           case Map.pop(acc, s) do

     

       57
       57
       +
             {nil, map} ->

     

       58
       58
       +
               map

     

       59
       59
       +
       

     

       60
       60
       +
             {count, map} ->

     

       61
       61
       +
               Map.merge(

     

       62
       62
       +
                 map,

     

       63
       63
       +
                 %{

     

       64
       64
       +
                   (s + 1) => count,

     

       65
       65
       +
                   (s - 1) => count

     

       66
       66
       +
                 },

     

       67
       67
       +
                 fn _k, a, b -> a + b end

     

       68
       68
       +
               )

     

       69
       69
       +
           end

     

       70
       70
       +
         end)

     

       71
       71
       +
       end)

     

       72
       72
       +
       |> Enum.sum_by(&elem(&1, 1))

     

       73
       73
       +
       ```

     

       74
       74
       +
       

     

       75
       75
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       76
       76
       +
       

     

       77
       77
       +
       ## Image

     

       78
       78
       +
       

     

       79
       79
       +
       ```elixir

     

       80
       80
       +
       height = length([start | rest])

     

       81
       81
       +
       width = byte_size(start)

     

       82
       82
       +
       

     

       83
       83
       +
       {height, width}

     

       84
       84
       +
       ```

     

       85
       85
       +
       

     

       86
       86
       +
       ```elixir

     

       87
       87
       +
       Image.new!(width, height)

     

       88
       88
       +
       |> Image.mutate(fn img ->

     

       89
       89
       +
         Image.Draw.point!(img, start_col, 0, color: :yellow)

     

       90
       90
       +
       

     

       91
       91
       +
         splitters

     

       92
       92
       +
         |> Enum.with_index(1)

     

       93
       93
       +
         |> Enum.reduce(MapSet.new([start_col]), fn {splits, y}, beams ->

     

       94
       94
       +
           import MapSet, only: [intersection: 2, difference: 2, union: 2]

     

       95
       95
       +
       

     

       96
       96
       +
           for x <- beams do

     

       97
       97
       +
             Image.Draw.point(img, x, y, color: :green)

     

       98
       98
       +
           end

     

       99
       99
       +
       

     

       100
       100
       +
           for x <- splits do

     

       101
       101
       +
             Image.Draw.point(img, x, y, color: :red)

     

       102
       102
       +
           end

     

       103
       103
       +
           

     

       104
       104
       +
           hits = intersection(beams, splits)

     

       105
       105
       +
           new_beams = for hit <- hits, dx <- [-1, 1], into: MapSet.new(), do: hit + dx

     

       106
       106
       +
           beams = beams |> difference(hits) |> union(new_beams)

     

       107
       107
       +
       

     

       108
       108
       +
           beams

     

       109
       109
       +
         end)

     

       110
       110
       +
       

     

       111
       111
       +
         img

     

       112
       112
       +
       end)

     

       113
       113
       +
       |> then(fn {:ok, img} -> img end)

     

       114
       114
       +
       |> Image.resize!(5, interpolate: :nearest)

     

       115
       115
       +
       ```

     

       116
       116
       +
       

     

       117
       117
       +
       <!-- livebook:{"offset":2553,"stamp":{"token":"XCP.6lQNAY-yntHErm41fMi4xgwAxGSGZ7l6ekgYSe6b3Exm48kBKgyIoCK62LLVaeQP-1PfZFpd3tzHwAIA8OWTsnRBuWsxmex5qixMa-l4DaThm-jrSaVsE3Qj4aO-TrqdqA","version":2}} -->

+116

2025/day08.livemd

···

       1
       1
       +
       # Day 08

     

       2
       2
       +
       

     

       3
       3
       +
       ```elixir

     

       4
       4
       +
       Mix.install([:kino_aoc])

     

       5
       5
       +
       ```

     

       6
       6
       +
       

     

       7
       7
       +
       ## Parse

     

       8
       8
       +
       

     

       9
       9
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiI4Iiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjUifQ","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       10
       10
       +
       

     

       11
       11
       +
       ```elixir

     

       12
       12
       +
       {:ok, puzzle_input} =

     

       13
       13
       +
         KinoAOC.download_puzzle("2025", "8", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       14
       14
       +
       ```

     

       15
       15
       +
       

     

       16
       16
       +
       ```elixir

     

       17
       17
       +
       boxes =

     

       18
       18
       +
         puzzle_input

     

       19
       19
       +
         |> String.split()

     

       20
       20
       +
         |> Enum.map(fn raw ->

     

       21
       21
       +
           raw

     

       22
       22
       +
           |> String.split(",")

     

       23
       23
       +
           |> Enum.map(&String.to_integer/1)

     

       24
       24
       +
           |> List.to_tuple()

     

       25
       25
       +
         end)

     

       26
       26
       +
         |> Enum.sort()

     

       27
       27
       +
       ```

     

       28
       28
       +
       

     

       29
       29
       +
       ## Setup

     

       30
       30
       +
       

     

       31
       31
       +
       ```elixir

     

       32
       32
       +
       defmodule JunctionBoxes do

     

       33
       33
       +
         def all_pairs([]), do: []

     

       34
       34
       +
       

     

       35
       35
       +
         def all_pairs([x | rest]) do

     

       36
       36
       +
           for(y <- rest, do: {x, y}) ++ all_pairs(rest)

     

       37
       37
       +
         end

     

       38
       38
       +
       

     

       39
       39
       +
         def dist2({ax, ay, az}, {bx, by, bz}) do

     

       40
       40
       +
           dx = ax - bx

     

       41
       41
       +
           dy = ay - by

     

       42
       42
       +
           dz = az - bz

     

       43
       43
       +
       

     

       44
       44
       +
           dx ** 2 + dy ** 2 + dz ** 2

     

       45
       45
       +
         end

     

       46
       46
       +
       

     

       47
       47
       +
         def group([], {a, b}), do: [MapSet.new([a, b])]

     

       48
       48
       +
         def group([set | rest], {a, b}) do

     

       49
       49
       +
           cond do

     

       50
       50
       +
             a in set and b in set -> [set | rest]

     

       51
       51
       +
             a in set or b in set -> set |> MapSet.put(a) |> MapSet.put(b) |> do_squash(rest, a, b, [])

     

       52
       52
       +
             true -> [set | group(rest, {a, b})]

     

       53
       53
       +
           end

     

       54
       54
       +
         end

     

       55
       55
       +
       

     

       56
       56
       +
         defp do_squash(curr, [], _, _, acc), do: [curr | acc]

     

       57
       57
       +
         defp do_squash(curr, [x | rest], a, b, acc) do

     

       58
       58
       +
           if a in x or b in x do

     

       59
       59
       +
             [MapSet.union(curr, x) | acc ++ rest]

     

       60
       60
       +
           else

     

       61
       61
       +
             do_squash(curr, rest, a, b, [x | acc])

     

       62
       62
       +
           end

     

       63
       63
       +
         end

     

       64
       64
       +
       end

     

       65
       65
       +
       ```

     

       66
       66
       +
       

     

       67
       67
       +
       ```elixir

     

       68
       68
       +
       sorted_pairs =

     

       69
       69
       +
         JunctionBoxes.all_pairs(boxes)

     

       70
       70
       +
         |> Enum.sort_by(fn {a, b} -> JunctionBoxes.dist2(a, b) end)

     

       71
       71
       +
       ```

     

       72
       72
       +
       

     

       73
       73
       +
       <!-- livebook:{"branch_parent_index":1} -->

     

       74
       74
       +
       

     

       75
       75
       +
       ## Part 1

     

       76
       76
       +
       

     

       77
       77
       +
       ```elixir

     

       78
       78
       +
       sorted_pairs

     

       79
       79
       +
       |> Enum.take(1000)

     

       80
       80
       +
       |> Enum.reduce([], &JunctionBoxes.group(&2, &1))

     

       81
       81
       +
       |> Enum.map(&MapSet.size/1)

     

       82
       82
       +
       |> Enum.sort(:desc)

     

       83
       83
       +
       |> Enum.take(3)

     

       84
       84
       +
       |> Enum.product()

     

       85
       85
       +
       ```

     

       86
       86
       +
       

     

       87
       87
       +
       <!-- livebook:{"branch_parent_index":1} -->

     

       88
       88
       +
       

     

       89
       89
       +
       ## Part 2

     

       90
       90
       +
       

     

       91
       91
       +
       ```elixir

     

       92
       92
       +
       box_count = length(boxes)

     

       93
       93
       +
       ```

     

       94
       94
       +
       

     

       95
       95
       +
       ```elixir

     

       96
       96
       +
       {a, b} =

     

       97
       97
       +
         sorted_pairs

     

       98
       98
       +
         |> Enum.reduce_while([], fn pair, acc ->

     

       99
       99
       +
           new_acc = JunctionBoxes.group(acc, pair)

     

       100
       100
       +
       

     

       101
       101
       +
           if MapSet.size(hd(new_acc)) == box_count do

     

       102
       102
       +
             {:halt, pair}

     

       103
       103
       +
           else

     

       104
       104
       +
             {:cont, new_acc}

     

       105
       105
       +
           end

     

       106
       106
       +
         end)

     

       107
       107
       +
       ```

     

       108
       108
       +
       

     

       109
       109
       +
       ```elixir

     

       110
       110
       +
       {ax, _, _} = a

     

       111
       111
       +
       {bx, _, _} = b

     

       112
       112
       +
       

     

       113
       113
       +
       ax * bx

     

       114
       114
       +
       ```

     

       115
       115
       +
       

     

       116
       116
       +
       <!-- livebook:{"offset":2222,"stamp":{"token":"XCP.sY5bJOGXuU_ZotobOVN6-zcg0TDJGEWVaJESs_-qDHzeEplFoStZ8_c6TRpS5eVpqnzoaj-gsLs_drksuYvMCDcM3T7_M6p9s09DRSKgMU2YB_Ogb0CB6_gAZamF2zEIUw","version":2}} -->

+167

2025/day09.livemd

···

       1
       1
       +
       # Day 09

     

       2
       2
       +
       

     

       3
       3
       +
       ```elixir

     

       4
       4
       +
       Mix.install([:kino_aoc, :image])

     

       5
       5
       +
       ```

     

       6
       6
       +
       

     

       7
       7
       +
       ## Setup

     

       8
       8
       +
       

     

       9
       9
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiI5Iiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjUifQ","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       10
       10
       +
       

     

       11
       11
       +
       ```elixir

     

       12
       12
       +
       {:ok, puzzle_input} =

     

       13
       13
       +
         KinoAOC.download_puzzle("2025", "9", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       14
       14
       +
       ```

     

       15
       15
       +
       

     

       16
       16
       +
       ```elixir

     

       17
       17
       +
       tiles =

     

       18
       18
       +
         puzzle_input

     

       19
       19
       +
         |> String.split()

     

       20
       20
       +
         |> Enum.map(fn raw ->

     

       21
       21
       +
           raw

     

       22
       22
       +
           |> String.split(",")

     

       23
       23
       +
           |> Enum.map(&String.to_integer/1)

     

       24
       24
       +
           |> List.to_tuple()

     

       25
       25
       +
         end)

     

       26
       26
       +
       ```

     

       27
       27
       +
       

     

       28
       28
       +
       ## Implementation

     

       29
       29
       +
       

     

       30
       30
       +
       ```elixir

     

       31
       31
       +
       defmodule Combinatorics do

     

       32
       32
       +
         def combinations2(list) do

     

       33
       33
       +
           Stream.unfold(list, fn

     

       34
       34
       +
             [] -> nil

     

       35
       35
       +
             [x | rest] ->

     

       36
       36
       +
               curr = for y <- rest, do: [x, y]

     

       37
       37
       +
       

     

       38
       38
       +
               {curr, rest}

     

       39
       39
       +
           end)

     

       40
       40
       +
           |> Stream.flat_map(& &1)

     

       41
       41
       +
         end

     

       42
       42
       +
       end

     

       43
       43
       +
       ```

     

       44
       44
       +
       

     

       45
       45
       +
       ```elixir

     

       46
       46
       +
       defmodule Rect do

     

       47
       47
       +
         require Record

     

       48
       48
       +
       

     

       49
       49
       +
         Record.defrecordp(:rect, l: 0, t: 0, r: 0, b: 0)

     

       50
       50
       +
       

     

       51
       51
       +
         def new({ax, ay}, {bx, by}) do

     

       52
       52
       +
           rect(l: min(ax, bx), r: max(ax, bx), t: min(ay, by), b: max(ay, by))

     

       53
       53
       +
         end

     

       54
       54
       +
       

     

       55
       55
       +
         def area(rect() = r) do

     

       56
       56
       +
           width(r) * height(r)

     

       57
       57
       +
         end

     

       58
       58
       +
       

     

       59
       59
       +
         def intersect?(

     

       60
       60
       +
               rect(l: al, r: ar, t: at, b: ab),

     

       61
       61
       +
               rect(l: bl, r: br, t: bt, b: bb)

     

       62
       62
       +
             ) do

     

       63
       63
       +
           al < br and ar > bl and at < bb and ab > bt

     

       64
       64
       +
         end

     

       65
       65
       +
       

     

       66
       66
       +
         def width(rect(r: r, l: l)), do: r - l + 1

     

       67
       67
       +
         def height(rect(t: t, b: b)), do: b - t + 1

     

       68
       68
       +
       

     

       69
       69
       +
         def to_svg(rect(l: x, t: y) = r, opts \\ []) do

     

       70
       70
       +
           ~s"""

     

       71
       71
       +
           <rect x="#{x}" y="#{y}" width="#{width(r)}" height="#{height(r)}"

     

       72
       72
       +
           #{Enum.map_join(opts, " ", fn {k, v} -> ~s(#{k}="#{v}") end)} />

     

       73
       73
       +
           """

     

       74
       74
       +
         end

     

       75
       75
       +
       end

     

       76
       76
       +
       ```

     

       77
       77
       +
       

     

       78
       78
       +
       ```elixir

     

       79
       79
       +
       rects =

     

       80
       80
       +
         Combinatorics.combinations2(tiles)

     

       81
       81
       +
         |> Stream.map(fn [a, b] -> Rect.new(a, b) end)

     

       82
       82
       +
         |> Enum.sort()

     

       83
       83
       +
       ```

     

       84
       84
       +
       

     

       85
       85
       +
       <!-- livebook:{"branch_parent_index":1} -->

     

       86
       86
       +
       

     

       87
       87
       +
       ## Part 1

     

       88
       88
       +
       

     

       89
       89
       +
       ```elixir

     

       90
       90
       +
       rects

     

       91
       91
       +
       |> Enum.max_by(&Rect.area/1)

     

       92
       92
       +
       |> IO.inspect()

     

       93
       93
       +
       |> Rect.area()

     

       94
       94
       +
       ```

     

       95
       95
       +
       

     

       96
       96
       +
       <!-- livebook:{"branch_parent_index":1} -->

     

       97
       97
       +
       

     

       98
       98
       +
       ## Part 2

     

       99
       99
       +
       

     

       100
       100
       +
       ```elixir

     

       101
       101
       +
       edges =

     

       102
       102
       +
         tiles

     

       103
       103
       +
         |> Enum.chunk_every(2, 1, tiles)

     

       104
       104
       +
         |> Enum.map(&apply(Rect, :new, &1))

     

       105
       105
       +
         |> Enum.sort()

     

       106
       106
       +
       ```

     

       107
       107
       +
       

     

       108
       108
       +
       ```elixir

     

       109
       109
       +
       # [{1916, 50285}, {94619, 50285}, {94619, 48466}, {1668, 48466}]

     

       110
       110
       +
       # |> Stream.flat_map(fn a ->

     

       111
       111
       +
       #  for b <- tiles do

     

       112
       112
       +
       #    Rect.new(a, b)

     

       113
       113
       +
       #  end

     

       114
       114
       +
       # end)

     

       115
       115
       +
       rects

     

       116
       116
       +
       |> Enum.reduce({0, nil}, fn r, {max, p} ->

     

       117
       117
       +
         a = Rect.area(r)

     

       118
       118
       +
       

     

       119
       119
       +
         if a > max and not Enum.any?(edges, &Rect.intersect?(r, &1)) do

     

       120
       120
       +
           {a, r}

     

       121
       121
       +
         else

     

       122
       122
       +
           {max, p}

     

       123
       123
       +
         end

     

       124
       124
       +
       end)

     

       125
       125
       +
       ```

     

       126
       126
       +
       

     

       127
       127
       +
       ## Draw

     

       128
       128
       +
       

     

       129
       129
       +
       ```elixir

     

       130
       130
       +
       {{min_x, _}, {max_x, _}} = Enum.min_max(tiles)

     

       131
       131
       +
       ```

     

       132
       132
       +
       

     

       133
       133
       +
       ```elixir

     

       134
       134
       +
       {{_, min_y}, {_, max_y}} = Enum.min_max_by(tiles, &elem(&1, 1))

     

       135
       135
       +
       ```

     

       136
       136
       +
       

     

       137
       137
       +
       ```elixir

     

       138
       138
       +
       h = max_y + min_y

     

       139
       139
       +
       w = max_x + min_x

     

       140
       140
       +
       ```

     

       141
       141
       +
       

     

       142
       142
       +
       ```elixir

     

       143
       143
       +
       {x, y} = hd(tiles)

     

       144
       144
       +
       

     

       145
       145
       +
       p1 = {:rect, 16055, 14805, 85282, 83613}

     

       146
       146
       +
       p2 = {:rect, 5741, 50285, 94619, 67351}

     

       147
       147
       +
       

     

       148
       148
       +
       svg = """

     

       149
       149
       +
       <svg xmlns="http://www.w3.org/2000/svg" width="500" viewBox="0 0 #{w} #{h}">

     

       150
       150
       +
         <rect width="100%" height="100%" fill="black" />

     

       151
       151
       +
         <path d="M#{x} #{y}#{

     

       152
       152
       +
           for {x, y} <- tl(tiles), do: "L#{x} #{y} "

     

       153
       153
       +
         } L#{x} #{y}" stroke="darkgreen" fill="green" stroke-width="200" />

     

       154
       154
       +
         #{Rect.to_svg(p1, stroke: :orange, fill: :transparent, "stroke-width": 200)}

     

       155
       155
       +
         #{Rect.to_svg(p2, stroke: :yellow, fill: :transparent, "stroke-width": 200)}

     

       156
       156
       +
         #{

     

       157
       157
       +
           for {x, y} <- tiles do

     

       158
       158
       +
             ~s(<rect x="#{x - 100}" y="#{y - 100}" width="200" height="200" fill="red" />)

     

       159
       159
       +
           end

     

       160
       160
       +
         }

     

       161
       161
       +
       </svg>

     

       162
       162
       +
       """

     

       163
       163
       +
       

     

       164
       164
       +
       Kino.Image.new(svg, :svg)

     

       165
       165
       +
       ```

     

       166
       166
       +
       

     

       167
       167
       +
       <!-- livebook:{"offset":3329,"stamp":{"token":"XCP.SSlM8wg30CucU7IP0n8MTbPIvnvvcZRXcglo9DY17kk0O0fwtLfUUiYJauWdspkXUlp0Axl5YscQNBKK5mSycPLd0iNdz8JFPfjCg4rS2pyM3JuQj73ipXd27t8Yd0ylig","version":2}} -->

+188

2025/day10.livemd

···

       1
       1
       +
       # Day 10

     

       2
       2
       +
       

     

       3
       3
       +
       ```elixir

     

       4
       4
       +
       Mix.install([:kino_aoc, {:dantzig, github: "hauleth/dantzig", ref: "use-proper-binary"}],

     

       5
       5
       +
       config: [

     

       6
       6
       +
         dantzig: [

     

       7
       7
       +
           highs_binary_path: System.find_executable("highs")

     

       8
       8
       +
         ]

     

       9
       9
       +
       ])

     

       10
       10
       +
       ```

     

       11
       11
       +
       

     

       12
       12
       +
       ## Section

     

       13
       13
       +
       

     

       14
       14
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIxMCIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI1In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       15
       15
       +
       

     

       16
       16
       +
       ```elixir

     

       17
       17
       +
       {:ok, puzzle_input} =

     

       18
       18
       +
         KinoAOC.download_puzzle("2025", "10", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       19
       19
       +
       ```

     

       20
       20
       +
       

     

       21
       21
       +
       ```elixir

     

       22
       22
       +
       defmodule Decoder do

     

       23
       23
       +
         def decode("[" <> pattern), do: do_lights(String.reverse(String.trim_trailing(pattern, "]")), 0)

     

       24
       24
       +
       

     

       25
       25
       +
         def decode("(" <> rest) do

     

       26
       26
       +
           <<seq::binary-size(byte_size(rest) - 1), ")">> = rest

     

       27
       27
       +
       

     

       28
       28
       +
           seq

     

       29
       29
       +
           |> String.split(",")

     

       30
       30
       +
           |> Enum.map(&String.to_integer/1)

     

       31
       31
       +
         end

     

       32
       32
       +
       

     

       33
       33
       +
         def decode("{" <> rest) do

     

       34
       34
       +
           <<seq::binary-size(byte_size(rest) - 1), "}">> = rest

     

       35
       35
       +
       

     

       36
       36
       +
           seq

     

       37
       37
       +
           |> String.split(",")

     

       38
       38
       +
           |> Enum.map(&String.to_integer/1)

     

       39
       39
       +
         end

     

       40
       40
       +
         

     

       41
       41
       +
         defp do_lights("", num), do: num

     

       42
       42
       +
         defp do_lights("." <> rest, num), do: do_lights(rest, 2 * num)

     

       43
       43
       +
         defp do_lights("#" <> rest, num), do: do_lights(rest, 2 * num + 1)

     

       44
       44
       +
       end

     

       45
       45
       +
       ```

     

       46
       46
       +
       

     

       47
       47
       +
       ```elixir

     

       48
       48
       +
       indicators =

     

       49
       49
       +
         puzzle_input

     

       50
       50
       +
         |> String.split("\n", trim: true)

     

       51
       51
       +
         |> Enum.map(fn raw ->

     

       52
       52
       +
           [lights | rest] =

     

       53
       53
       +
             raw

     

       54
       54
       +
             |> String.split()

     

       55
       55
       +
             |> Enum.map(&Decoder.decode/1)

     

       56
       56
       +
       

     

       57
       57
       +
           {buttons, [whatever]} = Enum.split(rest, -1)

     

       58
       58
       +
       

     

       59
       59
       +
           {lights, buttons, whatever}

     

       60
       60
       +
         end)

     

       61
       61
       +
       ```

     

       62
       62
       +
       

     

       63
       63
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       64
       64
       +
       

     

       65
       65
       +
       ## Part 1

     

       66
       66
       +
       

     

       67
       67
       +
       We are looking for such sequence of buttons that will provide pattern we are looking for. It can be solved by brute force with simple observation that buttons $a_n$ as well as light pattern $p$ can be represented by binary pattern. This allows us to use $\oplus$ (exclusive or, aka `XOR`) as an operation for pressing button.

     

       68
       68
       +
       

     

       69
       69
       +
       Thanks to that observation we can see, that order in which we press buttons doesn't matter, as $\oplus$ is reflexive, i.e.:

     

       70
       70
       +
       

     

       71
       71
       +
       $$

     

       72
       72
       +
       \begin{equation}

     

       73
       73
       +
       a \oplus b = b \oplus a

     

       74
       74
       +
       \end{equation}

     

       75
       75
       +
       $$

     

       76
       76
       +
       

     

       77
       77
       +
       Additionally, wrt. $\oplus$ we have identity element $0$ and inverse element is the same as an original element, i.e.

     

       78
       78
       +
       

     

       79
       79
       +
       $$

     

       80
       80
       +
       \begin{align}

     

       81
       81
       +
       a \oplus 0 = a \\

     

       82
       82
       +
       a \oplus a = 0

     

       83
       83
       +
       \end{align}

     

       84
       84
       +
       $$

     

       85
       85
       +
       

     

       86
       86
       +
       Additionally we can observe that:

     

       87
       87
       +
       

     

       88
       88
       +
       $$

     

       89
       89
       +
       \begin{equation}

     

       90
       90
       +
       (a \oplus b) \oplus c = a \oplus (b \oplus c)

     

       91
       91
       +
       \end{equation}

     

       92
       92
       +
       $$

     

       93
       93
       +
       

     

       94
       94
       +
       With that observation we can deduce that each button will be pressed at most once and the order in which we press buttons doesn't matter.

     

       95
       95
       +
       

     

       96
       96
       +
       ---

     

       97
       97
       +
       

     

       98
       98
       +
       So now we look for set $A = \{a_n\}$ of buttons that

     

       99
       99
       +
       

     

       100
       100
       +
       $$

     

       101
       101
       +
       A \in \mathcal{P}(\text{Buttons}) \\

     

       102
       102
       +
       \forall_{i, j} \; i \ne j \implies a_i \ne a_j \\

     

       103
       103
       +
       \bigoplus A = p

     

       104
       104
       +
       $$

     

       105
       105
       +
       

     

       106
       106
       +
       ```elixir

     

       107
       107
       +
       defmodule Comb do

     

       108
       108
       +
         def all_possible([]), do: [[]]

     

       109
       109
       +
         def all_possible([a | rest]) do

     

       110
       110
       +
           sub = all_possible(rest)

     

       111
       111
       +
       

     

       112
       112
       +
           sub ++ Enum.map(sub, &[a | &1])

     

       113
       113
       +
         end

     

       114
       114
       +
       end

     

       115
       115
       +
       ```

     

       116
       116
       +
       

     

       117
       117
       +
       ```elixir

     

       118
       118
       +
       indicators

     

       119
       119
       +
       |> Enum.sum_by(fn {p, a, _} ->

     

       120
       120
       +
         a

     

       121
       121
       +
         |> Enum.map(&Enum.sum_by(&1, fn p -> 2 ** p end))

     

       122
       122
       +
         |> Comb.all_possible()

     

       123
       123
       +
         |> Enum.sort_by(&length/1)

     

       124
       124
       +
         |> Enum.find(fn seq ->

     

       125
       125
       +
           r = Enum.reduce(seq, 0, &Bitwise.bxor/2)

     

       126
       126
       +
       

     

       127
       127
       +
           p == r

     

       128
       128
       +
         end)

     

       129
       129
       +
         |> length()

     

       130
       130
       +
       end)

     

       131
       131
       +
       ```

     

       132
       132
       +
       

     

       133
       133
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       134
       134
       +
       

     

       135
       135
       +
       ## Part 2

     

       136
       136
       +
       

     

       137
       137
       +
       ```elixir

     

       138
       138
       +
       defmodule Joltage do

     

       139
       139
       +
         alias Dantzig.Polynomial

     

       140
       140
       +
         alias Dantzig.Constraint

     

       141
       141
       +
         alias Dantzig.Problem

     

       142
       142
       +
       

     

       143
       143
       +
         def solve({_pat, buttons, goal}) do

     

       144
       144
       +
           p = Problem.new(direction: :minimize)

     

       145
       145
       +
       

     

       146
       146
       +
           {vars, {p, map}} =

     

       147
       147
       +
             buttons

     

       148
       148
       +
             |> Enum.with_index()

     

       149
       149
       +
             |> Enum.map_reduce({p, %{}}, fn {list, idx}, {p, acc} ->

     

       150
       150
       +
               {p, var} = Problem.new_variable(p, "v#{idx}", min: 0, type: :integer)

     

       151
       151
       +
       

     

       152
       152
       +
               acc =

     

       153
       153
       +
                 Enum.reduce(list, acc, fn key, map ->

     

       154
       154
       +
                   Map.update(map, key, [var], &[var | &1])

     

       155
       155
       +
                 end)

     

       156
       156
       +
       

     

       157
       157
       +
               {var, {p, acc}}

     

       158
       158
       +
             end)

     

       159
       159
       +
       

     

       160
       160
       +
           p =

     

       161
       161
       +
             map

     

       162
       162
       +
             |> Enum.sort()

     

       163
       163
       +
             |> Enum.map(&elem(&1, 1))

     

       164
       164
       +
             |> Enum.zip(goal)

     

       165
       165
       +
             |> Enum.reduce(p, fn {vars, target}, p ->

     

       166
       166
       +
               poly = Polynomial.sum(vars)

     

       167
       167
       +
               const = Constraint.new(poly, :==, target)

     

       168
       168
       +
       

     

       169
       169
       +
               Problem.add_constraint(p, const)

     

       170
       170
       +
             end)

     

       171
       171
       +
       

     

       172
       172
       +
           p = Problem.increment_objective(p, Polynomial.sum(vars))

     

       173
       173
       +
       

     

       174
       174
       +
           {:ok, s} = Dantzig.HiGHS.solve(p)

     

       175
       175
       +
       

     

       176
       176
       +
           Enum.sum_by(vars, &Dantzig.Solution.evaluate(s, &1))

     

       177
       177
       +
         end

     

       178
       178
       +
       end

     

       179
       179
       +
       ```

     

       180
       180
       +
       

     

       181
       181
       +
       ```elixir

     

       182
       182
       +
       indicators

     

       183
       183
       +
       |> Task.async_stream(&Joltage.solve/1, ordered: false)

     

       184
       184
       +
       |> Enum.sum_by(&elem(&1, 1))

     

       185
       185
       +
       |> trunc()

     

       186
       186
       +
       ```

     

       187
       187
       +
       

     

       188
       188
       +
       <!-- livebook:{"offset":4336,"stamp":{"token":"XCP.sfoBGIHkFvWbEHVrY-dL-QiEcwRz_ZCIjn3lQ0RFHActIOwEapmOPBt0ygbQAmrnEjYPlFm5KrcWx4LfIPbSznxxcea0fYORG9GbBBpRCm-tYbGXYTCGgqgTvOsifyWDNg","version":2}} -->

+85

2025/day11.livemd

···

       1
       1
       +
       # Day 11

     

       2
       2
       +
       

     

       3
       3
       +
       ```elixir

     

       4
       4
       +
       Mix.install([:kino_aoc])

     

       5
       5
       +
       ```

     

       6
       6
       +
       

     

       7
       7
       +
       ## Parse

     

       8
       8
       +
       

     

       9
       9
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIxMSIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI1In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       10
       10
       +
       

     

       11
       11
       +
       ```elixir

     

       12
       12
       +
       {:ok, puzzle_input} =

     

       13
       13
       +
         KinoAOC.download_puzzle("2025", "11", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       14
       14
       +
       ```

     

       15
       15
       +
       

     

       16
       16
       +
       ```elixir

     

       17
       17
       +
       graph =

     

       18
       18
       +
         puzzle_input

     

       19
       19
       +
         |> String.split("\n", trim: true)

     

       20
       20
       +
         |> Map.new(fn <<from::binary-3>> <> ": " <> rest ->

     

       21
       21
       +
           {from, String.split(rest)}

     

       22
       22
       +
         end)

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ## Implementation

     

       26
       26
       +
       

     

       27
       27
       +
       ```elixir

     

       28
       28
       +
       defmodule Servers do

     

       29
       29
       +
         def paths(graph, from, to), do: paths(graph, from, to, [from])

     

       30
       30
       +
       

     

       31
       31
       +
         defp paths(_graph, to, to, acc), do: [Enum.reverse(acc)]

     

       32
       32
       +
       

     

       33
       33
       +
         defp paths(graph, from, to, acc) do

     

       34
       34
       +
           if next = graph[from] do

     

       35
       35
       +
             Stream.flat_map(next, &paths(graph, &1, to, [&1 | acc]))

     

       36
       36
       +
           else

     

       37
       37
       +
             []

     

       38
       38
       +
           end

     

       39
       39
       +
         end

     

       40
       40
       +
       

     

       41
       41
       +
         def paths_through(graph, from, to, required),

     

       42
       42
       +
           do: path_through(graph, from, to, MapSet.new(required), %{})

     

       43
       43
       +
       

     

       44
       44
       +
         defp path_through(_graph, to, to, required, memo),

     

       45
       45
       +
           do: {if(Enum.empty?(required), do: 1, else: 0), memo}

     

       46
       46
       +
       

     

       47
       47
       +
         defp path_through(graph, from, to, required, memo) do

     

       48
       48
       +
           state = MapSet.delete(required, from)

     

       49
       49
       +
       

     

       50
       50
       +
           with :error <- Map.fetch(memo, {from, state}),

     

       51
       51
       +
                {:ok, next} <- Map.fetch(graph, from) do

     

       52
       52
       +
             {sum, memo} =

     

       53
       53
       +
             Enum.reduce(next, {0, memo}, fn n, {sum, acc} ->

     

       54
       54
       +
               {c, next_acc} = path_through(graph, n, to, state, acc)

     

       55
       55
       +
       

     

       56
       56
       +
               {c + sum, next_acc}

     

       57
       57
       +
             end)

     

       58
       58
       +
       

     

       59
       59
       +
             {sum, Map.put(memo, {from, state}, sum)}

     

       60
       60
       +
           else

     

       61
       61
       +
             :error -> {0, memo}

     

       62
       62
       +
             {:ok, val} -> {val, memo}

     

       63
       63
       +
           end

     

       64
       64
       +
         end

     

       65
       65
       +
       end

     

       66
       66
       +
       ```

     

       67
       67
       +
       

     

       68
       68
       +
       <!-- livebook:{"branch_parent_index":1} -->

     

       69
       69
       +
       

     

       70
       70
       +
       ## Part 1

     

       71
       71
       +
       

     

       72
       72
       +
       ```elixir

     

       73
       73
       +
       Servers.paths(graph, "you", "out") |> Enum.count()

     

       74
       74
       +
       ```

     

       75
       75
       +
       

     

       76
       76
       +
       <!-- livebook:{"branch_parent_index":1} -->

     

       77
       77
       +
       

     

       78
       78
       +
       ## Part 2

     

       79
       79
       +
       

     

       80
       80
       +
       ```elixir

     

       81
       81
       +
       Servers.paths_through(graph, "svr", "out", ["dac", "fft"])

     

       82
       82
       +
       |> elem(0)

     

       83
       83
       +
       ```

     

       84
       84
       +
       

     

       85
       85
       +
       <!-- livebook:{"offset":1933,"stamp":{"token":"XCP.fzzPot48c9xb6ftw8IEb1V6uTX6csBICnoXjN1PU6c3DylXjP-bco9PgawAoc2GSeNJRzS3NCPmJ9aO9Jm2ehPXnam5fN-bZvUbEcxKmNA8SqH2_fJ5o_qp8rIaxpH6DRQ","version":2}} -->

+73

2025/day12.livemd

···

       1
       1
       +
       # Day 12

     

       2
       2
       +
       

     

       3
       3
       +
       ```elixir

     

       4
       4
       +
       Mix.install([:kino_aoc])

     

       5
       5
       +
       ```

     

       6
       6
       +
       

     

       7
       7
       +
       ## Parsing

     

       8
       8
       +
       

     

       9
       9
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIxMiIsInNlc3Npb25fc2VjcmV0IjoiQURWRU5UX09GX0NPREVfU0VTU0lPTiIsInllYXIiOiIyMDI1In0","chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       10
       10
       +
       

     

       11
       11
       +
       ```elixir

     

       12
       12
       +
       {:ok, puzzle_input} =

     

       13
       13
       +
         KinoAOC.download_puzzle("2025", "12", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       14
       14
       +
       ```

     

       15
       15
       +
       

     

       16
       16
       +
       ```elixir

     

       17
       17
       +
       {areas, boxes} =

     

       18
       18
       +
         puzzle_input

     

       19
       19
       +
         |> String.split("\n\n")

     

       20
       20
       +
         |> List.pop_at(-1)

     

       21
       21
       +
       ```

     

       22
       22
       +
       

     

       23
       23
       +
       ```elixir

     

       24
       24
       +
       areas =

     

       25
       25
       +
         areas

     

       26
       26
       +
         |> String.split("\n")

     

       27
       27
       +
         |> Enum.map(fn raw ->

     

       28
       28
       +
           [area | counts] = String.split(raw)

     

       29
       29
       +
       

     

       30
       30
       +
           area =

     

       31
       31
       +
             area

     

       32
       32
       +
             |> String.trim(":") 

     

       33
       33
       +
             |> String.split("x")

     

       34
       34
       +
             |> Enum.map(&String.to_integer/1)

     

       35
       35
       +
             |> Enum.product()

     

       36
       36
       +
       

     

       37
       37
       +
           counts = Enum.map(counts, &String.to_integer/1)

     

       38
       38
       +
       

     

       39
       39
       +
           {area, counts}

     

       40
       40
       +
         end)

     

       41
       41
       +
       ```

     

       42
       42
       +
       

     

       43
       43
       +
       ```elixir

     

       44
       44
       +
       boxes =

     

       45
       45
       +
         boxes

     

       46
       46
       +
         |> Enum.map(fn <<_::binary-3>> <> rest ->

     

       47
       47
       +
           rest

     

       48
       48
       +
           |> String.to_charlist()

     

       49
       49
       +
           |> Enum.count(&(&1 == ?#))

     

       50
       50
       +
         end)

     

       51
       51
       +
       ```

     

       52
       52
       +
       

     

       53
       53
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       54
       54
       +
       

     

       55
       55
       +
       ## Part 1

     

       56
       56
       +
       

     

       57
       57
       +
       ```elixir

     

       58
       58
       +
       areas

     

       59
       59
       +
       |> Enum.count(fn {max, counts} ->

     

       60
       60
       +
         counts

     

       61
       61
       +
         |> Enum.zip_with(boxes, &*/2)

     

       62
       62
       +
         |> Enum.sum()

     

       63
       63
       +
         |> then(& &1 <= max)

     

       64
       64
       +
       end)

     

       65
       65
       +
       ```

     

       66
       66
       +
       

     

       67
       67
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       68
       68
       +
       

     

       69
       69
       +
       ## Part 2

     

       70
       70
       +
       

     

       71
       71
       +
       FIN

     

       72
       72
       +
       

     

       73
       73
       +
       <!-- livebook:{"offset":1266,"stamp":{"token":"XCP.VAO97d30rTEs0AWIHkPD4J0fLm3S60tQ3fKoA-riReFbzMnqL1jIoxttGhvNSnCfZVNfeUBuSYVe6PrIshxVGBwjr3pjNHCyFLSb4iSPNh277lkMmh6Gtrlfr8dvsYvw0g","version":2}} -->

Compare changes