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

+100

2019/1/input.txt

+19

2019/1/solution.exs

···

       1
       1
       +
       defmodule Main do

     

       2
       2
       +
         def calculate(value), do: max(div(value, 3) - 2, 0)

     

       3
       3
       +
       

     

       4
       4
       +
         def for_fuel(value), do: for_fuel(value, value)

     

       5
       5
       +
       

     

       6
       6
       +
         defp for_fuel(0, total), do: total

     

       7
       7
       +
         defp for_fuel(value, total) do

     

       8
       8
       +
           current = calculate(value)

     

       9
       9
       +
       

     

       10
       10
       +
           for_fuel(current, total + current)

     

       11
       11
       +
         end

     

       12
       12
       +
       end

     

       13
       13
       +
       

     

       14
       14
       +
       IO.stream(:stdio, :line)

     

       15
       15
       +
       |> Stream.map(&String.to_integer(String.trim(&1)))

     

       16
       16
       +
       |> Stream.map(&Main.calculate/1)

     

       17
       17
       +
       |> Stream.map(&Main.for_fuel/1)

     

       18
       18
       +
       |> Enum.reduce(&+/2)

     

       19
       19
       +
       |> IO.inspect()

2019/2/input.txt

···

       1
       1
       +
       1,0,0,3,1,1,2,3,1,3,4,3,1,5,0,3,2,1,10,19,1,6,19,23,1,10,23,27,2,27,13,31,1,31,6,35,2,6,35,39,1,39,5,43,1,6,43,47,2,6,47,51,1,51,5,55,2,55,9,59,1,6,59,63,1,9,63,67,1,67,10,71,2,9,71,75,1,6,75,79,1,5,79,83,2,83,10,87,1,87,5,91,1,91,9,95,1,6,95,99,2,99,10,103,1,103,5,107,2,107,6,111,1,111,5,115,1,9,115,119,2,119,10,123,1,6,123,127,2,13,127,131,1,131,6,135,1,135,10,139,1,13,139,143,1,143,13,147,1,5,147,151,1,151,2,155,1,155,5,0,99,2,0,14,0

+41

2019/2/solution.exs

···

       1
       1
       +
       defmodule GravAssist do

     

       2
       2
       +
         def calc([op, _, _ | rest], a \\ 12, b \\ 2) do

     

       3
       3
       +
           hd(execute([op, a, b | rest]))

     

       4
       4
       +
         end

     

       5
       5
       +
       

     

       6
       6
       +
         def execute(bytecode) when is_list(bytecode), do: execute(:array.from_list(bytecode))

     

       7
       7
       +
         def execute(bytecode), do: eval(bytecode, 0)

     

       8
       8
       +
       

     

       9
       9
       +
         defp eval(bytecode, ic) do

     

       10
       10
       +
           case :array.get(ic, bytecode) do

     

       11
       11
       +
             99 -> :array.to_list(bytecode)

     

       12
       12
       +
             op when op in 1..2 ->

     

       13
       13
       +
               pos_a = :array.get(ic + 1, bytecode)

     

       14
       14
       +
               pos_b = :array.get(ic + 2, bytecode)

     

       15
       15
       +
               pos_r = :array.get(ic + 3, bytecode)

     

       16
       16
       +
       

     

       17
       17
       +
               result = compute(op, :array.get(pos_a, bytecode), :array.get(pos_b, bytecode))

     

       18
       18
       +
       

     

       19
       19
       +
               new_bc = :array.set(pos_r, result, bytecode)

     

       20
       20
       +
       

     

       21
       21
       +
               eval(new_bc, ic + 4)

     

       22
       22
       +
             _ -> :error

     

       23
       23
       +
           end

     

       24
       24
       +
         end

     

       25
       25
       +
       

     

       26
       26
       +
         defp compute(1, a, b), do: a + b

     

       27
       27
       +
         defp compute(2, a, b), do: a * b

     

       28
       28
       +
       end

     

       29
       29
       +
       

     

       30
       30
       +
       data =

     

       31
       31
       +
         IO.read(:line)

     

       32
       32
       +
         |> String.split(",")

     

       33
       33
       +
         |> Enum.map(&String.to_integer(String.trim(&1)))

     

       34
       34
       +
       

     

       35
       35
       +
       IO.inspect(GravAssist.calc(data), label: :sol1)

     

       36
       36
       +
       

     

       37
       37
       +
       for(a <- 0..99,

     

       38
       38
       +
           b <- 0..99,

     

       39
       39
       +
           19690720 == GravAssist.calc(data, a, b),

     

       40
       40
       +
         do: {a, b})

     

       41
       41
       +
       |> IO.inspect(label: :sol2)

2019/3/input.txt

···

       1
       1
       +
       R997,D543,L529,D916,R855,D705,L159,U444,R234,U639,L178,D682,L836,U333,R571,D906,L583,U872,L733,U815,L484,D641,R649,U378,L26,U66,L659,D27,R4,U325,L264,D711,L837,D986,L38,U623,L830,D369,L469,D704,L302,U143,L771,U170,R237,U477,L251,D100,R561,D889,R857,D780,R258,D299,L975,D481,L692,D894,R847,D416,R670,D658,L537,U748,R468,D304,L263,D884,R806,D13,R288,U933,R4,U291,L809,D242,R669,D50,R106,D510,R409,U311,R101,D232,R370,D490,L762,D805,L981,D637,L987,U403,R965,U724,L404,D664,L687,U868,L808,D174,L363,D241,L54,D238,R444,U75,R683,U712,L759,D569,R349,D378,L576,U437,R137,D822,R21,D595,L602,U147,R959,U350,R964,U625,L718,U331,L252,D386,L251,U371,R973,D709,R915,D837,L7,U727,L501,D520,L626,U161,L287,D224,L821,U555,L312,U234,L335,D572,L113,U673,L615,D919,R925,U16,R211,U77,R630,U786,R850,D221,R939,U559,R887,U779,L222,D482,L252,D682,L904,U568,R317,D453,R689,D917,R845,U260,R69,U613,R528,D447,L791,D119,L268,U215,L806,U786,R465,D787,L792,D823,R526,D709,L362,D748,L518,U115,L898,U784,R893,U911,R98,U215,R828,D100,R153,U496,L938,D403,R886,D317,L849,D59,R156,D27,L64,D771,R956,U880,R313,D244,L483,D17,R72,U467,L475,D444,R554,D781,R524,D152,L771,U435,L622,D601,R733,D478,L686,D12,L525,D467,L302,D948,L966,U572,L303,U914,R54,D417,R635,D425,R640,D703,R17,D187,L195,U59,R166,D616,L557,U458,L743,D166,R328,D640,R908,D775,L151,D216,L964,D202,L534,D239,R998,U167,L604,D812,L527,U526,L640,U93,L733,D980,R607,D879,L593,D721,R454,U137,R683,D343,L38,D398,L81,U392,R821,U247,L361,D208,R763,D771,L515

     

       2
       2
       +
       L1000,D189,L867,U824,L193,D12,R704,U83,R371,D858,L970,D56,R877,D448,R962,U239,R641,D198,L840,D413,R586,D920,R650,U919,R375,D540,L150,U995,R54,D200,R61,D974,R249,U893,R319,U930,R658,U680,R286,D186,R963,U553,L256,U629,L554,U576,R887,U595,R629,D680,L684,U556,L302,U348,R825,D252,L684,U705,L258,D72,R907,U702,L518,U440,R239,U258,R825,U27,L580,D613,R357,D468,R519,U833,L415,D822,L798,U904,R812,U76,R86,U252,R427,U637,L896,U147,L294,U381,R306,U423,L688,D336,R648,U677,L750,D218,L649,D360,R710,D64,R317,U232,R261,D167,L49,D138,L431,D505,L535,U294,L553,U969,L144,U227,R437,D397,R359,U848,L48,D992,R169,D580,L219,D525,R552,U546,R849,D722,R894,D735,L182,U570,R274,D349,R312,U430,R441,U183,R645,D308,L416,U333,L687,U202,L973,D736,R382,U260,L176,D207,R706,U52,L142,D746,L328,D413,R879,D429,L679,D695,L224,D462,R358,D124,L515,D629,L873,D759,L763,U28,R765,D426,L93,U927,L395,U243,L393,D488,L729,U100,R488,D83,R47,U92,L871,D410,R405,D993,R537,D10,L79,D218,L686,D563,L31,U885,L784,D462,L160,U345,R204,U275,R162,U164,R843,D578,R255,D456,L398,U470,L576,D973,L337,D971,R205,U264,R707,U975,L60,U270,R1,U808,R844,D884,L952,D435,L144,D374,R389,D741,R404,D398,R282,D807,L316,U136,L504,U720,R859,D925,L711,U343,L535,D978,R578,U636,L447,D298,R574,U590,L142,D802,L846,D617,L838,U362,R812,U295,L328,U162,L617,D857,L759,D251,L343,U394,R721,U320,R836,U726,L950,D612,R129,U549,L970,D87,L341,D269,L659,U550,R835,D318,L189,U278,R871,D62,R703,U807,L389,U824,R521,D175,L698,U313,L942,D810,L498,U18,R168,D111,R607

+57

2019/3/solution.exs

···

       1
       1
       +
       defmodule Wires do

     

       2
       2
       +
         @directions %{

     

       3
       3
       +
           ?U => :up,

     

       4
       4
       +
           ?D => :down,

     

       5
       5
       +
           ?R => :right,

     

       6
       6
       +
           ?L => :left

     

       7
       7
       +
         }

     

       8
       8
       +
       

     

       9
       9
       +
         @moves %{

     

       10
       10
       +
           up: {0, 1},

     

       11
       11
       +
           down: {0, -1},

     

       12
       12
       +
           right: {1, 0},

     

       13
       13
       +
           left: {-1, 0}

     

       14
       14
       +
         }

     

       15
       15
       +
       

     

       16
       16
       +
         def load(list) do

     

       17
       17
       +
           list

     

       18
       18
       +
           |> Enum.map(&parse/1)

     

       19
       19
       +
           |> wire()

     

       20
       20
       +
         end

     

       21
       21
       +
       

     

       22
       22
       +
         defp parse(<<c, rest::binary>>) do

     

       23
       23
       +
           {Map.fetch!(@directions, c), String.to_integer(rest)}

     

       24
       24
       +
         end

     

       25
       25
       +
       

     

       26
       26
       +
         defp wire(steps) do

     

       27
       27
       +
           steps

     

       28
       28
       +
           |> Enum.reduce({[], {0, 0}}, &into_coordinates/2)

     

       29
       29
       +
           |> elem(0)

     

       30
       30
       +
           |> MapSet.new()

     

       31
       31
       +
         end

     

       32
       32
       +
       

     

       33
       33
       +
         defp into_coordinates({_, 0}, {points, curr}), do: {[curr | points], curr}

     

       34
       34
       +
         defp into_coordinates({dir, n}, {points, {x, y}}) do

     

       35
       35
       +
           {dx, dy} = Map.fetch!(@moves, dir)

     

       36
       36
       +
           next = {x + dx, y + dy}

     

       37
       37
       +
       

     

       38
       38
       +
           into_coordinates({dir, n - 1}, {[next | points], next})

     

       39
       39
       +
         end

     

       40
       40
       +
       end

     

       41
       41
       +
       

     

       42
       42
       +
       w1 =

     

       43
       43
       +
         IO.read(:line)

     

       44
       44
       +
         |> String.trim()

     

       45
       45
       +
         |> String.split(",")

     

       46
       46
       +
         |> Wires.load()

     

       47
       47
       +
       w2 =

     

       48
       48
       +
         IO.read(:line)

     

       49
       49
       +
         |> String.trim()

     

       50
       50
       +
         |> String.split(",")

     

       51
       51
       +
         |> Wires.load()

     

       52
       52
       +
       

     

       53
       53
       +
       MapSet.intersection(w1, w2)

     

       54
       54
       +
       |> MapSet.to_list()

     

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

     

       56
       56
       +
       |> Enum.min()

     

       57
       57
       +
       |> IO.inspect()

+87

2020/day01.livemd

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 01

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

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

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIxIiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjAifQ","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("2020", "1", 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
       +
        "1706\n1466\n1427\n1744\n1684\n1386\n2001\n1750\n1753\n1770\n1559\n1616\n1408\n1860\n1940\n2002\n1862\n1918\n1456\n1209\n1840\n1462\n1783\n1644\n1901\n1791\n1506\n2005\n1338\n1383\n1420\n1631\n1784\n1897\n1771\n1588\n1955\n1937\n1392\n1396\n1803\n1429\n1407\n1698\n1562\n1913\n1678\n1198\n1398\n1703\n1831\n1489\n1782\n1864\n1708\n1397\n1915\n1953\n1395\n1610\n1549\n1564\n1973\n1931\n2009\n1980\n1800\n1443\n1993\n1900\n1964\n1581\n1904\n1665\n1567\n1057\n1805\n1402\n1878\n1729\n1825\n1682\n1719\n1469\n1004\n1591\n1594\n811\n1523\n1424\n1756\n373\n1442\n1718\n1411\n1892\n1820\n1977\n1871\n1890\n1653\n1372\n1475\n1476\n1422\n2004\n1755\n1676\n639\n1425\n1853\n1712\n1525\n1514\n1455\n1658\n1963\n1579\n1861\n1458\n1474\n1613\n1681\n1586\n1441\n1499\n1865\n1735\n1989\n1952\n792\n1669\n1509\n1481\n1893\n1445\n1834\n1779\n1732\n1826\n1595\n1829\n449\n1920\n1707\n1780\n1935\n1867\n1769\n1107\n919\n1382\n1604\n1875\n1453\n1496\n1946\n1659\n1570\n1692\n1630\n1638\n1922\n1691\n1580\n1880\n1482\n1762\n1775\n1376\n1434\n1856\n1971\n1646\n1951\n1416\n1889\n1773\n1814\n1471\n1488\n1736\n1743\n1459\n1389\n1498\n1663\n1611\n1727\n1699\n1624\n1511\n1767\n1754\n1785\n1491\n1235\n1510\n1500\n1485"}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       input =

     

       27
       27
       +
         puzzle_input

     

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

     

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

     

       30
       30
       +
         |> Enum.sort()

     

       31
       31
       +
       ```

     

       32
       32
       +
       

     

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

     

       34
       34
       +
       

     

       35
       35
       +
       ```

     

       36
       36
       +
       [373, 449, 639, 792, 811, 919, 1004, 1057, 1107, 1198, 1209, 1235, 1338, 1372, 1376, 1382, 1383,

     

       37
       37
       +
        1386, 1389, 1392, 1395, 1396, 1397, 1398, 1402, 1407, 1408, 1411, 1416, 1420, 1422, 1424, 1425,

     

       38
       38
       +
        1427, 1429, 1434, 1441, 1442, 1443, 1445, 1453, 1455, 1456, 1458, 1459, 1462, 1466, 1469, 1471,

     

       39
       39
       +
        1474, ...]

     

       40
       40
       +
       ```

     

       41
       41
       +
       

     

       42
       42
       +
       ```elixir

     

       43
       43
       +
       defmodule Report do

     

       44
       44
       +
         def find([], _, _), do: nil

     

       45
       45
       +
         def find(_, _, sum) when sum < 0, do: nil

     

       46
       46
       +
         def find([a | _], 1, a), do: [a]

     

       47
       47
       +
       

     

       48
       48
       +
         def find([a | rest], n, sum) do

     

       49
       49
       +
           case find(rest, n - 1, sum - a) do

     

       50
       50
       +
             nil -> find(rest, n, sum)

     

       51
       51
       +
             nums when is_list(nums) -> [a | nums]

     

       52
       52
       +
           end

     

       53
       53
       +
         end

     

       54
       54
       +
       end

     

       55
       55
       +
       ```

     

       56
       56
       +
       

     

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

     

       58
       58
       +
       

     

       59
       59
       +
       ```

     

       60
       60
       +
       {:module, Report, <<70, 79, 82, 49, 0, 0, 8, ...>>, {:find, 3}}

     

       61
       61
       +
       ```

     

       62
       62
       +
       

     

       63
       63
       +
       ## Part 1

     

       64
       64
       +
       

     

       65
       65
       +
       ```elixir

     

       66
       66
       +
       Report.find(input, 2, 2020) |> Enum.product()

     

       67
       67
       +
       ```

     

       68
       68
       +
       

     

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

     

       70
       70
       +
       

     

       71
       71
       +
       ```

     

       72
       72
       +
       980499

     

       73
       73
       +
       ```

     

       74
       74
       +
       

     

       75
       75
       +
       ## Part 2

     

       76
       76
       +
       

     

       77
       77
       +
       ```elixir

     

       78
       78
       +
       Report.find(input, 3, 2020) |> Enum.product()

     

       79
       79
       +
       ```

     

       80
       80
       +
       

     

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

     

       82
       82
       +
       

     

       83
       83
       +
       ```

     

       84
       84
       +
       200637446

     

       85
       85
       +
       ```

     

       86
       86
       +
       

     

       87
       87
       +
       <!-- livebook:{"offset":2857,"stamp":{"token":"XCP.XnJnYSRQgz2UOQ3-aY4Wm_4ac7Pe55mGzaFCONZvS7KA-jlyVQYcIKjXR6X8BV8b5w148g-6oYynzwJ-it0om0UAWkB3kajGGEYsa5LCmZRmUjW5iuT6zTZ5VoYqHjiwSc0","version":2}} -->

+133

2020/day02.livemd

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 02

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

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

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIyIiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjAifQ","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("2020", "2", 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
       +
        "5-10 b: bhbjlkbbbbbbb\n3-4 j: hjvj\n8-9 p: pmljtsttp\n3-4 t: hvtttqhdjmmnbqwbgfs\n4-6 m: mblwtzmvmdjkkmmtsckm\n6-9 f: ffffftfff\n1-3 g: xggg\n3-10 k: rwkhttkxxdpnlkq\n3-11 w: wwmwwwwwwwww\n5-7 f: fffffffff\n1-4 l: lglllbc\n2-5 n: njnnn\n6-8 t: tcjtltttttdttjttbt\n10-20 d: djddddccdbdddddddndd\n2-5 z: gzppzhrhzdthnpcr\n13-14 p: plvppptppppzppbkpk\n11-13 t: jjtjvzfhsrtsmkdhj\n11-12 r: rtrdvrrxrrxrzr\n2-6 x: dxsvxgvk\n7-11 x: hcxxpvxrnmxckkq\n12-17 s: sssssssssssrssssss\n2-4 v: vvpvvvjvvjvvqbvv\n15-18 h: thqhhhgjjqhhnhhznz\n8-11 j: jbmgbtmjtbb\n2-4 d: xxdfvp\n2-7 p: fftlppz\n9-13 d: dfddddddsdddds\n5-7 d: ddddddz\n2-3 h: hfbhhh\n1-4 k: rmkvkkkk\n16-17 w: wwwhwwwwwwwwwwwwq\n5-8 l: gllxllnlqlglrplk\n1-7 p: mhnpspp\n5-13 f: qhwffbtfzmdffztfjs\n2-8 f: fkjhvcbflbwhggtbbcb\n2-3 m: bcmldxmdh\n6-7 p: ppcpppw\n3-10 m: mmmmmmmmmj\n4-12 s: ssjssssssssmsss\n2-5 j: rmjnjtjjjj\n2-3 q: qqdqq\n10-15 v: vvvvvvvvvvvvvvdvvvvv\n1-4 w: wwwc\n4-14 m: mmsmmmvmmmmmqqmmmmm\n7-10 d: ddcdddzdddddd\n4-5 h: hhhhh\n9-17 p: ppppppppqppppppppp\n6-7 m: mqtmnms\n4-5 s: pssss\n2-6 t: tdttttpwttt\n7-8 l: llsxsllzlwl\n7-10 f: fflffffkqffffm\n3-4 f: cdfp\n3-4 z: zzzz\n6-7 s: sbssdvs\n3-4 g: ggdv\n11-16 l: lllllnbsqlfzwrfljkh\n3-4 k: tqkxxfk\n3-17 s: xshmvlmzrjdpnvlssn\n1-16 l: lzzvllgktckllmlltl\n5-6 l: qlltvl\n6-7 p: npvbpcp\n4-6 g: gmgvgn\n12-13 r: rrnlrrwrtvrrrrcrrrv\n11-12 h: hhvxhhhhwjhd\n13-14 p: pdppcsjtppppppvtwpj\n10-14 l: hljjkjxlfwzlllclzq\n18-19 z: zzzzzzzzzzzzzzztzhn\n11-12 p: hpspwrkqbnpp\n16-18 h: hhhhhhghhhhhhhhwhbh\n1-2 p: vpxnqqbgrxprmh\n13-19 m: mmmmmmmmmmmmqmmmmqm\n1-2 n: ncndsnl\n9-10 x: xxxxxxxxxgxxd\n9-12 w: wwwwwwwwwwzwwdfgwwp\n3-5 h: nqhvhzb\n4-5 j: jjjns\n10-12 f: ffffffffffff\n7-10 v: mgvrwvvsjw\n3-5 m: wpmmm\n3-10 s: ffsbvjdslsnshqs\n9-10 z: mgzzbjzqsz\n3-13 d: ddjdddddddddnd\n2-4 l: tqkfhpwvvmc\n1-3 z: zzzzzn\n3-5 l: ctljlckdpnlchrzbc\n6-7 v: hqvcvvv\n11-13 v: vvvvcvvvvvvvvvv\n8-9 t: ztndmlwdb\n5-6 v: fdxxrvwpw\n1-4 n: xnkb\n16-17 v: vvvvvvvvvvvvvvvvnvv\n12-14 b: bbbbbxbbbdbgbcb\n1-7 w: wwwwwwrwwjtwk\n3-10 d: bxnhbhrmgd\n4-5 k: kkknkk\n2-4 n: bndln\n3-10 p: vpkppcppppcplpksp\n9-10 d: fhbzbdzqsdxlhnbt\n11-13 z: zzmzzzzwzpzzz\n12-17 b: hkbcbbhthbrbbdgbl\n11-13 c: cpccnxccxbjtm\n5-6 n: nnrmnfnsnn\n3-8 l: sslkllwljcgl\n1-9 p: fpppzzpppppphtrhppp\n4-11 h: kskbvrqhdjph\n3-9 r: rsrvxnrchtrrrr\n4-5 n: nwbln\n3-4 g: gjgv\n13-14 r: rrrrrrsrtrrrrrrrr\n10-15 m: mmmmmmmmmtmmgmm\n5-6 k: wkpkkqk\n10-11 l: wlbllglkbltblrqlllm\n6-7 d: ddddsrddd\n17-18 v: vvvvvvvvvvvfvgvvsvv\n6-10 n: nngnnnnvnknn\n7-8 t: qdztnrnt\n5-11 d: dfbdxqbmsdd\n1-6 n: znnvqdnx\n7-9 k: kkkkkkkkl\n5-6 m: mmmszmtmmks\n1-5 l: wlllllll\n13-14 m: mcmmmmmlmmmmjmmm\n1-7 k: kklkjvckb\n14-15 d: ddddmddddmddddddd\n18-19 k: kfkkkkkkkkkkkkkkkpkk\n3-4 z: czjzc\n17-18 t: btttttjmltrttxctgt\n1-4 c: cccscqcccc\n9-14 k: tcwcstszkvhjfmrqpkp\n3-8 c: ccccccjcscncp\n10-11 d: dddddddddmdd\n3-5 m: rgmfmkmd\n1-5 k: mfhnk\n4-5 x: cwnxftlt\n1-3 n: flnqmnnhnn\n2-5 f: vwlcnsfd\n4-8 c: cccccccbc\n10-12 v: dhfvlvbvspjldzch\n7-16 f: ffsmffffjffqfpffff\n10-13 n: njtrrnnqntjtn\n13-17 f: frffcfffrjffffdfpff\n5-10 m: mmmmvfmmmmmmmmdm\n5-6 v: vvvvvzvvvvv\n6-12 r: dqrrcrhrhjsrrr\n8-14 z: zzzzzzzlzzzgzsz\n5-9 q: qkwzsvwdg\n12-13 d: vzjfvddgctfdrr\n6-7 f: mgndffb\n2-5 x: nxxmx\n7-9 c: cmxsccccf\n1-7 n: nnnnnnnnnn\n6-8 g: gggglfgp\n2-13 v: kvwxcrfmpfcfdrgv\n5-7 p: tpplpffpccpp\n8-12 m: mmmmmmmmmmmxm\n9-10 v: vvvvvvvvvcv\n4-5 m: mbnmmkknmmwshmkthj\n8-9 t: cltntrtpqwtcsftttf\n8-16 f: ffffrffpffffffffff\n6-8 t: sttcctttdttdwjdndtt\n5-9 k: ckkkkvdkvkk\n1-3 f: ffczfpgmf\n2-4 w: wwlwwd\n1-9 d: lddbhdddmtfdmdzdrdhd\n16-17 h: xfqlbhhpbnclvztzzzx\n2-7 r: rrbntqrrsrkrm\n1-4 r: qwrr\n12-14 b: tvbbzjbbbbbbbn\n5-7 h: hhjvghth\n2-3 d: dndrcx\n8-9 c: ccccscccpc\n5-8 s: srcsszcsp\n13-15 g: gggggggglggggglggggg\n11-13 b: bbbbbfrbfbbgbb\n1-8 b: jbbkqbbbpbbbbbbp\n11-14 n: nnnnnnnnnnmnnnn\n1-4 g: qsggg\n14-15 l: sllslllggllljkdlm\n1-5 s: pvssbspdsshsssssrs\n7-10 c: ccccccmcpgcc\n6-14 m: bcfkpmvmcmmjml\n1-3 n: ncnnnnn\n12-14 j: bjfjxjjpjrjjjxjjk\n10-12 v: vfvvvvvvqjvvvwvwt\n6-13 d: stddxdnjrddhwgdhrfjf\n5-6 w: qcwhnwwk\n2-3 x: mcxfxckptzvw\n12-20 b: lvgvbxsxxlvbhfcxbtzr\n1-2 d: ddbdqd\n5-10 h: mhtnjvhhhs\n2-6 z: ztzzdxzzzqbvg\n2-7 t: ttjkqztr\n3-4 g: bgvggrxrhtlklfj\n4-5 q: qqqvq\n1-3 c: ccpc\n4-6 j: jjrdjj\n8-11 c: ncvshccccccsb\n" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       data =

     

       27
       27
       +
         puzzle_input

     

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

     

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

     

       30
       30
       +
           [spec, pass] = String.split(input, ": ", parts: 2)

     

       31
       31
       +
           [range, char] = String.split(spec, " ", parts: 2)

     

       32
       32
       +
       

     

       33
       33
       +
           [min, max] =

     

       34
       34
       +
             range

     

       35
       35
       +
             |> String.split("-", parts: 2)

     

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

     

       37
       37
       +
       

     

       38
       38
       +
           {min..max, char, pass}

     

       39
       39
       +
         end)

     

       40
       40
       +
       ```

     

       41
       41
       +
       

     

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

     

       43
       43
       +
       

     

       44
       44
       +
       ```

     

       45
       45
       +
       [

     

       46
       46
       +
         {5..10, "b", "bhbjlkbbbbbbb"},

     

       47
       47
       +
         {3..4, "j", "hjvj"},

     

       48
       48
       +
         {8..9, "p", "pmljtsttp"},

     

       49
       49
       +
         {3..4, "t", "hvtttqhdjmmnbqwbgfs"},

     

       50
       50
       +
         {4..6, "m", "mblwtzmvmdjkkmmtsckm"},

     

       51
       51
       +
         {6..9, "f", "ffffftfff"},

     

       52
       52
       +
         {1..3, "g", "xggg"},

     

       53
       53
       +
         {3..10, "k", "rwkhttkxxdpnlkq"},

     

       54
       54
       +
         {3..11, "w", "wwmwwwwwwwww"},

     

       55
       55
       +
         {5..7, "f", "fffffffff"},

     

       56
       56
       +
         {1..4, "l", "lglllbc"},

     

       57
       57
       +
         {2..5, "n", "njnnn"},

     

       58
       58
       +
         {6..8, "t", "tcjtltttttdttjttbt"},

     

       59
       59
       +
         {10..20, "d", "djddddccdbdddddddndd"},

     

       60
       60
       +
         {2..5, "z", "gzppzhrhzdthnpcr"},

     

       61
       61
       +
         {13..14, "p", "plvppptppppzppbkpk"},

     

       62
       62
       +
         {11..13, "t", "jjtjvzfhsrtsmkdhj"},

     

       63
       63
       +
         {11..12, "r", "rtrdvrrxrrxrzr"},

     

       64
       64
       +
         {2..6, "x", "dxsvxgvk"},

     

       65
       65
       +
         {7..11, "x", "hcxxpvxrnmxckkq"},

     

       66
       66
       +
         {12..17, "s", "sssssssssssrssssss"},

     

       67
       67
       +
         {2..4, "v", "vvpvvvjvvjvvqbvv"},

     

       68
       68
       +
         {15..18, "h", "thqhhhgjjqhhnhhznz"},

     

       69
       69
       +
         {8..11, "j", "jbmgbtmjtbb"},

     

       70
       70
       +
         {2..4, "d", "xxdfvp"},

     

       71
       71
       +
         {2..7, "p", "fftlppz"},

     

       72
       72
       +
         {9..13, "d", "dfddddddsdddds"},

     

       73
       73
       +
         {5..7, "d", "ddddddz"},

     

       74
       74
       +
         {2..3, "h", "hfbhhh"},

     

       75
       75
       +
         {1..4, "k", "rmkvkkkk"},

     

       76
       76
       +
         {16..17, "w", "wwwhwwwwwwwwwwwwq"},

     

       77
       77
       +
         {5..8, "l", "gllxllnlqlglrplk"},

     

       78
       78
       +
         {1..7, "p", "mhnpspp"},

     

       79
       79
       +
         {5..13, "f", "qhwffbtfzmdffztfjs"},

     

       80
       80
       +
         {2..8, "f", "fkjhvcbflbwhggtbbcb"},

     

       81
       81
       +
         {2..3, "m", "bcmldxmdh"},

     

       82
       82
       +
         {6..7, "p", "ppcpppw"},

     

       83
       83
       +
         {3..10, "m", "mmmmmmmmmj"},

     

       84
       84
       +
         {4..12, "s", "ssjssssssssmsss"},

     

       85
       85
       +
         {2..5, "j", "rmjnjtjjjj"},

     

       86
       86
       +
         {2..3, "q", "qqdqq"},

     

       87
       87
       +
         {10..15, "v", "vvvvvvvvvvvvvvdvvvvv"},

     

       88
       88
       +
         {1..4, "w", "wwwc"},

     

       89
       89
       +
         {4..14, "m", "mmsmmmvmmmmmqqmmmmm"},

     

       90
       90
       +
         {7..10, "d", "ddcdddzdddddd"},

     

       91
       91
       +
         {4..5, "h", "hhhhh"},

     

       92
       92
       +
         {9..17, "p", "ppppppppqppppppppp"},

     

       93
       93
       +
         {6..7, "m", ...},

     

       94
       94
       +
         {4..5, ...},

     

       95
       95
       +
         {...},

     

       96
       96
       +
         ...

     

       97
       97
       +
       ]

     

       98
       98
       +
       ```

     

       99
       99
       +
       

     

       100
       100
       +
       ## Part 1

     

       101
       101
       +
       

     

       102
       102
       +
       ```elixir

     

       103
       103
       +
       Enum.count(data, fn {range, <<char>>, pass} ->

     

       104
       104
       +
         count = for <<^char <- pass>>, reduce: 0, do: (n -> n + 1)

     

       105
       105
       +
       

     

       106
       106
       +
         count in range

     

       107
       107
       +
       end)

     

       108
       108
       +
       ```

     

       109
       109
       +
       

     

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

     

       111
       111
       +
       

     

       112
       112
       +
       ```

     

       113
       113
       +
       439

     

       114
       114
       +
       ```

     

       115
       115
       +
       

     

       116
       116
       +
       ## Part 2

     

       117
       117
       +
       

     

       118
       118
       +
       ```elixir

     

       119
       119
       +
       Enum.count(data, fn {a..b//1, char, pass} ->

     

       120
       120
       +
         char_1 = binary_part(pass, a - 1, 1)

     

       121
       121
       +
         char_2 = binary_part(pass, b - 1, 1)

     

       122
       122
       +
       

     

       123
       123
       +
         char_1 != char_2 and char in [char_1, char_2]

     

       124
       124
       +
       end)

     

       125
       125
       +
       ```

     

       126
       126
       +
       

     

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

     

       128
       128
       +
       

     

       129
       129
       +
       ```

     

       130
       130
       +
       584

     

       131
       131
       +
       ```

     

       132
       132
       +
       

     

       133
       133
       +
       <!-- livebook:{"offset":7223,"stamp":{"token":"XCP.hfrcfr0pT-nj7-j4nWaJo4YFPkw0SkyS5kkbU0031loYsccpQ9B5PfrwwU0eiuPMlC2H5sN-qI3EDIk0RJZEkgYu4EvABNl_2k4g0_4hLnQxFsTtp8-IrIUPuzEQJLdGAJ4","version":2}} -->

+124

2020/day03.livemd

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 03

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

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

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIzIiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjAifQ","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("2020", "3", 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#..................#...........\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#....#........#....#...#.......\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#..............##...#....##....\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#.##.....##....#........#.#.#.#\n##.#.###.........##.......#..#.\n#.....#.....................#..\n.........##........#...........\n" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       slope =

     

       27
       27
       +
         puzzle_input

     

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

     

       29
       29
       +
       ```

     

       30
       30
       +
       

     

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

     

       32
       32
       +
       

     

       33
       33
       +
       ```

     

       34
       34
       +
       ["....#...##.#.........#....#....", "#.......#...#...#.#............",

     

       35
       35
       +
        "#..#..#.#.##....#.#........#...", "........##...................#.",

     

       36
       36
       +
        "........#...##...#.#.###.......", "##............#...#.....#.##...",

     

       37
       37
       +
        "...........#....###...#.....#..", ".......#......#..##..#.....#...",

     

       38
       38
       +
        "..#.#..#....#.........#...#..#.", ".........##......#.....##..##..",

     

       39
       39
       +
        "........#.....#....#..##......#", "..#..#.......#..............#..",

     

       40
       40
       +
        ".....#.#.......................", ".#.#....#.........#............",

     

       41
       41
       +
        ".......#.....#.###.............", "......##......#...........#..#.",

     

       42
       42
       +
        ".#...............##...#........", ".....#..##........###.........#",

     

       43
       43
       +
        "#...........#..#............#..", ".........#....#..#.#......#....",

     

       44
       44
       +
        ".......#.........#..##.........", ".##.....#..................#...",

     

       45
       45
       +
        "....#............#.#....#.....#", "..#....#...##....#...#.#...#...",

     

       46
       46
       +
        "..........#................#.#.", "#...#.#.#.####..#.#..........#.",

     

       47
       47
       +
        "..#...#.##......#...........#..", "..#.....#...#.......#......#..#",

     

       48
       48
       +
        "..............#.......#........", ".#..#..........#.....#...#..#.#",

     

       49
       49
       +
        "#........#...#......#.......#..", "#..................#...........",

     

       50
       50
       +
        "..#...#........#...#..#........", "..............#.....#.....#..#.",

     

       51
       51
       +
        "#.#.......#..............##.##.", "....#.#.....##....#...........#",

     

       52
       52
       +
        "......#....#...#..#.......#....", "....#..#.#.....#..##.....#....#",

     

       53
       53
       +
        "...........#.......#.#.#.......", "#.......#..##........#..#......",

     

       54
       54
       +
        ".........#.##..#..............#", "...........#............###.#..",

     

       55
       55
       +
        "..#.....#.....##...#.........#.", "....##............##........#..",

     

       56
       56
       +
        ".....###..........#......##....", "#...##..#..#..........#........",

     

       57
       57
       +
        "....#.....#.......#..#.#...##..", ".#....#........#.#.........#.#.",

     

       58
       58
       +
        "##...#.#.....#......#..........", ".....##.....#....#.....###.#..#", ...]

     

       59
       59
       +
       ```

     

       60
       60
       +
       

     

       61
       61
       +
       ```elixir

     

       62
       62
       +
       binary_slice("abc", 5, 1)

     

       63
       63
       +
       ```

     

       64
       64
       +
       

     

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

     

       66
       66
       +
       

     

       67
       67
       +
       ```

     

       68
       68
       +
       ""

     

       69
       69
       +
       ```

     

       70
       70
       +
       

     

       71
       71
       +
       ```elixir

     

       72
       72
       +
       defmodule Toboggan do

     

       73
       73
       +
         def slide(slope, {dx, dy}) do

     

       74
       74
       +
           slope

     

       75
       75
       +
           |> Enum.take_every(dy)

     

       76
       76
       +
           |> Enum.reduce({0, 0}, fn row, {pos, count} ->

     

       77
       77
       +
             dc = if binary_part(row, rem(pos, byte_size(row)), 1) == "#", do: 1, else: 0

     

       78
       78
       +
       

     

       79
       79
       +
             {pos + dx, count + dc}

     

       80
       80
       +
           end)

     

       81
       81
       +
           |> elem(1)

     

       82
       82
       +
         end

     

       83
       83
       +
       end

     

       84
       84
       +
       ```

     

       85
       85
       +
       

     

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

     

       87
       87
       +
       

     

       88
       88
       +
       ```

     

       89
       89
       +
       {:module, Toboggan, <<70, 79, 82, 49, 0, 0, 9, ...>>, {:slide, 2}}

     

       90
       90
       +
       ```

     

       91
       91
       +
       

     

       92
       92
       +
       ## Part 1

     

       93
       93
       +
       

     

       94
       94
       +
       ```elixir

     

       95
       95
       +
       Toboggan.slide(slope, {3, 1})

     

       96
       96
       +
       ```

     

       97
       97
       +
       

     

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

     

       99
       99
       +
       

     

       100
       100
       +
       ```

     

       101
       101
       +
       254

     

       102
       102
       +
       ```

     

       103
       103
       +
       

     

       104
       104
       +
       ## Part 2

     

       105
       105
       +
       

     

       106
       106
       +
       ```elixir

     

       107
       107
       +
       [

     

       108
       108
       +
         {1, 1},

     

       109
       109
       +
         {3, 1},

     

       110
       110
       +
         {5, 1},

     

       111
       111
       +
         {7, 1},

     

       112
       112
       +
         {1, 2}

     

       113
       113
       +
       ]

     

       114
       114
       +
       |> Enum.map(&Toboggan.slide(slope, &1))

     

       115
       115
       +
       |> Enum.product()

     

       116
       116
       +
       ```

     

       117
       117
       +
       

     

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

     

       119
       119
       +
       

     

       120
       120
       +
       ```

     

       121
       121
       +
       1666768320

     

       122
       122
       +
       ```

     

       123
       123
       +
       

     

       124
       124
       +
       <!-- livebook:{"offset":7450,"stamp":{"token":"XCP.NoSFu8ULnZhWAsLV6KwdSJblZR21o6kgNjJs3gczqJcYu7u7w_HScRZAL77iGr_ANQuyNyfr_CBU1KjRZ9e7nllBTnLxF6esiGCVXrSCKYPlWFFGN8VONns6BoBdQss9DU8","version":2}} -->

+484

2020/day04.livemd

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 04

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

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

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiI0Iiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjAifQ","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("2020", "4", 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
       +
        "hcl:#6b5442 ecl:brn iyr:2019\npid:637485594 hgt:171cm\neyr:2021 byr:1986\n\neyr:2025 iyr:1938 byr:2014 hcl:#341e13\nhgt:66cm\npid:70195175\n\nhcl:#efcc98\niyr:2011 ecl:hzl\neyr:2020 hgt:174cm pid:589700330\n\nhcl:#bba027 eyr:2027 cid:54\necl:brn pid:153cm\niyr:2028 hgt:173cm\nbyr:2004\n\nhcl:b45cec\niyr:2011 ecl:oth hgt:185cm eyr:2029 pid:178cm\n\nhgt:185cm iyr:2016 eyr:2029 hcl:#888785 pid:026540921\n\neyr:2025\nhcl:6962f7 byr:2015 ecl:oth iyr:1974\nhgt:191cm\npid:2616015\n\npid:268398556 iyr:2019 ecl:grn\neyr:2027 byr:1951 hcl:#18171d hgt:67cm\n\neyr:2029 hgt:153cm ecl:brn pid:183179186 byr:2013 hcl:#623a2f\niyr:1957\n\ncid:121 iyr:1922 hcl:752fbc pid:79577560 byr:2025\nhgt:61cm eyr:1971\n\niyr:2016\neyr:2024 hcl:#18171d hgt:184cm\necl:hzl byr:1992 pid:751161201\n\neyr:2021 ecl:blu byr:1938 iyr:2016 hcl:#b6652a pid:313406514 hgt:191cm\n\nhcl:#623a2f eyr:2021\necl:brn\npid:145249653 hgt:167cm iyr:2019 byr:1991\n\niyr:2022 pid:175cm\nbyr:2021 eyr:2027 ecl:#f615b1\nhgt:172in hcl:#ceb3a1\n\nhgt:173in\necl:#0cba5e pid:1885981567 iyr:1968\nbyr:1952\neyr:1942\n\necl:oth eyr:2023 hgt:65cm pid:521737908 byr:1971 hcl:z iyr:2017\n\nbyr:1936\nhcl:#cfa07d\necl:brn iyr:2011 pid:589047874\neyr:2025\n\nhcl:#fffffd\npid:912552538\ncid:159 hgt:160cm iyr:2012\neyr:2023 ecl:hzl\nbyr:1946\n\niyr:2015\necl:amb hgt:72in\ncid:59 pid:782818257 hcl:#18171d eyr:2026\nbyr:1952\n\nhgt:173cm iyr:2018 cid:96 ecl:amb byr:1986 pid:783160698 eyr:2026\nhcl:#602927\n\nhcl:#a97842 cid:199 pid:912273414 eyr:2030\nhgt:171cm ecl:hzl iyr:2011 byr:1960\n\necl:amb hgt:156cm\niyr:2013\nhcl:#ceb3a1\ncid:116 pid:567057004 byr:1942\neyr:2029\n\necl:#cddc40\npid:045090966 cid:254\nhgt:75in hcl:#733820 eyr:2026 byr:1956\niyr:2015\n\npid:156cm\neyr:2040\nhgt:176cm ecl:#02e67d hcl:b7c0e6\niyr:1959 cid:129 byr:2022\n\nhgt:160cm byr:1933\necl:blu eyr:2029 iyr:2012 hcl:#888785 pid:028571975\n\niyr:2017\nhcl:#390f37 hgt:171cm ecl:brn byr:1931 pid:015365720 eyr:2030\n\niyr:2014 pid:697057757\neyr:2026 hgt:188cm\necl:gry byr:1926\n\npid:484310015 hcl:#fffffd hgt:150cm iyr:2018\ncid:53 ecl:gry eyr:2021 byr:1957\n\nhgt:156cm\neyr:2026 byr:1963\npid:063272603 ecl:brn iyr:2011\nhcl:#888785\n\nbyr:1955 pid:310518398 hgt:191cm iyr:2018\necl:oth eyr:2023 cid:132 hcl:#888785\n\nbyr:1938 hcl:#623a2f eyr:2023\niyr:2010\nhgt:165cm\npid:170304863\ncid:290 ecl:amb\n\neyr:2026\npid:021468065 hgt:164cm\nbyr:1996 iyr:2016 hcl:#18171d\necl:brn\n\nbyr:2027 ecl:oth pid:8258823391 hgt:153in hcl:#733820 eyr:1948\n\nbyr:2026 ecl:#cd275a iyr:2012 eyr:2036 pid:5917499975\n\nbyr:2004\ncid:151\nhcl:99ecb1\neyr:2033 pid:871137711 iyr:1997\nhgt:184cm ecl:oth\n\nbyr:2011\nhcl:z ecl:#eee1d2 hgt:59cm eyr:1925 iyr:2030 pid:#02ee78\n\npid:742658992\nhcl:#888785\nbyr:1995\neyr:2024 hgt:162cm iyr:2013 cid:169 ecl:gry\n\nhgt:152cm byr:1946\neyr:2027 iyr:2018\npid:352799678\nhcl:#238da0\necl:amb\ncid:71\n\nhcl:#623a2f pid:723616064 eyr:2021\nhgt:172cm\nbyr:1926 iyr:2013\necl:grn\n\niyr:2019 hgt:94 byr:2028 eyr:1986\npid:#ee7f00\n\necl:amb\neyr:2027 pid:188153423 byr:1957 hcl:#d67ae1\niyr:2011 hgt:183cm\n\nbyr:1950 ecl:#e2495d iyr:2010 hgt:166cm eyr:2034 pid:151457075\n\neyr:1981\nbyr:2016 iyr:2029 pid:153cm ecl:#55c2a4 hcl:z\nhgt:76cm\n\nhgt:184cm ecl:amb eyr:2021\nhcl:#623a2f\npid:414607669 iyr:1960 byr:2002\n\neyr:2027 iyr:2020 hgt:179cm byr:1991\npid:969568248\necl:blu\n\nhgt:175cm pid:536803427 hcl:#a97842 iyr:2012\necl:grn byr:1950 eyr:2027\n\neyr:2028 hgt:60in hcl:#733820 iyr:2018 ecl:oth pid:871909483\nbyr:1930\n\nhgt:155cm iyr:2020 byr:1960 eyr:2021\npid:515710074 ecl:amb hcl:#341e13\n\nbyr:1922 hcl:z iyr:1977 ecl:brn\neyr:2023 hgt:119 pid:865700639\n\necl:gry hcl:959fcd pid:#633ac1\nbyr:2011 hgt:68in\neyr:2020\n\niyr:1972 hcl:z cid:149 byr:2020\nhgt:166in pid:4548657 eyr:1960\necl:#cc987c\n\neyr:2023 hcl:#b6652a iyr:2015\nhgt:187in pid:547953710 byr:1979 ecl:grn\n\niyr:2018\npid:508691429 ecl:oth eyr:2025 hgt:187cm cid:270\nhcl:#888785 byr:1977\n\nhgt:168cm eyr:2032 byr:2020\necl:gry iyr:1982\nhcl:z pid:648015564\n\nhcl:#fffffd pid:911858643 iyr:2016 ecl:gry eyr:2030 byr:1992 hgt:156cm\n\npid:241562994 eyr:2026 ecl:grn hgt:164cm\nhcl:#c0946f byr:1945 iyr:2015 cid:296\n\nbyr:1976 pid:269322775 ecl:hzl\nhgt:162cm hcl:#b6652a\neyr:2022 cid:335 iyr:2012\n\neyr:2028\nhgt:106\npid:268626219 hcl:#a97842\niyr:2011\necl:grn byr:" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       passports =

     

       27
       27
       +
         puzzle_input

     

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

     

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

     

       30
       30
       +
           passport

     

       31
       31
       +
           |> String.split(~r/\s/, trim: true)

     

       32
       32
       +
           |> Map.new(fn <<key::3-binary, ":", data::binary>> ->

     

       33
       33
       +
             {key, data}

     

       34
       34
       +
           end)

     

       35
       35
       +
         end)

     

       36
       36
       +
       ```

     

       37
       37
       +
       

     

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

     

       39
       39
       +
       

     

       40
       40
       +
       ```

     

       41
       41
       +
       [

     

       42
       42
       +
         %{

     

       43
       43
       +
           "byr" => "1986",

     

       44
       44
       +
           "ecl" => "brn",

     

       45
       45
       +
           "eyr" => "2021",

     

       46
       46
       +
           "hcl" => "#6b5442",

     

       47
       47
       +
           "hgt" => "171cm",

     

       48
       48
       +
           "iyr" => "2019",

     

       49
       49
       +
           "pid" => "637485594"

     

       50
       50
       +
         },

     

       51
       51
       +
         %{

     

       52
       52
       +
           "byr" => "2014",

     

       53
       53
       +
           "eyr" => "2025",

     

       54
       54
       +
           "hcl" => "#341e13",

     

       55
       55
       +
           "hgt" => "66cm",

     

       56
       56
       +
           "iyr" => "1938",

     

       57
       57
       +
           "pid" => "70195175"

     

       58
       58
       +
         },

     

       59
       59
       +
         %{

     

       60
       60
       +
           "ecl" => "hzl",

     

       61
       61
       +
           "eyr" => "2020",

     

       62
       62
       +
           "hcl" => "#efcc98",

     

       63
       63
       +
           "hgt" => "174cm",

     

       64
       64
       +
           "iyr" => "2011",

     

       65
       65
       +
           "pid" => "589700330"

     

       66
       66
       +
         },

     

       67
       67
       +
         %{

     

       68
       68
       +
           "byr" => "2004",

     

       69
       69
       +
           "cid" => "54",

     

       70
       70
       +
           "ecl" => "brn",

     

       71
       71
       +
           "eyr" => "2027",

     

       72
       72
       +
           "hcl" => "#bba027",

     

       73
       73
       +
           "hgt" => "173cm",

     

       74
       74
       +
           "iyr" => "2028",

     

       75
       75
       +
           "pid" => "153cm"

     

       76
       76
       +
         },

     

       77
       77
       +
         %{

     

       78
       78
       +
           "ecl" => "oth",

     

       79
       79
       +
           "eyr" => "2029",

     

       80
       80
       +
           "hcl" => "b45cec",

     

       81
       81
       +
           "hgt" => "185cm",

     

       82
       82
       +
           "iyr" => "2011",

     

       83
       83
       +
           "pid" => "178cm"

     

       84
       84
       +
         },

     

       85
       85
       +
         %{"eyr" => "2029", "hcl" => "#888785", "hgt" => "185cm", "iyr" => "2016", "pid" => "026540921"},

     

       86
       86
       +
         %{

     

       87
       87
       +
           "byr" => "2015",

     

       88
       88
       +
           "ecl" => "oth",

     

       89
       89
       +
           "eyr" => "2025",

     

       90
       90
       +
           "hcl" => "6962f7",

     

       91
       91
       +
           "hgt" => "191cm",

     

       92
       92
       +
           "iyr" => "1974",

     

       93
       93
       +
           "pid" => "2616015"

     

       94
       94
       +
         },

     

       95
       95
       +
         %{

     

       96
       96
       +
           "byr" => "1951",

     

       97
       97
       +
           "ecl" => "grn",

     

       98
       98
       +
           "eyr" => "2027",

     

       99
       99
       +
           "hcl" => "#18171d",

     

       100
       100
       +
           "hgt" => "67cm",

     

       101
       101
       +
           "iyr" => "2019",

     

       102
       102
       +
           "pid" => "268398556"

     

       103
       103
       +
         },

     

       104
       104
       +
         %{

     

       105
       105
       +
           "byr" => "2013",

     

       106
       106
       +
           "ecl" => "brn",

     

       107
       107
       +
           "eyr" => "2029",

     

       108
       108
       +
           "hcl" => "#623a2f",

     

       109
       109
       +
           "hgt" => "153cm",

     

       110
       110
       +
           "iyr" => "1957",

     

       111
       111
       +
           "pid" => "183179186"

     

       112
       112
       +
         },

     

       113
       113
       +
         %{

     

       114
       114
       +
           "byr" => "2025",

     

       115
       115
       +
           "cid" => "121",

     

       116
       116
       +
           "eyr" => "1971",

     

       117
       117
       +
           "hcl" => "752fbc",

     

       118
       118
       +
           "hgt" => "61cm",

     

       119
       119
       +
           "iyr" => "1922",

     

       120
       120
       +
           "pid" => "79577560"

     

       121
       121
       +
         },

     

       122
       122
       +
         %{

     

       123
       123
       +
           "byr" => "1992",

     

       124
       124
       +
           "ecl" => "hzl",

     

       125
       125
       +
           "eyr" => "2024",

     

       126
       126
       +
           "hcl" => "#18171d",

     

       127
       127
       +
           "hgt" => "184cm",

     

       128
       128
       +
           "iyr" => "2016",

     

       129
       129
       +
           "pid" => "751161201"

     

       130
       130
       +
         },

     

       131
       131
       +
         %{

     

       132
       132
       +
           "byr" => "1938",

     

       133
       133
       +
           "ecl" => "blu",

     

       134
       134
       +
           "eyr" => "2021",

     

       135
       135
       +
           "hcl" => "#b6652a",

     

       136
       136
       +
           "hgt" => "191cm",

     

       137
       137
       +
           "iyr" => "2016",

     

       138
       138
       +
           "pid" => "313406514"

     

       139
       139
       +
         },

     

       140
       140
       +
         %{

     

       141
       141
       +
           "byr" => "1991",

     

       142
       142
       +
           "ecl" => "brn",

     

       143
       143
       +
           "eyr" => "2021",

     

       144
       144
       +
           "hcl" => "#623a2f",

     

       145
       145
       +
           "hgt" => "167cm",

     

       146
       146
       +
           "iyr" => "2019",

     

       147
       147
       +
           "pid" => "145249653"

     

       148
       148
       +
         },

     

       149
       149
       +
         %{

     

       150
       150
       +
           "byr" => "2021",

     

       151
       151
       +
           "ecl" => "#f615b1",

     

       152
       152
       +
           "eyr" => "2027",

     

       153
       153
       +
           "hcl" => "#ceb3a1",

     

       154
       154
       +
           "hgt" => "172in",

     

       155
       155
       +
           "iyr" => "2022",

     

       156
       156
       +
           "pid" => "175cm"

     

       157
       157
       +
         },

     

       158
       158
       +
         %{

     

       159
       159
       +
           "byr" => "1952",

     

       160
       160
       +
           "ecl" => "#0cba5e",

     

       161
       161
       +
           "eyr" => "1942",

     

       162
       162
       +
           "hgt" => "173in",

     

       163
       163
       +
           "iyr" => "1968",

     

       164
       164
       +
           "pid" => "1885981567"

     

       165
       165
       +
         },

     

       166
       166
       +
         %{

     

       167
       167
       +
           "byr" => "1971",

     

       168
       168
       +
           "ecl" => "oth",

     

       169
       169
       +
           "eyr" => "2023",

     

       170
       170
       +
           "hcl" => "z",

     

       171
       171
       +
           "hgt" => "65cm",

     

       172
       172
       +
           "iyr" => "2017",

     

       173
       173
       +
           "pid" => "521737908"

     

       174
       174
       +
         },

     

       175
       175
       +
         %{

     

       176
       176
       +
           "byr" => "1936",

     

       177
       177
       +
           "ecl" => "brn",

     

       178
       178
       +
           "eyr" => "2025",

     

       179
       179
       +
           "hcl" => "#cfa07d",

     

       180
       180
       +
           "iyr" => "2011",

     

       181
       181
       +
           "pid" => "589047874"

     

       182
       182
       +
         },

     

       183
       183
       +
         %{

     

       184
       184
       +
           "byr" => "1946",

     

       185
       185
       +
           "cid" => "159",

     

       186
       186
       +
           "ecl" => "hzl",

     

       187
       187
       +
           "eyr" => "2023",

     

       188
       188
       +
           "hcl" => "#fffffd",

     

       189
       189
       +
           "hgt" => "160cm",

     

       190
       190
       +
           "iyr" => "2012",

     

       191
       191
       +
           "pid" => "912552538"

     

       192
       192
       +
         },

     

       193
       193
       +
         %{

     

       194
       194
       +
           "byr" => "1952",

     

       195
       195
       +
           "cid" => "59",

     

       196
       196
       +
           "ecl" => "amb",

     

       197
       197
       +
           "eyr" => "2026",

     

       198
       198
       +
           "hcl" => "#18171d",

     

       199
       199
       +
           "hgt" => "72in",

     

       200
       200
       +
           "iyr" => "2015",

     

       201
       201
       +
           "pid" => "782818257"

     

       202
       202
       +
         },

     

       203
       203
       +
         %{

     

       204
       204
       +
           "byr" => "1986",

     

       205
       205
       +
           "cid" => "96",

     

       206
       206
       +
           "ecl" => "amb",

     

       207
       207
       +
           "eyr" => "2026",

     

       208
       208
       +
           "hcl" => "#602927",

     

       209
       209
       +
           "hgt" => "173cm",

     

       210
       210
       +
           "iyr" => "2018",

     

       211
       211
       +
           "pid" => "783160698"

     

       212
       212
       +
         },

     

       213
       213
       +
         %{

     

       214
       214
       +
           "byr" => "1960",

     

       215
       215
       +
           "cid" => "199",

     

       216
       216
       +
           "ecl" => "hzl",

     

       217
       217
       +
           "eyr" => "2030",

     

       218
       218
       +
           "hcl" => "#a97842",

     

       219
       219
       +
           "hgt" => "171cm",

     

       220
       220
       +
           "iyr" => "2011",

     

       221
       221
       +
           "pid" => "912273414"

     

       222
       222
       +
         },

     

       223
       223
       +
         %{

     

       224
       224
       +
           "byr" => "1942",

     

       225
       225
       +
           "cid" => "116",

     

       226
       226
       +
           "ecl" => "amb",

     

       227
       227
       +
           "eyr" => "2029",

     

       228
       228
       +
           "hcl" => "#ceb3a1",

     

       229
       229
       +
           "hgt" => "156cm",

     

       230
       230
       +
           "iyr" => "2013",

     

       231
       231
       +
           "pid" => "567057004"

     

       232
       232
       +
         },

     

       233
       233
       +
         %{

     

       234
       234
       +
           "byr" => "1956",

     

       235
       235
       +
           "cid" => "254",

     

       236
       236
       +
           "ecl" => "#cddc40",

     

       237
       237
       +
           "eyr" => "2026",

     

       238
       238
       +
           "hcl" => "#733820",

     

       239
       239
       +
           "hgt" => "75in",

     

       240
       240
       +
           "iyr" => "2015",

     

       241
       241
       +
           "pid" => "045090966"

     

       242
       242
       +
         },

     

       243
       243
       +
         %{

     

       244
       244
       +
           "byr" => "2022",

     

       245
       245
       +
           "cid" => "129",

     

       246
       246
       +
           "ecl" => "#02e67d",

     

       247
       247
       +
           "eyr" => "2040",

     

       248
       248
       +
           "hcl" => "b7c0e6",

     

       249
       249
       +
           "hgt" => "176cm",

     

       250
       250
       +
           "iyr" => "1959",

     

       251
       251
       +
           "pid" => "156cm"

     

       252
       252
       +
         },

     

       253
       253
       +
         %{

     

       254
       254
       +
           "byr" => "1933",

     

       255
       255
       +
           "ecl" => "blu",

     

       256
       256
       +
           "eyr" => "2029",

     

       257
       257
       +
           "hcl" => "#888785",

     

       258
       258
       +
           "hgt" => "160cm",

     

       259
       259
       +
           "iyr" => "2012",

     

       260
       260
       +
           "pid" => "028571975"

     

       261
       261
       +
         },

     

       262
       262
       +
         %{

     

       263
       263
       +
           "byr" => "1931",

     

       264
       264
       +
           "ecl" => "brn",

     

       265
       265
       +
           "eyr" => "2030",

     

       266
       266
       +
           "hcl" => "#390f37",

     

       267
       267
       +
           "hgt" => "171cm",

     

       268
       268
       +
           "iyr" => "2017",

     

       269
       269
       +
           "pid" => "015365720"

     

       270
       270
       +
         },

     

       271
       271
       +
         %{

     

       272
       272
       +
           "byr" => "1926",

     

       273
       273
       +
           "ecl" => "gry",

     

       274
       274
       +
           "eyr" => "2026",

     

       275
       275
       +
           "hgt" => "188cm",

     

       276
       276
       +
           "iyr" => "2014",

     

       277
       277
       +
           "pid" => "697057757"

     

       278
       278
       +
         },

     

       279
       279
       +
         %{

     

       280
       280
       +
           "byr" => "1957",

     

       281
       281
       +
           "cid" => "53",

     

       282
       282
       +
           "ecl" => "gry",

     

       283
       283
       +
           "eyr" => "2021",

     

       284
       284
       +
           "hcl" => "#fffffd",

     

       285
       285
       +
           "hgt" => "150cm",

     

       286
       286
       +
           "iyr" => "2018",

     

       287
       287
       +
           "pid" => "484310015"

     

       288
       288
       +
         },

     

       289
       289
       +
         %{

     

       290
       290
       +
           "byr" => "1963",

     

       291
       291
       +
           "ecl" => "brn",

     

       292
       292
       +
           "eyr" => "2026",

     

       293
       293
       +
           "hcl" => "#888785",

     

       294
       294
       +
           "hgt" => "156cm",

     

       295
       295
       +
           "iyr" => "2011",

     

       296
       296
       +
           "pid" => "063272603"

     

       297
       297
       +
         },

     

       298
       298
       +
         %{

     

       299
       299
       +
           "byr" => "1955",

     

       300
       300
       +
           "cid" => "132",

     

       301
       301
       +
           "ecl" => "oth",

     

       302
       302
       +
           "eyr" => "2023",

     

       303
       303
       +
           "hcl" => "#888785",

     

       304
       304
       +
           "hgt" => "191cm",

     

       305
       305
       +
           "iyr" => "2018",

     

       306
       306
       +
           "pid" => "310518398"

     

       307
       307
       +
         },

     

       308
       308
       +
         %{

     

       309
       309
       +
           "byr" => "1938",

     

       310
       310
       +
           "cid" => "290",

     

       311
       311
       +
           "ecl" => "amb",

     

       312
       312
       +
           "eyr" => "2023",

     

       313
       313
       +
           "hcl" => "#623a2f",

     

       314
       314
       +
           "hgt" => "165cm",

     

       315
       315
       +
           "iyr" => "2010",

     

       316
       316
       +
           "pid" => "170304863"

     

       317
       317
       +
         },

     

       318
       318
       +
         %{

     

       319
       319
       +
           "byr" => "1996",

     

       320
       320
       +
           "ecl" => "brn",

     

       321
       321
       +
           "eyr" => "2026",

     

       322
       322
       +
           "hcl" => "#18171d",

     

       323
       323
       +
           "hgt" => "164cm",

     

       324
       324
       +
           "iyr" => "2016",

     

       325
       325
       +
           "pid" => "021468065"

     

       326
       326
       +
         },

     

       327
       327
       +
         %{

     

       328
       328
       +
           "byr" => "2027",

     

       329
       329
       +
           "ecl" => "oth",

     

       330
       330
       +
           "eyr" => "1948",

     

       331
       331
       +
           "hcl" => "#733820",

     

       332
       332
       +
           "hgt" => "153in",

     

       333
       333
       +
           "pid" => "8258823391"

     

       334
       334
       +
         },

     

       335
       335
       +
         %{"byr" => "2026", "ecl" => "#cd275a", "eyr" => "2036", "iyr" => "2012", "pid" => "5917499975"},

     

       336
       336
       +
         %{

     

       337
       337
       +
           "byr" => "2004",

     

       338
       338
       +
           "cid" => "151",

     

       339
       339
       +
           "ecl" => "oth",

     

       340
       340
       +
           "eyr" => "2033",

     

       341
       341
       +
           "hcl" => "99ecb1",

     

       342
       342
       +
           "hgt" => "184cm",

     

       343
       343
       +
           "iyr" => "1997",

     

       344
       344
       +
           "pid" => "871137711"

     

       345
       345
       +
         },

     

       346
       346
       +
         %{

     

       347
       347
       +
           "byr" => "2011",

     

       348
       348
       +
           "ecl" => "#eee1d2",

     

       349
       349
       +
           "eyr" => "1925",

     

       350
       350
       +
           "hcl" => "z",

     

       351
       351
       +
           "hgt" => "59cm",

     

       352
       352
       +
           "iyr" => "2030",

     

       353
       353
       +
           "pid" => "#02ee78"

     

       354
       354
       +
         },

     

       355
       355
       +
         %{

     

       356
       356
       +
           "byr" => "1995",

     

       357
       357
       +
           "cid" => "169",

     

       358
       358
       +
           "ecl" => "gry",

     

       359
       359
       +
           "eyr" => "2024",

     

       360
       360
       +
           "hcl" => "#888785",

     

       361
       361
       +
           "hgt" => "162cm",

     

       362
       362
       +
           "iyr" => "2013",

     

       363
       363
       +
           "pid" => "742658992"

     

       364
       364
       +
         },

     

       365
       365
       +
         %{

     

       366
       366
       +
           "byr" => "1946",

     

       367
       367
       +
           "cid" => "71",

     

       368
       368
       +
           "ecl" => "amb",

     

       369
       369
       +
           "eyr" => "2027",

     

       370
       370
       +
           "hcl" => "#238da0",

     

       371
       371
       +
           "hgt" => "152cm",

     

       372
       372
       +
           "iyr" => "2018",

     

       373
       373
       +
           "pid" => "352799678"

     

       374
       374
       +
         },

     

       375
       375
       +
         %{

     

       376
       376
       +
           "byr" => "1926",

     

       377
       377
       +
           "ecl" => "grn",

     

       378
       378
       +
           "eyr" => "2021",

     

       379
       379
       +
           "hcl" => "#623a2f",

     

       380
       380
       +
           "hgt" => "172cm",

     

       381
       381
       +
           "iyr" => "2013",

     

       382
       382
       +
           "pid" => "723616064"

     

       383
       383
       +
         },

     

       384
       384
       +
         %{"byr" => "2028", "eyr" => "1986", "hgt" => "94", "iyr" => "2019", "pid" => "#ee7f00"},

     

       385
       385
       +
         %{

     

       386
       386
       +
           "byr" => "1957",

     

       387
       387
       +
           "ecl" => "amb",

     

       388
       388
       +
           "eyr" => "2027",

     

       389
       389
       +
           "hcl" => "#d67ae1",

     

       390
       390
       +
           "hgt" => "183cm",

     

       391
       391
       +
           "iyr" => "2011",

     

       392
       392
       +
           "pid" => "188153423"

     

       393
       393
       +
         },

     

       394
       394
       +
         %{

     

       395
       395
       +
           "byr" => "1950",

     

       396
       396
       +
           "ecl" => "#e2495d",

     

       397
       397
       +
           "eyr" => "2034",

     

       398
       398
       +
           "hgt" => "166cm",

     

       399
       399
       +
           "iyr" => "2010",

     

       400
       400
       +
           "pid" => "151457075"

     

       401
       401
       +
         },

     

       402
       402
       +
         %{

     

       403
       403
       +
           "byr" => "2016",

     

       404
       404
       +
           "ecl" => "#55c2a4",

     

       405
       405
       +
           "eyr" => "1981",

     

       406
       406
       +
           "hcl" => "z",

     

       407
       407
       +
           "hgt" => "76cm",

     

       408
       408
       +
           "iyr" => "2029",

     

       409
       409
       +
           "pid" => "153cm"

     

       410
       410
       +
         },

     

       411
       411
       +
         %{

     

       412
       412
       +
           "byr" => "2002",

     

       413
       413
       +
           "ecl" => "amb",

     

       414
       414
       +
           "eyr" => "2021",

     

       415
       415
       +
           "hcl" => "#623a2f",

     

       416
       416
       +
           "hgt" => "184cm",

     

       417
       417
       +
           "iyr" => "1960",

     

       418
       418
       +
           ...

     

       419
       419
       +
         },

     

       420
       420
       +
         %{"byr" => "1991", "ecl" => "blu", "eyr" => "2027", "hgt" => "179cm", "iyr" => "2020", ...},

     

       421
       421
       +
         %{"byr" => "1950", "ecl" => "grn", "eyr" => "2027", "hcl" => "#a97842", ...},

     

       422
       422
       +
         %{"byr" => "1930", "ecl" => "oth", "eyr" => "2028", ...},

     

       423
       423
       +
         %{"byr" => "1960", "ecl" => "amb", ...},

     

       424
       424
       +
         %{"byr" => "1922", ...},

     

       425
       425
       +
         %{...},

     

       426
       426
       +
         ...

     

       427
       427
       +
       ]

     

       428
       428
       +
       ```

     

       429
       429
       +
       

     

       430
       430
       +
       ## Part 1

     

       431
       431
       +
       

     

       432
       432
       +
       ```elixir

     

       433
       433
       +
       Enum.count(passports, fn passport ->

     

       434
       434
       +
         required = ~w[byr iyr eyr hgt hcl ecl pid]

     

       435
       435
       +
         keys = Map.keys(passport)

     

       436
       436
       +
       

     

       437
       437
       +
         Enum.all?(required, & &1 in keys)

     

       438
       438
       +
       end)

     

       439
       439
       +
       ```

     

       440
       440
       +
       

     

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

     

       442
       442
       +
       

     

       443
       443
       +
       ```

     

       444
       444
       +
       196

     

       445
       445
       +
       ```

     

       446
       446
       +
       

     

       447
       447
       +
       ## Part 2

     

       448
       448
       +
       

     

       449
       449
       +
       ```elixir

     

       450
       450
       +
       defmodule Part2 do

     

       451
       451
       +
         def valid?(passport) do

     

       452
       452
       +
           [

     

       453
       453
       +
             year(passport["byr"]) in 1920..2002,

     

       454
       454
       +
             year(passport["iyr"]) in 2010..2020,

     

       455
       455
       +
             year(passport["eyr"]) in 2020..2030,

     

       456
       456
       +
             case hgt(passport["hgt"]) do

     

       457
       457
       +
               {cm, "cm"} -> cm in 150..193

     

       458
       458
       +
               {i, "in"} -> i in 59..79

     

       459
       459
       +
               _ -> false

     

       460
       460
       +
             end,

     

       461
       461
       +
             Map.get(passport, "hcl", "") =~ ~r/^#[0-9a-f]{6}$/,

     

       462
       462
       +
             passport["ecl"] in ~w[amb blu brn gry grn hzl oth],

     

       463
       463
       +
             Map.get(passport, "pid", "") =~ ~r/^\d{9}$/

     

       464
       464
       +
           ]

     

       465
       465
       +
           |> Enum.all?()

     

       466
       466
       +
         end

     

       467
       467
       +
       

     

       468
       468
       +
         defp year(nil), do: false

     

       469
       469
       +
         defp year(y), do: elem(Integer.parse(y), 0)

     

       470
       470
       +
       

     

       471
       471
       +
         defp hgt(nil), do: false

     

       472
       472
       +
         defp hgt(h), do: Integer.parse(h)

     

       473
       473
       +
       end

     

       474
       474
       +
       

     

       475
       475
       +
       Enum.count(passports, &Part2.valid?/1)

     

       476
       476
       +
       ```

     

       477
       477
       +
       

     

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

     

       479
       479
       +
       

     

       480
       480
       +
       ```

     

       481
       481
       +
       114

     

       482
       482
       +
       ```

     

       483
       483
       +
       

     

       484
       484
       +
       <!-- livebook:{"offset":13532,"stamp":{"token":"XCP.TTqFDnEDh1KcybgE2cRzHx79CkCBOfAe1WwEG3cX7vDTkxtUF55KF32ZCFPKqMdo3PkrQc384TMNDJTmch-aqQHkit7xUcJ8qMXwA33agDM5wcdBmkMyp1XHIbZz4GZrr3w","version":2}} -->

+105

2020/day05.livemd

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 05

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

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

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiI1Iiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjAifQ","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("2020", "5", 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
       +
        "FFBBFFFLRL\nFFBBFBBRRL\nFBBBFFBLRL\nBBFBFFBLRR\nBFBBBFFLLL\nBFBBBBBLLR\nFBFBFBFLLR\nBFBFBBFLLR\nFBBFBFBLLL\nBBBFBFBRLL\nBFBBBFBLRL\nFBBFFFBLLR\nBFFBFBFLRL\nFBBBBFBRLR\nFFBBBBBRRL\nFBBFBFFLRL\nFBBBBBBLLR\nFBBFBBBRRL\nFBBFFBFRLL\nFBFBBBBRRR\nBFFBFBFRRL\nBFBFBBBLLR\nFFFFBFBLRL\nFBFFBFFLRL\nFFBFBBBRRR\nFFBFFFFLRR\nFBBBFFFLLR\nFFFFFBFLLL\nBFFFFFFLRL\nFBBBBBFRLR\nBBBFFBBRRR\nFFFFBBBRLL\nFBFFBBBRLR\nBFBBBFFRRL\nBBFBBFBLRL\nBFBFBFFRRR\nBBFBFFFLLL\nFBFBFBFRRR\nBFBFBFFRRL\nBBFBBFBRRL\nFFBBFBFLRL\nFBFFFFFRLR\nFBBFFFBLLL\nFBBBBFFRLL\nFFBBBBBLLL\nBFFBBFFRLR\nFFFBBFBRRR\nFBBBFFFRLL\nFFFBFBFLRL\nBFFBBFFLRL\nBFBBBBBLRL\nBFFFFFBRRR\nFFFBBFBLRL\nFBBBFBFRLL\nFBBFBFBLRR\nBBFBBFFLRR\nFBFFBBFLLL\nFFFFFBBRLL\nFFBBFFBRLR\nBBFFFFFLLL\nBFFFFBFLRR\nFBFBBFFRRL\nBFBFFBBLLR\nFBBBFBBRLR\nBBBFBFFRLL\nBBFFBBFRLR\nFFBFFBBRLR\nFFBBBFBRLR\nBBBFFFBLRR\nBBFBFBFLRR\nBFBBBBBRLR\nBFFFFFBLLR\nFBFFBFFRLL\nBBBFFBBRLR\nFFBBBFBRRR\nBFBBBFBRLR\nFBFFFBBLRL\nFFFBFFFRLL\nBBFFBFFLLL\nBFFBBFFRRR\nFFBFBFBRRL\nFFBBBFBRRL\nFBBFFBBRLR\nFBFFBBFRLR\nBFBFFBBRRR\nBBFBFBBRLR\nFFBFFFFRRL\nBBFFBFFLLR\nFBBFBFBRRR\nBFBFBBBRRL\nFBFBFFBRRL\nFFFBBFFRLL\nBFBFFFFRRR\nFBBFFBFLLR\nFFBFBFFRLL\nFBFFBFBLLL\nFBFBFFFLRL\nBBFFFFFRRR\nFBFFBBFLRR\nFBFFFBFLRL\nFBBBFBBRRL\nBFFBFFFRLR\nFFBBBBFLLR\nBFFFFBFLRL\nBFFBFFBRRR\nFFBFBFBLRL\nBBFFFBBRLL\nFFBFBBFRRR\nFFFBFBFRRL\nFBFFBFBRRR\nFBBBBFBRRL\nFBFFFFFLLR\nFFBFFFFLLR\nFBBBBFFRLR\nBBBFFBBLRR\nBBBFFBFLRR\nFBBFBBBLRR\nFBBFBBFRRL\nFFFBFFBLLL\nFBFFFFBLLL\nBBFFFFBLLL\nFBFFFBFLRR\nFFBFBFFLRR\nBBFBFFFRLL\nFFFBBBFRLR\nFFBFFBBRLL\nBBBFBFFRRL\nBFFBBBBLRR\nBFFFFFFLLL\nBBBFFFBLLL\nFBBBBBFRLL\nFBBFBBBLLR\nBBFBFFFRRR\nBBFFFBBLLL\nFBBFFBFLRL\nBBFBFFFLRR\nBFBFFBFRLL\nBFFFBFBLLR\nBBBFBFBLLL\nBBBFFBFRLR\nFBFFBFBRLR\nBFBBFFFLLL\nBBFFFFBLRR\nBBFFFBBRRL\nBBBFBFFLLL\nBFBFFBFLLL\nFBBBBFFLLR\nFFBFFFFRLR\nFFBBBFBRLL\nBFFFFFFRRL\nBFBFFBBLRL\nBBFBBBFRLL\nBFFFBFFLLR\nBBFBFFBRLL\nBFBBFFFRLL\nBBFBBFBRLR\nFFFBBFBRLR\nBFFFBBFLRL\nFFBFFBFRLL\nFFFBFFBLRL\nBFBBBFFRLR\nBBBFFBBLRL\nBFFBBBBRRL\nFFBBFFFRLL\nBFBFFBFLRL\nBFFBBBBRRR\nBBFBFBFRRL\nBBBFFBFRRL\nBFFFBFBLRL\nFFFBFBFRLR\nFBFFBBBLRR\nFFFFBBBLLL\nBBBFBBFLLR\nBFFBFBFRRR\nBFBFFFBRRR\nBBFBBBBLLR\nFFBBBBBLRL\nFFBFFBFLRR\nFFBBBFBLRR\nBBFBBFBRRR\nFFFFFFBRRR\nBFBFBFBRRL\nBBFFBBBLRR\nBBFBFFFRLR\nFBBFBFBLLR\nBFBBFFBRLL\nFFFFBFBLLR\nBFBFFBBRLR\nFBFFFBFRRR\nBFFBFFFRLL\nFBBBFFFRRR\nFFFBBBFLLL\nFBBBBBBRRL\nFBBFFBBLLR\nBBBFBFFLRR\nBFBBFBFLRR\nFFFBBBBRRR\nBFFFBBFRLR\nFBFFBBFLLR\nFBFFFFFRRL\nBBBFBBFLLL\nBBBFFFFRLR\nFFFFBBBRRR\nFBBBFBBLLL\nBFFBFFBLLL\nFBFBBFBRLR\nFFBFFBBLLR\nFFFFBFFLRR\nFBBFFBFLLL\nFBFBBFBRRR\nBBBFBFBLLR\nBBFFBFBLLL\nFFBFFBFRLR\nFBBBFBBLRR\nBBFBBFBLLL\nFFBFFBFRRR\nFBBBBFFLRL\nBFBBFBFLLR\nFBFBBBFRLR\nBFBBFFBLLR\nFFFBBBFLLR\nFFFBBBFRRL\nBFFFBFBRLR\nBBBFBBFLRR\nBBFBBFFLLR\nBBFBBBBRLR\nFBBFFFFLRR\nFBFBBFFRLL\nFFBFFFFRRR\nFFFBBFFRRL\nFFFBBFBRRL\nFFFBFBFLLR\nFFBBBBFRRR\nBFFFFBBRRL\nBFFFFBFRRR\nBFBBBFBLRR\nFFBBFFFRRL\nFBBBBBBRRR\nBBFBFFBLLR\nFBFFFFBRLL\nBFBBFBFLLL\nFBFFFBBRLL\nFBBBFFBLLR\nBBFBBBFRLR\nFBFBBFBLRR\nFFFFFBFLLR\nFBFBBBFLRL\nFFBFFFBRRR\nFFFBBFFLRL\nBBBFFFFLLR\nBFBFFFFRRL\nFBFBFBBLLR\nFBBBFBFRRL\nBBFBBBBRRL\nBFBBFBFLRL\nBFFBBFFLLR\nBFBFFBBRLL\nFBFFBFFRLR\nFBFBFBFLRR\nBFBFBBFRRR\nFBBBBFBLRL\nFFBBBFFRRR\nFFBBFFBRLL\nFFBBBBBRLL\nFBFFFBFRRL\nFFFBBBFLRL\nBBBFBFFRRR\nFFFBFFFRRR\nFBFFBFFLLL\nFFBBFFBRRL\nBFFBFFBRRL\nFFBBBFFRLR\nBBBFFFFRRR\nBBFBFBBRRR\nFBFBBBBLRR\nBFBFBFBLLL\nFFBBFFBLLR\nBFFFBBBRLR\nBFBBFBBRLR\nBFFFFBBLLR\nFBFBFBBRLR\nBFFBBBFLLR\nFBFFBFBLRL\nBFBFBBBRLL\nBFBBBFFLRL\nFFFBFFFLRR\nBFFBBFBRLL\nFFBBBBFRLL\nBBFFFBBLLR\nFBFBFBFRLR\nBBBFFFBRLR\nBFFFFFBRLR\nBBBFFFFLLL\nFFFBBFBRLL\nBFFFFFBRRL\nFBFFBBBRRL\nFBFBFBBLLL\nFBFBBFBRRL\nFBBFBBBRRR\nBFBFFBBRRL\nFBBBBFBLLL\nFBBBBBBRLR\nBBFFFBFRRL\nFFFFBFBLLL\nFFFFBBFLRR\nFFFFBFFLRL\nBFFFBBFRLL\nBBFFFFBRRR\nBFBFFFFRLL\nBFFFFBFLLR\nBBBFFBBRRL\nBBFBBFBLLR\nBFFFFBFRLR\nFBBBFBFLLR\nFFFFFBBLRR\nBFBFFFFLRR\nFBFBBFFLRL\nFBFFFBBRRR\nBBFBBBFLRL\nBFBBBFFLLR\nBFBFBBFRRL\nFBFFFFBLRL\nFBBFBFFRLR\nBFBFBBBLRR\nBFBFBBFLRL\nBBFFBFFRLL\nFBFFBBBLRL\nBFBFBFFLLR\nFFFBFFBLLR\nFFFBFBBRRR\nBBFBFFFLLR\nFBBBFBFRLR\nFBFFBBBLLL\nFFBFBBFLRR\nFBFBFFFLLL\nBBFFFFFLRL\nFBFBBFBLRL\nBBFFFBFLLR\nBBFBBBBRRR\nBFBBBFFRRR\nFFFBFFBRLL\nFBBBFFFRLR\nBBBFBFBLRL\nFBFFFFBRLR\nBFFFFFBLLL\nFBFFFFBLLR\nBFBBFFBLRR\nBFBFBBBRRR\nBBBFBFBRRR\nFFFBBFFRRR\nFBBBFFFLRR\nBBFBFFFRRL\nBFBFBBFRLR\nBFFFBFBRLL\nFBFFFFFLLL\nFFFBBBBLRL\nFFFBBFFLLL\nFBFFFFBRRR\nFFBFBFBRLR\nBFBFFFBLRR\nBFFFBFBLLL\nFBBFBFFRLL\nFBFBFFFRLL\nFBBBFFBRRR\nFBBBFFBRLL\nFFBBFBBLLL\nFBBBBFBRRR\nBFBBBFBLLR\nFBBBBBFLLR\nFFBBFBFLRR\nBFFBBFBLLR\nFBFFFFBLRR\nBFFB" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       seats =

     

       27
       27
       +
         puzzle_input

     

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

     

       29
       29
       +
       ```

     

       30
       30
       +
       

     

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

     

       32
       32
       +
       

     

       33
       33
       +
       ```

     

       34
       34
       +
       ["FFBBFFFLRL", "FFBBFBBRRL", "FBBBFFBLRL", "BBFBFFBLRR", "BFBBBFFLLL", "BFBBBBBLLR", "FBFBFBFLLR",

     

       35
       35
       +
        "BFBFBBFLLR", "FBBFBFBLLL", "BBBFBFBRLL", "BFBBBFBLRL", "FBBFFFBLLR", "BFFBFBFLRL", "FBBBBFBRLR",

     

       36
       36
       +
        "FFBBBBBRRL", "FBBFBFFLRL", "FBBBBBBLLR", "FBBFBBBRRL", "FBBFFBFRLL", "FBFBBBBRRR", "BFFBFBFRRL",

     

       37
       37
       +
        "BFBFBBBLLR", "FFFFBFBLRL", "FBFFBFFLRL", "FFBFBBBRRR", "FFBFFFFLRR", "FBBBFFFLLR", "FFFFFBFLLL",

     

       38
       38
       +
        "BFFFFFFLRL", "FBBBBBFRLR", "BBBFFBBRRR", "FFFFBBBRLL", "FBFFBBBRLR", "BFBBBFFRRL", "BBFBBFBLRL",

     

       39
       39
       +
        "BFBFBFFRRR", "BBFBFFFLLL", "FBFBFBFRRR", "BFBFBFFRRL", "BBFBBFBRRL", "FFBBFBFLRL", "FBFFFFFRLR",

     

       40
       40
       +
        "FBBFFFBLLL", "FBBBBFFRLL", "FFBBBBBLLL", "BFFBBFFRLR", "FFFBBFBRRR", "FBBBFFFRLL", "FFFBFBFLRL",

     

       41
       41
       +
        "BFFBBFFLRL", ...]

     

       42
       42
       +
       ```

     

       43
       43
       +
       

     

       44
       44
       +
       ```elixir

     

       45
       45
       +
       defmodule Plane do

     

       46
       46
       +
         def lookup(<<>>, _directions, pos, 1), do: pos

     

       47
       47
       +
       

     

       48
       48
       +
         def lookup(<<curr>> <> rest, d, first, dist) do

     

       49
       49
       +
           dist = div(dist, 2)

     

       50
       50
       +
       

     

       51
       51
       +
           {nf, nl} =

     

       52
       52
       +
             if curr == d do

     

       53
       53
       +
               {first, dist}

     

       54
       54
       +
             else

     

       55
       55
       +
               {first + dist, dist}

     

       56
       56
       +
             end

     

       57
       57
       +
       

     

       58
       58
       +
           lookup(rest, d, nf, nl)

     

       59
       59
       +
         end

     

       60
       60
       +
       

     

       61
       61
       +
         def seat_no(id) do

     

       62
       62
       +
           {row, col} = String.split_at(id, 7)

     

       63
       63
       +
       

     

       64
       64
       +
           lookup(row, ?F, 0, 128) * 8 + lookup(col, ?L, 0, 8)

     

       65
       65
       +
         end

     

       66
       66
       +
       end

     

       67
       67
       +
       ```

     

       68
       68
       +
       

     

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

     

       70
       70
       +
       

     

       71
       71
       +
       ```

     

       72
       72
       +
       {:module, Plane, <<70, 79, 82, 49, 0, 0, 9, ...>>, {:seat_no, 1}}

     

       73
       73
       +
       ```

     

       74
       74
       +
       

     

       75
       75
       +
       ## Part 1

     

       76
       76
       +
       

     

       77
       77
       +
       ```elixir

     

       78
       78
       +
       seats

     

       79
       79
       +
       |> Enum.map(&Plane.seat_no/1)

     

       80
       80
       +
       |> Enum.max()

     

       81
       81
       +
       ```

     

       82
       82
       +
       

     

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

     

       84
       84
       +
       

     

       85
       85
       +
       ```

     

       86
       86
       +
       947

     

       87
       87
       +
       ```

     

       88
       88
       +
       

     

       89
       89
       +
       ## Part 2

     

       90
       90
       +
       

     

       91
       91
       +
       ```elixir

     

       92
       92
       +
       seats

     

       93
       93
       +
       |> Enum.sort()

     

       94
       94
       +
       |> Enum.map(&Plane.seat_no/1)

     

       95
       95
       +
       |> Enum.chunk_every(2, 1)

     

       96
       96
       +
       |> Enum.find_value(fn [a, b] -> if b == a + 2, do: a + 1 end)

     

       97
       97
       +
       ```

     

       98
       98
       +
       

     

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

     

       100
       100
       +
       

     

       101
       101
       +
       ```

     

       102
       102
       +
       636

     

       103
       103
       +
       ```

     

       104
       104
       +
       

     

       105
       105
       +
       <!-- livebook:{"offset":6707,"stamp":{"token":"XCP.jyVZ5mT4Eh93IIpxW_8l2Aemq91Tmk8CIwY-V3Z73RF3Qd7Yjct-IMJBfvB57vM_l06YF1tv55dZ73nE8aLIHN4OMmL-3l-vRTpT0Qs7Ks6Oc5tQDm2ynrANEp8xknTW7O4","version":2}} -->

+38 -11

2021/day01.livemd

···

       4
       4
        
       

     

       5
       5
        
       # Day 1

     

       6
       6
        
       

     

       7
       7
       +
       ```elixir

     

       8
       8
       +
       Mix.install([

     

       9
       9
       +
         {:kino_aoc, ">= 0.0.0"}

     

       10
       10
       +
       ])

     

       11
       11
       +
       ```

     

       12
       12
       +
       

     

       7
       13
        
       ## Load input

     

       8
       14
        
       

     

       15
       15
       +
       <!-- livebook:{"attrs":{"assign_to":"puzzle_input","day":"1","session_secret":"ADVENT_OF_CODE_SESSION","year":"2021"},"chunks":null,"kind":"Elixir.KinoAOC.HelperCell","livebook_object":"smart_cell"} -->

     

       16
       16
       +
       

     

       17
       17
       +
       ```elixir

     

       18
       18
       +
       {:ok, puzzle_input} =

     

       19
       19
       +
         KinoAOC.download_puzzle("2021", "1", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       20
       20
       +
       ```

     

       21
       21
       +
       

     

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

     

       23
       23
       +
       

     

       24
       24
       +
       ```

     

       25
       25
       +
       {:ok,

     

       26
       26
       +
        "173\n178\n179\n187\n196\n199\n200\n201\n210\n209\n210\n211\n221\n223\n235\n236\n237\n238\n242\n249\n247\n246\n256\n257\n258\n257\n258\n265\n293\n303\n304\n317\n322\n330\n336\n337\n340\n339\n350\n351\n352\n353\n349\n353\n342\n339\n341\n342\n348\n349\n350\n355\n362\n392\n388\n393\n404\n402\n401\n402\n405\n410\n411\n424\n425\n432\n434\n433\n435\n441\n420\n439\n461\n463\n464\n468\n469\n473\n485\n494\n493\n489\n490\n491\n497\n490\n491\n493\n519\n520\n553\n554\n560\n565\n574\n586\n599\n600\n601\n604\n578\n574\n578\n597\n598\n597\n607\n606\n608\n616\n613\n615\n618\n617\n619\n626\n638\n639\n650\n682\n686\n693\n696\n709\n715\n745\n747\n750\n751\n753\n760\n763\n764\n772\n776\n779\n791\n794\n795\n800\n799\n808\n814\n825\n826\n831\n830\n837\n853\n854\n863\n872\n873\n881\n885\n895\n896\n897\n895\n905\n909\n912\n916\n921\n919\n927\n929\n935\n936\n937\n948\n947\n948\n922\n926\n932\n931\n938\n958\n975\n977\n982\n985\n986\n987\n988\n1007\n1005\n1007\n1008\n1010\n1013\n1015\n1016\n1019\n1025\n1026\n1027\n1029\n1039\n1047\n1054\n1055\n1063\n1066\n1087\n1095\n1096\n1097\n1093\n1114\n1123\n1131\n1137\n1142\n1140\n1154\n1157\n1158\n1159\n1160\n1170\n1174\n1182\n1184\n1191\n1200\n1211\n1214\n1231\n1241\n1250\n1246\n1260\n1287\n1311\n1313\n1318\n1327\n1325\n1324\n1325\n1326\n1339\n1350\n1355\n1358\n1368\n1380\n1422\n1423\n1442\n1466\n1450\n1451\n1457\n1464\n1474\n1490\n1494\n1507\n1508\n1509\n1511\n1524\n1521\n1528\n1529\n1533\n1538\n1542\n1544\n1543\n1560\n1579\n1585\n1589\n1591\n1598\n1599\n1600\n1610\n1614\n1615\n1629\n1624\n1629\n1632\n1627\n1641\n1638\n1639\n1641\n1644\n1645\n1646\n1647\n1659\n1661\n1658\n1661\n1664\n1665\n1669\n1671\n1673\n1674\n1675\n1672\n1677\n1687\n1688\n1696\n1697\n1711\n1715\n1720\n1721\n1724\n1725\n1726\n1731\n1740\n1737\n1746\n1745\n1758\n1760\n1758\n1771\n1777\n1773\n1777\n1778\n1788\n1794\n1804\n1809\n1814\n1837\n1839\n1838\n1837\n1842\n1851\n1857\n1843\n1844\n1845\n1860\n1863\n1888\n1887\n1888\n1889\n1897\n1895\n1903\n1906\n1907\n1913\n1917\n1916\n1917\n1926\n1927\n1935\n1933\n1934\n1939\n1940\n1942\n1944\n1941\n1946\n1967\n1969\n1975\n1976\n1979\n1981\n1982\n1987\n1981\n1982\n1981\n1982\n1992\n2027\n2028\n2029\n2036\n2037\n2038\n2042\n2044\n2048\n2047\n2054\n2055\n2062\n2065\n2066\n2091\n2103\n2093\n2094\n2089\n2091\n2093\n2098\n2108\n2086\n2087\n2118\n2123\n2127\n2132\n2148\n2149\n2147\n2148\n2149\n2150\n2152\n2151\n2152\n2149\n2156\n2167\n2177\n2179\n2180\n2159\n2167\n2158\n2156\n2174\n2169\n2170\n2180\n2183\n2187\n2191\n2192\n2200\n2202\n2206\n2240\n2251\n2247\n2259\n2273\n2274\n2276\n2255\n2256\n2263\n2265\n2269\n2270\n2272\n2273\n2275\n2276\n2281\n2290\n2292\n2293\n2287\n2291\n2289\n2287\n2290\n2306\n2307\n2310\n2315\n2329\n2337\n2370\n2375\n2373\n2376\n2362\n2397\n2400\n2401\n2419\n2429\n2435\n2438\n2450\n2451\n2481\n2482\n2487\n2491\n2492\n2496\n2501\n2502\n2499\n2501\n2467\n2469\n2468\n2470\n2473\n2480\n2481\n2488\n2500\n2506\n2509\n2512\n2513\n2515\n2516\n2512\n2506\n2511\n2513\n2514\n2519\n2547\n2580\n2584\n2585\n2582\n2599\n2600\n2599\n2600\n2599\n2600\n2613\n2612\n2610\n2612\n2608\n2615\n2622\n2610\n2613\n2608\n2619\n2640\n2620\n2612\n2608\n2609\n2625\n2626\n2634\n2638\n2670\n2674\n2675\n2674\n2678\n2685\n2686\n2678\n2692\n2693\n2716\n2718\n2705\n2709\n2713\n2714\n2715\n2722\n2712\n2714\n2719\n2720\n2740\n2741\n2734\n2738\n2764\n2765\n2768\n2773\n2777\n2810\n2789\n2808\n2807\n2813\n2828\n2841\n2853\n2854\n2842\n2843\n2846\n2848\n2860\n2861\n2862\n2864\n2865\n2866\n2880\n2851\n2853\n2858\n2865\n2866\n2873\n2885\n2886\n2887\n2893\n2914\n2916\n2924\n2925\n2927\n2929\n2949\n2967\n2968\n2976\n2965\n2983\n2985\n2984\n2991\n2993\n3007\n3005\n3012\n3015\n3019\n3025\n3030\n3034\n3043\n3044\n3085\n3094\n3124\n3139\n3146\n3147\n3176\n3196\n3199\n3200\n3246\n3251\n3254\n3286\n3280\n3287\n3289\n3288\n3290\n3294\n3306\n3307\n3309\n3312\n3327\n3325\n3334\n3333\n3335\n3357\n3374\n3380\n3392\n3393\n3406\n3416\n3417\n3431\n3418\n3439\n3452\n3468\n3469\n3474\n3490\n3489\n3490\n3491\n3513\n3512\n3513\n3514\n3515\n3516\n3517\n3513\n3514\n3508\n3520\n3522\n3521\n3520\n3531\n3533\n3545\n3546\n3554\n3558\n3559\n3560\n3565\n3578\n3570\n3573\n3574\n3580\n3592\n3593\n3594\n3595\n3596\n3617\n3625\n3624\n3626\n3629\n3635\n3634\n3640\n3661\n3668\n3671\n3674\n3675\n3679\n3688\n3692\n3698\n3700\n3696\n3697\n3701\n3707\n3697\n3699\n3703\n3702\n3700\n3711\n3714\n3715\n3716\n3722\n3741\n3751\n3752\n3759\n3782\n3785\n3786\n3787\n3799\n3807\n3810\n3809\n3816\n3794\n3796\n3800\n3804\n3810\n3812\n3813\n3821\n3822\n3840\n3851\n3866\n3867\n3875\n3895\n3913\n3905\n3917\n3918\n3913\n3921\n3927\n3931\n3936\n3957\n3956\n3958\n3959\n3980\n3979\n3986\n3997\n3988\n3989\n3990\n3994\n3995\n3999\n3993\n4024\n4022\n4018\n4019\n4031\n4032\n4033\n4043\n4045\n4047\n4048\n4058\n4067\n4077\n4069\n4070\n4080\n4087\n4113\n4118\n4123\n4128\n4132\n4144\n4149\n4152\n4131\n4160\n4175\n4176\n4177\n4176\n4179\n4191\n4196\n4201\n4202\n4205\n4214\n4216\n4217\n4210\n4212\n4216\n4217\n4220\n4219\n4220\n42" <> ...}

     

       27
       27
       +
       ```

     

       28
       28
       +
       

     

       9
       29
        
       ```elixir

     

       10
       30
        
       stream =

     

       11
       11
       -
         File.stream!("day1.txt")

     

       31
       31
       +
         puzzle_input

     

       32
       32
       +
         |> String.split()

     

       12
       33
        
         |> Stream.map(&String.to_integer(String.trim(&1)))

     

       13
       34
        
       ```

     

       14
       35
        
       

     

       15
       15
       -
       ```output

     

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

     

       37
       37
       +
       

     

       38
       38
       +
       ```

     

       16
       39
        
       #Stream<[

     

       17
       17
       -
         enum: %File.Stream{

     

       18
       18
       -
           line_or_bytes: :line,

     

       19
       19
       -
           modes: [:raw, :read_ahead, :binary],

     

       20
       20
       -
           path: "day1.txt",

     

       21
       21
       -
           raw: true

     

       22
       22
       -
         },

     

       23
       23
       -
         funs: [#Function<47.58486609/1 in Stream.map/2>]

     

       40
       40
       +
         enum: ["173", "178", "179", "187", "196", "199", "200", "201", "210", "209", "210", "211", "221",

     

       41
       41
       +
          "223", "235", "236", "237", "238", "242", "249", "247", "246", "256", "257", "258", "257", "258",

     

       42
       42
       +
          "265", "293", "303", "304", "317", "322", "330", "336", "337", "340", "339", "350", "351", "352",

     

       43
       43
       +
          "353", "349", "353", "342", "339", "341", "342", "348", ...],

     

       44
       44
       +
         funs: [#Function<48.53678557/1 in Stream.map/2>]

     

       24
       45
        
       ]>

     

       25
       46
        
       ```

     

       26
       47
        
       

     
···

       34
       55
        
       |> Enum.count(fn [a, b] -> a < b end)

     

       35
       56
        
       ```

     

       36
       57
        
       

     

       37
       37
       -
       ```output

     

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

     

       59
       59
       +
       

     

       60
       60
       +
       ```

     

       38
       61
        
       1688

     

       39
       62
        
       ```

     

       40
       63
        
       

     
···

       64
       87
        
       |> Enum.count(fn [a, _, _, b] -> a < b end)

     

       65
       88
        
       ```

     

       66
       89
        
       

     

       67
       67
       -
       ```output

     

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

     

       91
       91
       +
       

     

       92
       92
       +
       ```

     

       68
       93
        
       1728

     

       69
       94
        
       ```

     

       95
       95
       +
       

     

       96
       96
       +
       <!-- livebook:{"offset":6811,"stamp":{"token":"XCP.FvhtdtxXYvRknZpAwd7ATOS4B7IljsyPdpscD9AizNpEm35rzHOr6FxLlc7D5RuBsoDcHmWO_rDJI7khm9nmL4U_ebmCGJuAd_tnVXrljSHKDRHzwzLMZ_v6kJy6nqkgIA","version":2}} -->

+12 -4

2021/day17.livemd

···

       24
       24
        
       [a: a, b: b]

     

       25
       25
        
       ```

     

       26
       26
        
       

     

       27
       27
       -
       ```output

     

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

     

       28
       28
       +
       

     

       29
       29
       +
       ```

     

       28
       30
        
       target area: x=288..330, y=-96..-50

     

       29
       31
        
       ```

     

       30
       32
        
       

     

       31
       31
       -
       ```output

     

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

     

       34
       34
       +
       

     

       35
       35
       +
       ```

     

       32
       36
        
       [a: %{x: 288, y: -96}, b: %{x: 330, y: -50}]

     

       33
       37
        
       ```

     

       34
       38
        
       

     
···

       119
       123
        
       {v_y, v_y * (v_y + 1) / 2}

     

       120
       124
        
       ```

     

       121
       125
        
       

     

       122
       122
       -
       ```output

     

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

     

       127
       127
       +
       

     

       128
       128
       +
       ```

     

       123
       129
        
       {95, 4560.0}

     

       124
       130
        
       ```

     

       125
       131
        
       

     
···

       180
       186
        
       MapSet.size(pairs)

     

       181
       187
        
       ```

     

       182
       188
        
       

     

       183
       183
       -
       ```output

     

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

     

       190
       190
       +
       

     

       191
       191
       +
       ```

     

       184
       192
        
       3344

     

       185
       193
        
       ```

+15 -5

2021/day18.livemd

···

       12
       12
        
         |> Enum.map(&elem(Code.eval_string(&1), 0))

     

       13
       13
        
       ```

     

       14
       14
        
       

     

       15
       15
       -
       ```output

     

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

     

       16
       16
       +
       

     

       17
       17
       +
       ```

     

       16
       18
        
       [

     

       17
       19
        
         [[[6, [8, 3]], [2, 0]], [[[9, 5], [9, 1]], 3]],

     

       18
       20
        
         [[[9, [2, 2]], [5, 4]], [[[2, 2], [9, 6]], '\a\a']],

     
···

       133
       135
        
       end

     

       134
       136
        
       ```

     

       135
       137
        
       

     

       136
       136
       -
       ```output

     

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

     

       139
       139
       +
       

     

       140
       140
       +
       ```

     

       137
       141
        
       {:module, Day18, <<70, 79, 82, 49, 0, 0, 12, ...>>, {:magnitude, 1}}

     

       138
       142
        
       ```

     

       139
       143
        
       

     
···

       148
       152
        
       |> Day18.magnitude()

     

       149
       153
        
       ```

     

       150
       154
        
       

     

       151
       151
       -
       ```output

     

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

     

       156
       156
       +
       

     

       157
       157
       +
       ```

     

       152
       158
        
       [[[[7, 7], [7, 8]], [[8, 7], [0, 7]]], [[[6, 6], [6, 7]], 6]]

     

       153
       159
        
       ```

     

       154
       160
        
       

     

       155
       155
       -
       ```output

     

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

     

       162
       162
       +
       

     

       163
       163
       +
       ```

     

       156
       164
        
       3411

     

       157
       165
        
       ```

     

       158
       166
        
       

     
···

       169
       177
        
       end

     

       170
       178
        
       ```

     

       171
       179
        
       

     

       172
       172
       -
       ```output

     

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

     

       181
       181
       +
       

     

       182
       182
       +
       ```

     

       173
       183
        
       4680

     

       174
       184
        
       ```

+8 -17

2021/day19.livemd

···

       257
       257
        
                 end)

     

       258
       258
        
               end)

     

       259
       259
        
       

     

       260
       260
       -
             IO.inspect(time / 1_000_000)

     

       260
       260
       +
             # IO.inspect(time / 1_000_000)

     

       261
       261
        
       

     

       262
       262
        
             current = Day19.pairs(set)

     

       263
       263
        
       

     
···

       272
       272
        
                 {:halt, {set, scanners}}

     

       273
       273
        
       

     

       274
       274
        
               {joinable, later} ->

     

       275
       275
       -
                 IO.inspect({length(joinable), length(later)}, label: i)

     

       275
       275
       +
                 # IO.inspect({length(joinable), length(later)}, label: i)

     

       276
       276
        
                 {:cont, {set, joinable, later, scanners}}

     

       277
       277
        
             end

     

       278
       278
        
           end

     
···

       284
       284
        
       <!-- livebook:{"output":true} -->

     

       285
       285
        
       

     

       286
       286
        
       ```

     

       287
       287
       -
       0.005503

     

       288
       288
       -
       1: {5, 25}

     

       289
       289
       -
       0.029354

     

       290
       290
       -
       2: {5, 20}

     

       291
       291
       -
       0.067284

     

       292
       292
       -
       3: {7, 13}

     

       293
       293
       -
       0.195126

     

       294
       294
       -
       4: {6, 7}

     

       295
       295
       -
       0.292686

     

       296
       296
       -
       5: {5, 2}

     

       297
       297
       -
       0.374403

     

       298
       298
       -
       6: {1, 1}

     

       299
       299
       -
       0.074645

     

       300
       300
       -
       7: {1, 0}

     

       301
       301
       -
       0.090199

     

       287
       287
       +
       warning: variable "i" is unused (if the variable is not meant to be used, prefix it with an underscore)

     

       288
       288
       +
         2021/day19.livemd#cell:w7cczzbdb2mrwtou27usauoozuqydf3v:9

     

       289
       289
       +
       

     

       290
       290
       +
       warning: variable "time" is unused (if the variable is not meant to be used, prefix it with an underscore)

     

       291
       291
       +
         2021/day19.livemd#cell:w7cczzbdb2mrwtou27usauoozuqydf3v:10

     

       292
       292
       +
       

     

       302
       293
        
       ```

     

       303
       294
        
       

     

       304
       295
        
       <!-- livebook:{"output":true} -->

+9 -3

2021/day20.livemd

···

       128
       128
        
       img = Day20.Image.new(board)

     

       129
       129
        
       ```

     

       130
       130
        
       

     

       131
       131
       -
       ```output

     

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

     

       132
       132
       +
       

     

       133
       133
       +
       ```

     

       132
       134
        
       #Image<{100x100}

     

       133
       135
        
                                                                                                             

     

       134
       136
        
        █ █   █  ██  ████████   ██    █ █ ███ █ ██ ██   █  ███ █ ██ █ █  █  ██  ███    █  ██ ██    █   ██ █  

     
···

       244
       246
        
       |> Day20.Image.lighted()

     

       245
       247
        
       ```

     

       246
       248
        
       

     

       247
       247
       -
       ```output

     

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

     

       250
       250
       +
       

     

       251
       251
       +
       ```

     

       248
       252
        
       5179

     

       249
       253
        
       ```

     

       250
       254
        
       

     
···

       256
       260
        
       |> Day20.Image.lighted()

     

       257
       261
        
       ```

     

       258
       262
        
       

     

       259
       259
       -
       ```output

     

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

     

       264
       264
       +
       

     

       265
       265
       +
       ```

     

       260
       266
        
       16112

     

       261
       267
        
       ```

+12 -4

2021/day21.livemd

···

       17
       17
        
       {p1, p2}

     

       18
       18
        
       ```

     

       19
       19
        
       

     

       20
       20
       -
       ```output

     

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

     

       21
       21
       +
       

     

       22
       22
       +
       ```

     

       21
       23
        
       {3, 5}

     

       22
       24
        
       ```

     

       23
       25
        
       

     
···

       36
       38
        
       rounds * 3 * loser

     

       37
       39
        
       ```

     

       38
       40
        
       

     

       39
       39
       -
       ```output

     

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

     

       42
       42
       +
       

     

       43
       43
       +
       ```

     

       40
       44
        
       720750

     

       41
       45
        
       ```

     

       42
       46
        
       

     
···

       84
       88
        
       end

     

       85
       89
        
       ```

     

       86
       90
        
       

     

       87
       87
       -
       ```output

     

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

     

       92
       92
       +
       

     

       93
       93
       +
       ```

     

       88
       94
        
       {:module, Day21.Task2, <<70, 79, 82, 49, 0, 0, 12, ...>>, {:round, 3}}

     

       89
       95
        
       ```

     

       90
       96
        
       

     
···

       92
       98
        
       Day21.Task2.play(p1, p2)

     

       93
       99
        
       ```

     

       94
       100
        
       

     

       95
       95
       -
       ```output

     

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

     

       102
       102
       +
       

     

       103
       103
       +
       ```

     

       96
       104
        
       275067741811212

     

       97
       105
        
       ```

+12 -4

2021/day22.livemd

···

       21
       21
        
         end)

     

       22
       22
        
       ```

     

       23
       23
        
       

     

       24
       24
       -
       ```output

     

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

     

       25
       25
       +
       

     

       26
       26
       +
       ```

     

       25
       27
        
       [

     

       26
       28
        
         on: %{x: -40..7, y: -3..49, z: -48..6},

     

       27
       29
        
         on: %{x: -38..10, y: -11..37, z: -30..19},

     
···

       133
       135
        
       end

     

       134
       136
        
       ```

     

       135
       137
        
       

     

       136
       136
       -
       ```output

     

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

     

       139
       139
       +
       

     

       140
       140
       +
       ```

     

       137
       141
        
       {:module, Day22, <<70, 79, 82, 49, 0, 0, 18, ...>>, {:split, 2}}

     

       138
       142
        
       ```

     

       139
       143
        
       

     
···

       150
       154
        
       |> Day22.volume()

     

       151
       155
        
       ```

     

       152
       156
        
       

     

       153
       153
       -
       ```output

     

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

     

       158
       158
       +
       

     

       159
       159
       +
       ```

     

       154
       160
        
       556501

     

       155
       161
        
       ```

     

       156
       162
        
       

     
···

       162
       168
        
       |> Day22.volume()

     

       163
       169
        
       ```

     

       164
       170
        
       

     

       165
       165
       -
       ```output

     

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

     

       172
       172
       +
       

     

       173
       173
       +
       ```

     

       166
       174
        
       1217140271559773

     

       167
       175
        
       ```

+12 -4

2021/day23.livemd

···

       19
       19
        
         |> Map.new()

     

       20
       20
        
       ```

     

       21
       21
        
       

     

       22
       22
       -
       ```output

     

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

     

       23
       23
       +
       

     

       24
       24
       +
       ```

     

       23
       25
        
       %{a: [:d, :b], b: [:d, :a], c: [:c, :b], d: [:c, :a]}

     

       24
       26
        
       ```

     

       25
       27
        
       

     
···

       124
       126
        
       end

     

       125
       127
        
       ```

     

       126
       128
        
       

     

       127
       127
       -
       ```output

     

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

     

       130
       130
       +
       

     

       131
       131
       +
       ```

     

       128
       132
        
       warning: variable "depth" is unused (if the variable is not meant to be used, prefix it with an underscore)

     

       129
       133
        
         day23.livemd#cell:58: Day23.room_to_hall/3

     

       130
       134
        
       

     
···

       136
       140
        
       

     

       137
       141
        
       ```

     

       138
       142
        
       

     

       139
       139
       -
       ```output

     

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

     

       144
       144
       +
       

     

       145
       145
       +
       ```

     

       140
       146
        
       {:module, Day23, <<70, 79, 82, 49, 0, 0, 23, ...>>, {:cost, 4}}

     

       141
       147
        
       ```

     

       142
       148
        
       

     
···

       144
       150
        
       Day23.process(input)

     

       145
       151
        
       ```

     

       146
       152
        
       

     

       147
       147
       -
       ```output

     

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

     

       154
       154
       +
       

     

       155
       155
       +
       ```

     

       148
       156
        
       :inf

     

       149
       157
        
       ```

+397 -9

2021/day24.livemd

···

       19
       19
        
           end

     

       20
       20
        
         end

     

       21
       21
        
       

     

       22
       22
       -
         def evaluate(ops, input), do: evaluate(ops, Integer.digits(input), %{w: 0, x: 0, y: 0, z: 0})

     

       22
       22
       +
         def evaluate(ops, input), do: evaluate(ops, to_digits(input), %{w: 0, x: 0, y: 0, z: 0})

     

       23
       23
        
       

     

       24
       24
        
         defp evaluate([], _, regs), do: regs

     

       25
       25
       -
       

     

       26
       26
       -
         defp evaluate([:nop | rest], input, regs), do: evaluate(rest, input, regs)

     

       27
       25
        
       

     

       28
       26
        
         defp evaluate([{:inp, reg} | rest], [v | input], regs),

     

       29
       27
        
           do: evaluate(rest, input, %{regs | reg => v})

     
···

       48
       46
        
       

     

       49
       47
        
         defp get(imm, _regs) when is_integer(imm), do: imm

     

       50
       48
        
         defp get(reg, regs) when is_atom(reg), do: Map.get(regs, reg, 0)

     

       49
       49
       +
       

     

       50
       50
       +
         defp to_digits(int) when is_integer(int), do: Integer.digits(int)

     

       51
       51
       +
         defp to_digits(digits) when is_list(digits), do: digits

     

       51
       52
        
       end

     

       52
       53
        
       

     

       53
       54
        
       input =

     

       54
       54
       -
         File.stream!("day24.txt")

     

       55
       55
       +
         File.stream!("#{__DIR__}/day24.txt")

     

       55
       56
        
         |> Stream.map(&String.trim/1)

     

       56
       57
        
         |> Enum.map(&Day24.parse/1)

     

       57
       58
        
         |> IO.inspect(limit: :infinity)

     
···

       325
       326
        
       ```

     

       326
       327
        
       

     

       327
       328
        
       ```elixir

     

       328
       328
       -
       44..52 |> Enum.map(&rem(&1, 26))

     

       329
       329
       +
       digits =

     

       330
       330
       +
         Enum.chunk_while(

     

       331
       331
       +
         input,

     

       332
       332
       +
         [],

     

       333
       333
       +
         fn

     

       334
       334
       +
           {:inp, _} = inp, [] -> {:cont, [inp]}

     

       335
       335
       +
           {:inp, _} = inp, acc -> {:cont, Enum.reverse(acc), [inp]}

     

       336
       336
       +
           other, acc -> {:cont, [other | acc]}

     

       337
       337
       +
         end,

     

       338
       338
       +
         fn acc -> {:cont, Enum.reverse(acc), []} end

     

       339
       339
       +
       )

     

       329
       340
        
       ```

     

       330
       341
        
       

     

       331
       342
        
       <!-- livebook:{"output":true} -->

     

       332
       343
        
       

     

       333
       344
        
       ```

     

       334
       334
       -
       [18, 19, 20, 21, 22, 23, 24, 25, 0]

     

       345
       345
       +
       [

     

       346
       346
       +
         [

     

       347
       347
       +
           {:inp, :w},

     

       348
       348
       +
           {:mul, :x, 0},

     

       349
       349
       +
           {:add, :x, :z},

     

       350
       350
       +
           {:mod, :x, 26},

     

       351
       351
       +
           {:div, :z, 1},

     

       352
       352
       +
           {:add, :x, 11},

     

       353
       353
       +
           {:eql, :x, :w},

     

       354
       354
       +
           {:eql, :x, 0},

     

       355
       355
       +
           {:mul, :y, 0},

     

       356
       356
       +
           {:add, :y, 25},

     

       357
       357
       +
           {:mul, :y, :x},

     

       358
       358
       +
           {:add, :y, 1},

     

       359
       359
       +
           {:mul, :z, :y},

     

       360
       360
       +
           {:mul, :y, 0},

     

       361
       361
       +
           {:add, :y, :w},

     

       362
       362
       +
           {:add, :y, 16},

     

       363
       363
       +
           {:mul, :y, :x},

     

       364
       364
       +
           {:add, :z, :y}

     

       365
       365
       +
         ],

     

       366
       366
       +
         [

     

       367
       367
       +
           {:inp, :w},

     

       368
       368
       +
           {:mul, :x, 0},

     

       369
       369
       +
           {:add, :x, :z},

     

       370
       370
       +
           {:mod, :x, 26},

     

       371
       371
       +
           {:div, :z, 1},

     

       372
       372
       +
           {:add, :x, 12},

     

       373
       373
       +
           {:eql, :x, :w},

     

       374
       374
       +
           {:eql, :x, 0},

     

       375
       375
       +
           {:mul, :y, 0},

     

       376
       376
       +
           {:add, :y, 25},

     

       377
       377
       +
           {:mul, :y, :x},

     

       378
       378
       +
           {:add, :y, 1},

     

       379
       379
       +
           {:mul, :z, :y},

     

       380
       380
       +
           {:mul, :y, 0},

     

       381
       381
       +
           {:add, :y, :w},

     

       382
       382
       +
           {:add, :y, 11},

     

       383
       383
       +
           {:mul, :y, :x},

     

       384
       384
       +
           {:add, :z, :y}

     

       385
       385
       +
         ],

     

       386
       386
       +
         [

     

       387
       387
       +
           {:inp, :w},

     

       388
       388
       +
           {:mul, :x, 0},

     

       389
       389
       +
           {:add, :x, :z},

     

       390
       390
       +
           {:mod, :x, 26},

     

       391
       391
       +
           {:div, :z, 1},

     

       392
       392
       +
           {:add, :x, 13},

     

       393
       393
       +
           {:eql, :x, :w},

     

       394
       394
       +
           {:eql, :x, 0},

     

       395
       395
       +
           {:mul, :y, 0},

     

       396
       396
       +
           {:add, :y, 25},

     

       397
       397
       +
           {:mul, :y, :x},

     

       398
       398
       +
           {:add, :y, 1},

     

       399
       399
       +
           {:mul, :z, :y},

     

       400
       400
       +
           {:mul, :y, 0},

     

       401
       401
       +
           {:add, :y, :w},

     

       402
       402
       +
           {:add, :y, 12},

     

       403
       403
       +
           {:mul, :y, :x},

     

       404
       404
       +
           {:add, :z, :y}

     

       405
       405
       +
         ],

     

       406
       406
       +
         [

     

       407
       407
       +
           {:inp, :w},

     

       408
       408
       +
           {:mul, :x, 0},

     

       409
       409
       +
           {:add, :x, :z},

     

       410
       410
       +
           {:mod, :x, 26},

     

       411
       411
       +
           {:div, :z, 26},

     

       412
       412
       +
           {:add, :x, -5},

     

       413
       413
       +
           {:eql, :x, :w},

     

       414
       414
       +
           {:eql, :x, 0},

     

       415
       415
       +
           {:mul, :y, 0},

     

       416
       416
       +
           {:add, :y, 25},

     

       417
       417
       +
           {:mul, :y, :x},

     

       418
       418
       +
           {:add, :y, 1},

     

       419
       419
       +
           {:mul, :z, :y},

     

       420
       420
       +
           {:mul, :y, 0},

     

       421
       421
       +
           {:add, :y, :w},

     

       422
       422
       +
           {:add, :y, 12},

     

       423
       423
       +
           {:mul, :y, :x},

     

       424
       424
       +
           {:add, :z, :y}

     

       425
       425
       +
         ],

     

       426
       426
       +
         [

     

       427
       427
       +
           {:inp, :w},

     

       428
       428
       +
           {:mul, :x, 0},

     

       429
       429
       +
           {:add, :x, :z},

     

       430
       430
       +
           {:mod, :x, 26},

     

       431
       431
       +
           {:div, :z, 26},

     

       432
       432
       +
           {:add, :x, -3},

     

       433
       433
       +
           {:eql, :x, :w},

     

       434
       434
       +
           {:eql, :x, 0},

     

       435
       435
       +
           {:mul, :y, 0},

     

       436
       436
       +
           {:add, :y, 25},

     

       437
       437
       +
           {:mul, :y, :x},

     

       438
       438
       +
           {:add, :y, 1},

     

       439
       439
       +
           {:mul, :z, :y},

     

       440
       440
       +
           {:mul, :y, 0},

     

       441
       441
       +
           {:add, :y, :w},

     

       442
       442
       +
           {:add, :y, 12},

     

       443
       443
       +
           {:mul, :y, :x},

     

       444
       444
       +
           {:add, :z, :y}

     

       445
       445
       +
         ],

     

       446
       446
       +
         [

     

       447
       447
       +
           {:inp, :w},

     

       448
       448
       +
           {:mul, :x, 0},

     

       449
       449
       +
           {:add, :x, :z},

     

       450
       450
       +
           {:mod, :x, 26},

     

       451
       451
       +
           {:div, :z, 1},

     

       452
       452
       +
           {:add, :x, 14},

     

       453
       453
       +
           {:eql, :x, :w},

     

       454
       454
       +
           {:eql, :x, 0},

     

       455
       455
       +
           {:mul, :y, 0},

     

       456
       456
       +
           {:add, :y, 25},

     

       457
       457
       +
           {:mul, :y, :x},

     

       458
       458
       +
           {:add, :y, 1},

     

       459
       459
       +
           {:mul, :z, :y},

     

       460
       460
       +
           {:mul, :y, 0},

     

       461
       461
       +
           {:add, :y, :w},

     

       462
       462
       +
           {:add, :y, 2},

     

       463
       463
       +
           {:mul, :y, :x},

     

       464
       464
       +
           {:add, :z, :y}

     

       465
       465
       +
         ],

     

       466
       466
       +
         [

     

       467
       467
       +
           {:inp, :w},

     

       468
       468
       +
           {:mul, :x, 0},

     

       469
       469
       +
           {:add, :x, :z},

     

       470
       470
       +
           {:mod, :x, 26},

     

       471
       471
       +
           {:div, :z, 1},

     

       472
       472
       +
           {:add, :x, 15},

     

       473
       473
       +
           {:eql, :x, :w},

     

       474
       474
       +
           {:eql, :x, 0},

     

       475
       475
       +
           {:mul, :y, 0},

     

       476
       476
       +
           {:add, :y, 25},

     

       477
       477
       +
           {:mul, :y, :x},

     

       478
       478
       +
           {:add, :y, 1},

     

       479
       479
       +
           {:mul, :z, :y},

     

       480
       480
       +
           {:mul, :y, 0},

     

       481
       481
       +
           {:add, :y, :w},

     

       482
       482
       +
           {:add, :y, 11},

     

       483
       483
       +
           {:mul, :y, :x},

     

       484
       484
       +
           {:add, :z, :y}

     

       485
       485
       +
         ],

     

       486
       486
       +
         [

     

       487
       487
       +
           {:inp, :w},

     

       488
       488
       +
           {:mul, :x, 0},

     

       489
       489
       +
           {:add, :x, :z},

     

       490
       490
       +
           {:mod, :x, 26},

     

       491
       491
       +
           {:div, :z, 26},

     

       492
       492
       +
           {:add, :x, -16},

     

       493
       493
       +
           {:eql, :x, :w},

     

       494
       494
       +
           {:eql, :x, 0},

     

       495
       495
       +
           {:mul, :y, 0},

     

       496
       496
       +
           {:add, :y, 25},

     

       497
       497
       +
           {:mul, :y, :x},

     

       498
       498
       +
           {:add, :y, 1},

     

       499
       499
       +
           {:mul, :z, :y},

     

       500
       500
       +
           {:mul, :y, 0},

     

       501
       501
       +
           {:add, :y, :w},

     

       502
       502
       +
           {:add, :y, 4},

     

       503
       503
       +
           {:mul, :y, :x},

     

       504
       504
       +
           {:add, :z, :y}

     

       505
       505
       +
         ],

     

       506
       506
       +
         [

     

       507
       507
       +
           {:inp, :w},

     

       508
       508
       +
           {:mul, :x, 0},

     

       509
       509
       +
           {:add, :x, :z},

     

       510
       510
       +
           {:mod, :x, 26},

     

       511
       511
       +
           {:div, :z, 1},

     

       512
       512
       +
           {:add, :x, 14},

     

       513
       513
       +
           {:eql, :x, :w},

     

       514
       514
       +
           {:eql, :x, 0},

     

       515
       515
       +
           {:mul, :y, 0},

     

       516
       516
       +
           {:add, :y, 25},

     

       517
       517
       +
           {:mul, :y, :x},

     

       518
       518
       +
           {:add, :y, 1},

     

       519
       519
       +
           {:mul, :z, :y},

     

       520
       520
       +
           {:mul, :y, 0},

     

       521
       521
       +
           {:add, :y, :w},

     

       522
       522
       +
           {:add, :y, 12},

     

       523
       523
       +
           {:mul, :y, :x},

     

       524
       524
       +
           {:add, :z, :y}

     

       525
       525
       +
         ],

     

       526
       526
       +
         [

     

       527
       527
       +
           {:inp, :w},

     

       528
       528
       +
           {:mul, :x, 0},

     

       529
       529
       +
           {:add, :x, :z},

     

       530
       530
       +
           {:mod, :x, 26},

     

       531
       531
       +
           {:div, :z, 1},

     

       532
       532
       +
           {:add, :x, 15},

     

       533
       533
       +
           {:eql, :x, :w},

     

       534
       534
       +
           {:eql, :x, 0},

     

       535
       535
       +
           {:mul, :y, 0},

     

       536
       536
       +
           {:add, :y, 25},

     

       537
       537
       +
           {:mul, :y, :x},

     

       538
       538
       +
           {:add, :y, 1},

     

       539
       539
       +
           {:mul, :z, :y},

     

       540
       540
       +
           {:mul, :y, 0},

     

       541
       541
       +
           {:add, :y, :w},

     

       542
       542
       +
           {:add, :y, 9},

     

       543
       543
       +
           {:mul, :y, :x},

     

       544
       544
       +
           {:add, :z, :y}

     

       545
       545
       +
         ],

     

       546
       546
       +
         [

     

       547
       547
       +
           {:inp, :w},

     

       548
       548
       +
           {:mul, :x, 0},

     

       549
       549
       +
           {:add, :x, :z},

     

       550
       550
       +
           {:mod, :x, 26},

     

       551
       551
       +
           {:div, :z, 26},

     

       552
       552
       +
           {:add, :x, -7},

     

       553
       553
       +
           {:eql, :x, :w},

     

       554
       554
       +
           {:eql, :x, 0},

     

       555
       555
       +
           {:mul, :y, 0},

     

       556
       556
       +
           {:add, :y, 25},

     

       557
       557
       +
           {:mul, :y, :x},

     

       558
       558
       +
           {:add, :y, 1},

     

       559
       559
       +
           {:mul, :z, :y},

     

       560
       560
       +
           {:mul, :y, 0},

     

       561
       561
       +
           {:add, :y, :w},

     

       562
       562
       +
           {:add, :y, 10},

     

       563
       563
       +
           {:mul, :y, :x},

     

       564
       564
       +
           {:add, :z, :y}

     

       565
       565
       +
         ],

     

       566
       566
       +
         [

     

       567
       567
       +
           {:inp, :w},

     

       568
       568
       +
           {:mul, :x, 0},

     

       569
       569
       +
           {:add, :x, :z},

     

       570
       570
       +
           {:mod, :x, 26},

     

       571
       571
       +
           {:div, :z, 26},

     

       572
       572
       +
           {:add, :x, -11},

     

       573
       573
       +
           {:eql, :x, :w},

     

       574
       574
       +
           {:eql, :x, 0},

     

       575
       575
       +
           {:mul, :y, 0},

     

       576
       576
       +
           {:add, :y, 25},

     

       577
       577
       +
           {:mul, :y, :x},

     

       578
       578
       +
           {:add, :y, 1},

     

       579
       579
       +
           {:mul, :z, :y},

     

       580
       580
       +
           {:mul, :y, 0},

     

       581
       581
       +
           {:add, :y, :w},

     

       582
       582
       +
           {:add, :y, 11},

     

       583
       583
       +
           {:mul, :y, :x},

     

       584
       584
       +
           {:add, :z, :y}

     

       585
       585
       +
         ],

     

       586
       586
       +
         [

     

       587
       587
       +
           {:inp, :w},

     

       588
       588
       +
           {:mul, :x, 0},

     

       589
       589
       +
           {:add, :x, :z},

     

       590
       590
       +
           {:mod, :x, 26},

     

       591
       591
       +
           {:div, :z, 26},

     

       592
       592
       +
           {:add, :x, -6},

     

       593
       593
       +
           {:eql, :x, :w},

     

       594
       594
       +
           {:eql, :x, 0},

     

       595
       595
       +
           {:mul, :y, 0},

     

       596
       596
       +
           {:add, :y, 25},

     

       597
       597
       +
           {:mul, :y, :x},

     

       598
       598
       +
           {:add, :y, 1},

     

       599
       599
       +
           {:mul, :z, :y},

     

       600
       600
       +
           {:mul, :y, 0},

     

       601
       601
       +
           {:add, :y, :w},

     

       602
       602
       +
           {:add, :y, 6},

     

       603
       603
       +
           {:mul, :y, :x},

     

       604
       604
       +
           {:add, :z, :y}

     

       605
       605
       +
         ],

     

       606
       606
       +
         [

     

       607
       607
       +
           {:inp, :w},

     

       608
       608
       +
           {:mul, :x, 0},

     

       609
       609
       +
           {:add, :x, :z},

     

       610
       610
       +
           {:mod, :x, 26},

     

       611
       611
       +
           {:div, :z, 26},

     

       612
       612
       +
           {:add, :x, -11},

     

       613
       613
       +
           {:eql, :x, :w},

     

       614
       614
       +
           {:eql, :x, 0},

     

       615
       615
       +
           {:mul, :y, 0},

     

       616
       616
       +
           {:add, :y, 25},

     

       617
       617
       +
           {:mul, :y, :x},

     

       618
       618
       +
           {:add, :y, 1},

     

       619
       619
       +
           {:mul, :z, :y},

     

       620
       620
       +
           {:mul, :y, 0},

     

       621
       621
       +
           {:add, :y, :w},

     

       622
       622
       +
           {:add, :y, 15},

     

       623
       623
       +
           {:mul, :y, :x},

     

       624
       624
       +
           {:add, :z, :y}

     

       625
       625
       +
         ]

     

       626
       626
       +
       ]

     

       335
       627
        
       ```

     

       336
       628
        
       

     

       337
       629
        
       ```elixir

     

       338
       338
       -
       IO.inspect(Day24.evaluate(input, 11_111_111_111_161))

     

       630
       630
       +
       List.myers_difference(hd(digits), Enum.at(digits, 4))

     

       631
       631
       +
       ```

     

       632
       632
       +
       

     

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

     

       634
       634
       +
       

     

       635
       635
       +
       ```

     

       636
       636
       +
       [

     

       637
       637
       +
         eq: [{:inp, :w}, {:mul, :x, 0}, {:add, :x, :z}, {:mod, :x, 26}],

     

       638
       638
       +
         del: [{:div, :z, 1}, {:add, :x, 11}],

     

       639
       639
       +
         ins: [{:div, :z, 26}, {:add, :x, -3}],

     

       640
       640
       +
         eq: [

     

       641
       641
       +
           {:eql, :x, :w},

     

       642
       642
       +
           {:eql, :x, 0},

     

       643
       643
       +
           {:mul, :y, 0},

     

       644
       644
       +
           {:add, :y, 25},

     

       645
       645
       +
           {:mul, :y, :x},

     

       646
       646
       +
           {:add, :y, 1},

     

       647
       647
       +
           {:mul, :z, :y},

     

       648
       648
       +
           {:mul, :y, 0},

     

       649
       649
       +
           {:add, :y, :w}

     

       650
       650
       +
         ],

     

       651
       651
       +
         del: [{:add, :y, 16}],

     

       652
       652
       +
         ins: [{:add, :y, 12}],

     

       653
       653
       +
         eq: [{:mul, :y, :x}, {:add, :z, :y}]

     

       654
       654
       +
       ]

     

       655
       655
       +
       ```

     

       656
       656
       +
       

     

       657
       657
       +
       ```elixir

     

       658
       658
       +
       params =

     

       659
       659
       +
         Enum.map(digits, fn sub ->

     

       660
       660
       +
           [5, 15]

     

       661
       661
       +
           |> Enum.map(&Enum.at(sub, &1))

     

       662
       662
       +
           |> Enum.map(&elem(&1, 2))

     

       663
       663
       +
         end)

     

       664
       664
       +
       ```

     

       665
       665
       +
       

     

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

     

       667
       667
       +
       

     

       668
       668
       +
       ```

     

       669
       669
       +
       [

     

       670
       670
       +
         [11, 16],

     

       671
       671
       +
         ~c"\f\v",

     

       672
       672
       +
         ~c"\r\f",

     

       673
       673
       +
         [-5, 12],

     

       674
       674
       +
         [-3, 12],

     

       675
       675
       +
         [14, 2],

     

       676
       676
       +
         [15, 11],

     

       677
       677
       +
         [-16, 4],

     

       678
       678
       +
         [14, 12],

     

       679
       679
       +
         [15, 9],

     

       680
       680
       +
         [-7, 10],

     

       681
       681
       +
         [-11, 11],

     

       682
       682
       +
         [-6, 6],

     

       683
       683
       +
         [-11, 15]

     

       684
       684
       +
       ]

     

       685
       685
       +
       ```

     

       686
       686
       +
       

     

       687
       687
       +
       ```elixir

     

       688
       688
       +
       defmodule ALU do

     

       689
       689
       +
         def solve(params, range) do

     

       690
       690
       +
           params |> solve(0, [], range) |> Enum.reverse() |> Integer.undigits()

     

       691
       691
       +
         end

     

       692
       692
       +
       

     

       693
       693
       +
         defp solve([], _z, acc, _range), do: acc

     

       694
       694
       +
       

     

       695
       695
       +
         defp solve([[a, b] | rest], z, acc, range) when a > 0 do

     

       696
       696
       +
           Enum.find_value(range, fn w ->

     

       697
       697
       +
             solve(rest, 26 * z + w + b, [w | acc], range)

     

       698
       698
       +
           end)

     

       699
       699
       +
         end

     

       700
       700
       +
       

     

       701
       701
       +
         defp solve([[a, _] | rest], z, acc, range) when a < 0 do

     

       702
       702
       +
           value = rem(z, 26) + a

     

       703
       703
       +
       

     

       704
       704
       +
           if value in range do

     

       705
       705
       +
             solve(rest, div(z, 26), [value | acc], range)

     

       706
       706
       +
           end

     

       707
       707
       +
         end

     

       708
       708
       +
       end

     

       339
       709
        
       ```

     

       340
       710
        
       

     

       341
       711
        
       <!-- livebook:{"output":true} -->

     

       342
       712
        
       

     

       343
       713
        
       ```

     

       344
       344
       -
       %{w: 1, x: 1, y: 16, z: 207697766}

     

       714
       714
       +
       {:module, ALU, <<70, 79, 82, 49, 0, 0, 10, ...>>, {:solve, 4}}

     

       715
       715
       +
       ```

     

       716
       716
       +
       

     

       717
       717
       +
       ## Part 1

     

       718
       718
       +
       

     

       719
       719
       +
       ```elixir

     

       720
       720
       +
       ALU.solve(params, 9..1//-1)

     

       721
       721
       +
       ```

     

       722
       722
       +
       

     

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

     

       724
       724
       +
       

     

       725
       725
       +
       ```

     

       726
       726
       +
       41299994879959

     

       727
       727
       +
       ```

     

       728
       728
       +
       

     

       729
       729
       +
       ## Part 2

     

       730
       730
       +
       

     

       731
       731
       +
       ```elixir

     

       732
       732
       +
       ALU.solve(params, 1..9)

     

       345
       733
        
       ```

     

       346
       734
        
       

     

       347
       735
        
       <!-- livebook:{"output":true} -->

     

       348
       736
        
       

     

       349
       737
        
       ```

     

       350
       350
       -
       %{w: 1, x: 1, y: 16, z: 207697766}

     

       738
       738
       +
       11189561113216

     

       351
       739
        
       ```

+1 -1

2023/day04.livemd

···

       196
       196
        
       10378710

     

       197
       197
        
       ```

     

       198
       198
        
       

     

       199
       199
       -
       <!-- livebook:{"offset":11578,"stamp":{"token":"XCP.lXGe3Iu191OYuBQqrLXtyX10eAJRxaC7kWxJhXV-XwPuZXy80YHtfPI-uAobs5Ncg0KyodauGARY5zWPhVt6a96P5flHG1j0LHMDzRblFBObyqrIKaYaIlaYVVUXUtasrA","version":2}} -->

     

       199
       199
       +
       <!-- livebook:{"offset":11578,"stamp":{"token":"XCP.MkFlr54HtUrLxNpCiRslp5uHY2WvhZ1VtV-O2Kmdgys3ejH3O0uJAEJe8o8FxytUQyFTMJeefRatVMyr9J3CU3x5R4g7Ie-s_vb0vC-AepFre8COUMkA6Ws70S_FqoCSbA","version":2}} -->

+69 -318

2023/day05.livemd

···

       3
       3
        
       # Day 05

     

       4
       4
        
       

     

       5
       5
        
       ```elixir

     

       6
       6
       -
       Mix.install([:kino_aoc, {:range_set, path: "../range_set"}])

     

       6
       6
       +
       Mix.install([:kino_aoc, {:range_set, github: "hauleth/range_set"}])

     

       7
       7
        
       ```

     

       8
       8
        
       

     

       9
       9
        
       ## Parse

     
···

       23
       23
        
       ```

     

       24
       24
        
       

     

       25
       25
        
       ```elixir

     

       26
       26
       -
       puzzle_input =

     

       27
       27
       -
         """

     

       28
       28
       -
         seeds: 79 14 55 13

     

       26
       26
       +
       # puzzle_input =

     

       27
       27
       +
       """

     

       28
       28
       +
       seeds: 79 14 55 13

     

       29
       29
        
       

     

       30
       30
       -
         seed-to-soil map:

     

       31
       31
       -
         50 98 2

     

       32
       32
       -
         52 50 48

     

       30
       30
       +
       seed-to-soil map:

     

       31
       31
       +
       50 98 2

     

       32
       32
       +
       52 50 48

     

       33
       33
        
       

     

       34
       34
       -
         soil-to-fertilizer map:

     

       35
       35
       -
         0 15 37

     

       36
       36
       -
         37 52 2

     

       37
       37
       -
         39 0 15

     

       34
       34
       +
       soil-to-fertilizer map:

     

       35
       35
       +
       0 15 37

     

       36
       36
       +
       37 52 2

     

       37
       37
       +
       39 0 15

     

       38
       38
        
       

     

       39
       39
       -
         fertilizer-to-water map:

     

       40
       40
       -
         49 53 8

     

       41
       41
       -
         0 11 42

     

       42
       42
       -
         42 0 7

     

       43
       43
       -
         57 7 4

     

       39
       39
       +
       fertilizer-to-water map:

     

       40
       40
       +
       49 53 8

     

       41
       41
       +
       0 11 42

     

       42
       42
       +
       42 0 7

     

       43
       43
       +
       57 7 4

     

       44
       44
        
       

     

       45
       45
       -
         water-to-light map:

     

       46
       46
       -
         88 18 7

     

       47
       47
       -
         18 25 70

     

       45
       45
       +
       water-to-light map:

     

       46
       46
       +
       88 18 7

     

       47
       47
       +
       18 25 70

     

       48
       48
        
       

     

       49
       49
       -
         light-to-temperature map:

     

       50
       50
       -
         45 77 23

     

       51
       51
       -
         81 45 19

     

       52
       52
       -
         68 64 13

     

       49
       49
       +
       light-to-temperature map:

     

       50
       50
       +
       45 77 23

     

       51
       51
       +
       81 45 19

     

       52
       52
       +
       68 64 13

     

       53
       53
        
       

     

       54
       54
       -
         temperature-to-humidity map:

     

       55
       55
       -
         0 69 1

     

       56
       56
       -
         1 0 69

     

       54
       54
       +
       temperature-to-humidity map:

     

       55
       55
       +
       0 69 1

     

       56
       56
       +
       1 0 69

     

       57
       57
        
       

     

       58
       58
       -
         humidity-to-location map:

     

       59
       59
       -
         60 56 37

     

       60
       60
       -
         56 93 4

     

       61
       61
       -
         """

     

       62
       62
       -
         |> String.trim()

     

       58
       58
       +
       humidity-to-location map:

     

       59
       59
       +
       60 56 37

     

       60
       60
       +
       56 93 4

     

       61
       61
       +
       """

     

       62
       62
       +
       |> String.trim()

     

       63
       63
        
       ```

     

       64
       64
        
       

     

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

     
···

       72
       72
        
       defmodule Mapping do

     

       73
       73
        
         @behaviour Access

     

       74
       74
        
       

     

       75
       75
       +
         import Kernel, except: [apply: 2]

     

       76
       76
       +
       

     

       75
       77
        
         defstruct [:values]

     

       76
       78
        
       

     

       77
       79
        
         def from_list(lst) do

     

       78
       78
       -
           # true = Enum.all?(lst, fn {a, b} -> Range.size(a) == Range.size(b) end)

     

       79
       80
        
           %__MODULE__{values: Enum.sort(lst)}

     

       80
       81
        
         end

     

       81
       82
        
       

     

       82
       82
       -
         def squash(%__MODULE__{values: from}, %__MODULE__{values: to}) do

     

       83
       83
       -
           from_list(do_squash(from, to))

     

       84
       84
       -
         end

     

       85
       85
       -
       

     

       86
       86
       -
         defp do_squash([], rest), do: rest

     

       87
       87
       -
         defp do_squash(rest, []), do: rest

     

       88
       88
       -
       

     

       89
       89
       -
         #        a---b

     

       90
       90
       -
         # c---d

     

       91
       91
       -
         defp do_squash([{_src, a.._b} | _] = xs, [{_c..d, _out} = v | ys]) when d < a do

     

       92
       92
       -
           [v | do_squash(xs, ys)]

     

       93
       93
       -
         end

     

       94
       94
       -
       

     

       95
       95
       -
         # a---b

     

       96
       96
       -
         #        c---d

     

       97
       97
       -
         defp do_squash([{_src, _a..b} = v | xs], [{c.._d, _out} | _] = ys) when b < c do

     

       98
       98
       -
           [v | do_squash(xs, ys)]

     

       99
       99
       -
         end

     

       100
       100
       -
       

     

       101
       101
       -
         # a---b

     

       102
       102
       -
         # c---d

     

       103
       103
       -
         defp do_squash([{src, range} | xs], [{range, out} | ys]) do

     

       104
       104
       -
           [{src, out} | do_squash(xs, ys)]

     

       105
       105
       -
         end

     

       83
       83
       +
         defp apply({a.._, to}, v), do: v - a + to

     

       106
       84
        
       

     

       107
       107
       -
         # a------b

     

       108
       108
       -
         #   c--d

     

       109
       109
       -
         defp do_squash([{src, a..b} | xs], [{c..d, out} | ys]) when a <= c and b >= d do

     

       110
       110
       -
           range_match(src, [

     

       111
       111
       -
             a..(c - 1),

     

       112
       112
       -
             out,

     

       113
       113
       -
             (d + 1)..b

     

       114
       114
       -
           ])

     

       115
       115
       -
           |> Enum.concat(do_squash(xs, ys))

     

       85
       85
       +
         @impl Access

     

       86
       86
       +
         def fetch(%__MODULE__{values: list}, key) when is_integer(key) do

     

       87
       87
       +
           {:ok, sorted_find(list, key)}

     

       116
       88
        
         end

     

       117
       89
        
       

     

       118
       118
       -
         #   a--b

     

       119
       119
       -
         # c------d

     

       120
       120
       -
         defp do_squash([{src, a..b} | xs], [{c..d, out} | ys]) when a >= c and b <= d do

     

       121
       121
       -
           range_match(

     

       122
       122
       -
             [

     

       123
       123
       -
               c..(a - 1),

     

       124
       124
       -
               src,

     

       125
       125
       -
               (b + 1)..d

     

       126
       126
       -
             ],

     

       127
       127
       -
             out

     

       128
       128
       -
           )

     

       129
       129
       -
           |> Enum.concat(do_squash(xs, ys))

     

       90
       90
       +
         def fetch(%__MODULE__{values: map}, %RangeSet{ranges: ranges}) do

     

       91
       91
       +
           ranges

     

       92
       92
       +
           |> Enum.flat_map(&map_range(&1, map))

     

       93
       93
       +
           |> RangeSet.new()

     

       94
       94
       +
           |> then(&{:ok, &1})

     

       130
       95
        
         end

     

       131
       96
        
       

     

       132
       132
       -
         # a---b

     

       133
       133
       -
         #   c---d

     

       134
       134
       -
         defp do_squash([{src, a..b} | xs], [{c..d, out} | ys]) when c in a..b and b in c..d do

     

       135
       135
       -
           {s1, s2} = Range.split(src, Range.size(a..c) - 1)

     

       136
       136
       -
           {o1, o2} = Range.split(out, Range.size(c..b))

     

       97
       97
       +
         defp sorted_find([], n), do: n

     

       98
       98
       +
         defp sorted_find([{a..b, _} = result | _], n) when n in a..b, do: apply(result, n)

     

       99
       99
       +
         defp sorted_find([{a.._, _} | _], n) when n < a, do: n

     

       100
       100
       +
         defp sorted_find([_ | rest], n), do: sorted_find(rest, n)

     

       137
       101
        
       

     

       138
       138
       -
           [

     

       139
       139
       -
             {s1, a..(c - 1)},

     

       140
       140
       -
             {s2, o1},

     

       141
       141
       -
             {(b + 1)..d, o2}

     

       142
       142
       -
           ]

     

       143
       143
       -
           |> Enum.concat(do_squash(xs, ys))

     

       144
       144
       -
         end

     

       102
       102
       +
         defp map_range(range, []), do: [range]

     

       103
       103
       +
         defp map_range(_..hi = range, [{lo.._, _} | _]) when lo > hi, do: [range]

     

       104
       104
       +
         defp map_range(lo.._ = range, [{_..hi, _} | rest]) when lo > hi, do: map_range(range, rest)

     

       145
       105
        
       

     

       146
       146
       -
         #   a---b

     

       147
       147
       -
         # c---d

     

       148
       148
       -
         defp do_squash([{src, a..b} | xs], [{c..d, out} | ys]) when a > c and b > d do

     

       149
       149
       -
           IO.puts("foo")

     

       150
       150
       -
           {of, ol} = Range.split(out, Range.size(c..a) - 1)

     

       151
       151
       -
           {sf, sl} = Range.split(src, Range.size(a..d))

     

       106
       106
       +
         defp map_range(arg_range, [{fun_range, _} = fun_def | maps]) do

     

       107
       107
       +
           fun_lo..fun_hi = fun_range

     

       108
       108
       +
           arg_lo..arg_hi = arg_range

     

       109
       109
       +
           lo = max(fun_lo, arg_lo)

     

       110
       110
       +
           hi = min(fun_hi, arg_hi)

     

       152
       111
        
       

     

       153
       112
        
           [

     

       154
       154
       -
             {c..(a - 1), of},

     

       155
       155
       -
             {sf, ol},

     

       156
       156
       -
             {sl, (d + 1)..b}

     

       113
       113
       +
             apply(fun_def, lo)..apply(fun_def, hi)

     

       114
       114
       +
             | if(hi < arg_hi, do: map_range((hi + 1)..arg_hi, maps), else: [])

     

       157
       115
        
           ]

     

       158
       158
       -
           |> Enum.concat(do_squash(xs, ys))

     

       159
       159
       -
         end

     

       160
       160
       -
       

     

       161
       161
       -
         defp range_match(list, a.._) when is_list(list) do

     

       162
       162
       -
           Enum.reduce(list, {[], a}, fn

     

       163
       163
       -
             _.._//1 = range, {acc, s} ->

     

       164
       164
       -
               to = s + Range.size(range) - 1

     

       165
       165
       -
               {[{range, s..to} | acc], to + 1}

     

       166
       166
       -
       

     

       167
       167
       -
             _, acc ->

     

       168
       168
       -
               acc

     

       169
       169
       -
           end)

     

       170
       170
       -
           |> elem(0)

     

       171
       171
       -
         end

     

       172
       172
       -
       

     

       173
       173
       -
         defp range_match(_.._ = range, list) when is_list(list) do

     

       174
       174
       -
           for {a, b} <- range_match(list, range), do: {b, a}

     

       175
       175
       -
         end

     

       176
       176
       -
       

     

       177
       177
       -
         @impl Access

     

       178
       178
       -
         def fetch(%__MODULE__{values: list}, key) when is_integer(key) do

     

       179
       179
       -
           val =

     

       180
       180
       -
             with {a.._, b.._} <- Enum.find(list, key, fn {range, _} -> key in range end) do

     

       181
       181
       -
               key - a + b

     

       182
       182
       -
             end

     

       183
       183
       -
       

     

       184
       184
       -
           {:ok, val}

     

       185
       116
        
         end

     

       186
       117
        
       end

     

       187
       118
        
       

     
···

       198
       129
        
           |> Enum.map(&String.split/1)

     

       199
       130
        
           |> Enum.map(fn line ->

     

       200
       131
        
             [to, from, len] = Enum.map(line, &String.to_integer/1)

     

       201
       201
       -
             {from..(from + len - 1), to..(to + len - 1)}

     

       132
       132
       +
             {from..(from + len - 1), to}

     

       202
       133
        
           end)

     

       203
       134
        
           |> Mapping.from_list()

     

       204
       135
        
         end)

     

       205
       205
       -
       

     

       206
       206
       -
       [seed2soil, soil2fert, fert2water, water2light, light2temp, temp2hum, hum2loc] = mappings

     

       207
       136
        
       

     

       208
       137
        
       seeds =

     

       209
       138
        
         seeds

     
···

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

     

       227
       156
        
       

     

       228
       157
        
       ```

     

       229
       229
       -
       [79, 14, 55, 13]

     

       230
       230
       -
       ```

     

       231
       231
       -
       

     

       232
       232
       -
       ```elixir

     

       233
       233
       -
       a = Mapping.from_list([{1..10, 31..40}])

     

       234
       234
       -
       b = Mapping.from_list([{25..35, 65..75}])

     

       235
       235
       -
       

     

       236
       236
       -
       k = 30

     

       237
       237
       -
       

     

       238
       238
       -
       dbg(b[dbg(a[k])])

     

       239
       239
       -
       dbg(Mapping.squash(a, b))[k]

     

       240
       240
       -
       ```

     

       241
       241
       -
       

     

       242
       242
       -
       <!-- livebook:{"output":true} -->

     

       243
       243
       -
       

     

       244
       244
       -
       ```

     

       245
       245
       -
       30

     

       246
       246
       -
       ```

     

       247
       247
       -
       

     

       248
       248
       -
       <!-- livebook:{"output":true} -->

     

       249
       249
       -
       

     

       250
       250
       -
       ```

     

       251
       251
       -
       70

     

       252
       252
       -
       ```

     

       253
       253
       -
       

     

       254
       254
       -
       <!-- livebook:{"output":true} -->

     

       255
       255
       -
       

     

       256
       256
       -
       ```

     

       257
       257
       -
       foo

     

       258
       258
       -
       ```

     

       259
       259
       -
       

     

       260
       260
       -
       <!-- livebook:{"output":true} -->

     

       261
       261
       -
       

     

       262
       262
       -
       ```

     

       263
       263
       -
       %Mapping{values: [{1..5, 71..75}, {6..10, 36..40}, {25..30, 65..70}]}

     

       264
       264
       -
       ```

     

       265
       265
       -
       

     

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

     

       267
       267
       -
       

     

       268
       268
       -
       ```

     

       269
       269
       -
       70

     

       158
       158
       +
       [1310704671, 312415190, 1034820096, 106131293, 682397438, 30365957, 2858337556, 1183890307,

     

       159
       159
       +
        665754577, 13162298, 2687187253, 74991378, 1782124901, 3190497, 208902075, 226221606, 4116455504,

     

       160
       160
       +
        87808390, 2403629707, 66592398]

     

       270
       161
        
       ```

     

       271
       162
        
       

     

       272
       163
        
       ## Part 1

     
···

       280
       171
        
       <!-- livebook:{"output":true} -->

     

       281
       172
        
       

     

       282
       173
        
       ```

     

       283
       283
       -
       35

     

       284
       284
       -
       ```

     

       285
       285
       -
       

     

       286
       286
       -
       ```elixir

     

       287
       287
       -
       squashed = Enum.reduce(mappings, &Mapping.squash/2)

     

       174
       174
       +
       51752125

     

       288
       175
        
       ```

     

       289
       176
        
       

     

       290
       290
       -
       <!-- livebook:{"output":true} -->

     

       291
       291
       -
       

     

       292
       292
       -
       ```

     

       293
       293
       -
       foo

     

       294
       294
       -
       foo

     

       295
       295
       -
       foo

     

       296
       296
       -
       ```

     

       297
       297
       -
       

     

       298
       298
       -
       <!-- livebook:{"output":true} -->

     

       299
       299
       -
       

     

       300
       300
       -
       ```

     

       301
       301
       -
       %Mapping{

     

       302
       302
       -
         values: [

     

       303
       303
       -
           {0..0, 27..27},

     

       304
       304
       -
           {0..5, 28..33},

     

       305
       305
       -
           {1..10, 40..49},

     

       306
       306
       -
           {6..59, 7..60},

     

       307
       307
       -
           {7..10, 59..62},

     

       308
       308
       -
           {11..14, 52..55},

     

       309
       309
       -
           {11..52, 0..41},

     

       310
       310
       -
           {15..41, 0..26},

     

       311
       311
       -
           {18..24, 90..96},

     

       312
       312
       -
           {25..55, 18..48},

     

       313
       313
       -
           {45..58, 74..87},

     

       314
       314
       -
           {49..51, 34..36},

     

       315
       315
       -
           {52..53, 37..38},

     

       316
       316
       -
           {53..60, 49..56},

     

       317
       317
       -
           {54..56, 56..58},

     

       318
       318
       -
           {56..64, 61..69},

     

       319
       319
       -
           {59..63, 95..99},

     

       320
       320
       -
           {60..80, 53..73},

     

       321
       321
       -
           {61..67, 63..69},

     

       322
       322
       -
           {64..76, 70..82},

     

       323
       323
       -
           {65..92, 69..96},

     

       324
       324
       -
           {69..69, 39..39},

     

       325
       325
       -
           {77..99, 45..67},

     

       326
       326
       -
           {81..87, 83..89},

     

       327
       327
       -
           {93..96, 49..52},

     

       328
       328
       -
           {95..97, 97..99},

     

       329
       329
       -
           {98..99, 50..51}

     

       330
       330
       -
         ]

     

       331
       331
       -
       }

     

       332
       332
       -
       ```

     

       177
       177
       +
       ## Part 2

     

       333
       178
        
       

     

       334
       179
        
       ```elixir

     

       335
       180
        
       seeds

     

       336
       336
       -
       |> Enum.map(&squashed[&1])

     

       337
       337
       -
       |> Enum.min()

     

       181
       181
       +
       |> Enum.chunk_every(2)

     

       182
       182
       +
       |> Enum.map(fn [start, length] -> start..(start + length - 1) end)

     

       183
       183
       +
       |> RangeSet.new()

     

       184
       184
       +
       |> then(&Enum.reduce(mappings, &1, fn map, r -> map[r] end))

     

       185
       185
       +
       |> RangeSet.min()

     

       338
       186
        
       ```

     

       339
       187
        
       

     

       340
       188
        
       <!-- livebook:{"output":true} -->

     

       341
       189
        
       

     

       342
       190
        
       ```

     

       343
       343
       -
       14

     

       191
       191
       +
       12634632

     

       344
       192
        
       ```

     

       345
       193
        
       

     

       346
       346
       -
       ```elixir

     

       347
       347
       -
       Enum.map(seeds, &squashed[&1])

     

       348
       348
       -
       ```

     

       349
       349
       -
       

     

       350
       350
       -
       <!-- livebook:{"output":true} -->

     

       351
       351
       -
       

     

       352
       352
       -
       ```

     

       353
       353
       -
       [72, 15, 56, 14]

     

       354
       354
       -
       ```

     

       355
       355
       -
       

     

       356
       356
       -
       ```elixir

     

       357
       357
       -
       seeds =

     

       358
       358
       -
         Enum.chunk_every(seeds, 2)

     

       359
       359
       -
         |> Enum.map(fn [a, b] -> a..(a + b) end)

     

       360
       360
       -
         |> RangeSet.new()

     

       361
       361
       -
       

     

       362
       362
       -
       mappings

     

       363
       363
       -
       |> Enum.reduce(seeds, fn map, curr ->

     

       364
       364
       -
         IO.puts("")

     

       365
       365
       -
         IO.inspect(map, label: :map)

     

       366
       366
       -
         IO.inspect(curr, label: :curr)

     

       367
       367
       -
         inputs = RangeSet.new(for {from, _} <- map.values, do: from)

     

       368
       368
       -
         mapped = IO.inspect(RangeSet.intersection(inputs, curr), label: :inter)

     

       369
       369
       -
         left = IO.inspect(RangeSet.difference(curr, mapped), label: :diff)

     

       370
       370
       -
       

     

       371
       371
       -
         mapped =

     

       372
       372
       -
           mapped.ranges

     

       373
       373
       -
           |> Enum.map(fn a..b -> map[a]..map[b]//1 end)

     

       374
       374
       -
           |> RangeSet.new()

     

       375
       375
       -
           |> IO.inspect(label: :mapped)

     

       376
       376
       -
       

     

       377
       377
       -
         IO.inspect(RangeSet.union(left, mapped))

     

       378
       378
       -
       end)

     

       379
       379
       -
       ```

     

       380
       380
       -
       

     

       381
       381
       -
       <!-- livebook:{"output":true} -->

     

       382
       382
       -
       

     

       383
       383
       -
       ```

     

       384
       384
       -
       

     

       385
       385
       -
       map: %Mapping{values: [{50..97, 52..99}, {98..99, 50..51}]}

     

       386
       386
       -
       curr: RangeSet.new([55..68, 79..93])

     

       387
       387
       -
       inter: RangeSet.new([55..68, 79..93])

     

       388
       388
       -
       diff: RangeSet.new([])

     

       389
       389
       -
       mapped: RangeSet.new([57..70, 81..95])

     

       390
       390
       -
       RangeSet.new([57..70, 81..95])

     

       391
       391
       -
       

     

       392
       392
       -
       map: %Mapping{values: [{0..14, 39..53}, {15..51, 0..36}, {52..53, 37..38}]}

     

       393
       393
       -
       curr: RangeSet.new([57..70, 81..95])

     

       394
       394
       -
       inter: RangeSet.new([])

     

       395
       395
       -
       diff: RangeSet.new([57..70, 81..95])

     

       396
       396
       -
       mapped: RangeSet.new([])

     

       397
       397
       -
       RangeSet.new([57..70, 81..95])

     

       398
       398
       -
       

     

       399
       399
       -
       map: %Mapping{

     

       400
       400
       -
         values: [{0..6, 42..48}, {7..10, 57..60}, {11..52, 0..41}, {53..60, 49..56}]

     

       401
       401
       -
       }

     

       402
       402
       -
       curr: RangeSet.new([57..70, 81..95])

     

       403
       403
       -
       inter: RangeSet.new([57..60])

     

       404
       404
       -
       diff: RangeSet.new([61..70, 81..95])

     

       405
       405
       -
       mapped: RangeSet.new([53..56])

     

       406
       406
       -
       RangeSet.new([53..56, 61..70, 81..95])

     

       407
       407
       -
       

     

       408
       408
       -
       map: %Mapping{values: [{18..24, 88..94}, {25..94, 18..87}]}

     

       409
       409
       -
       curr: RangeSet.new([53..56, 61..70, 81..95])

     

       410
       410
       -
       inter: RangeSet.new([53..56, 61..70, 81..94])

     

       411
       411
       -
       diff: RangeSet.new([95..95])

     

       412
       412
       -
       mapped: RangeSet.new([46..49, 54..63, 74..87])

     

       413
       413
       -
       RangeSet.new([46..49, 54..63, 74..87, 95..95])

     

       414
       414
       -
       

     

       415
       415
       -
       map: %Mapping{values: [{45..63, 81..99}, {64..76, 68..80}, {77..99, 45..67}]}

     

       416
       416
       -
       curr: RangeSet.new([46..49, 54..63, 74..87, 95..95])

     

       417
       417
       -
       inter: RangeSet.new([46..49, 54..63, 74..76, 77..87, 95..95])

     

       418
       418
       -
       diff: RangeSet.new([])

     

       419
       419
       -
       mapped: RangeSet.new([45..55, 63..63, 78..80, 82..85, 90..99])

     

       420
       420
       -
       RangeSet.new([45..55, 63..63, 78..80, 82..85, 90..99])

     

       421
       421
       -
       

     

       422
       422
       -
       map: %Mapping{values: [{0..68, 1..69}, {69..69, 0..0}]}

     

       423
       423
       -
       curr: RangeSet.new([45..55, 63..63, 78..80, 82..85, 90..99])

     

       424
       424
       -
       inter: RangeSet.new([45..55, 63..63])

     

       425
       425
       -
       diff: RangeSet.new([78..80, 82..85, 90..99])

     

       426
       426
       -
       mapped: RangeSet.new([46..56, 64..64])

     

       427
       427
       -
       RangeSet.new([46..56, 64..64, 78..80, 82..85, 90..99])

     

       428
       428
       -
       

     

       429
       429
       -
       map: %Mapping{values: [{56..92, 60..96}, {93..96, 56..59}]}

     

       430
       430
       -
       curr: RangeSet.new([46..56, 64..64, 78..80, 82..85, 90..99])

     

       431
       431
       -
       ```

     

       432
       432
       -
       

     

       433
       433
       -
       ```elixir

     

       434
       434
       -
       light2temp[74]

     

       435
       435
       -
       ```

     

       436
       436
       -
       

     

       437
       437
       -
       <!-- livebook:{"output":true} -->

     

       438
       438
       -
       

     

       439
       439
       -
       ```

     

       440
       440
       -
       78

     

       441
       441
       -
       ```

     

       442
       442
       -
       

     

       443
       443
       -
       <!-- livebook:{"offset":13391,"stamp":{"token":"XCP.YBvV3LijXOIMnujrbQ1UcVgKkKIgzTxWiEVKN6_kRQO7Z54rqDRPZT7cgjsENw1cakYqdxjdW8l0ZieLojSPU1k_oMLqBh0-YpWLbT9dUfZRNKIxmeQgwwCEGOzZ2hdsVw","version":2}} -->

     

       194
       194
       +
       <!-- livebook:{"offset":8450,"stamp":{"token":"XCP.9I0OWZix2U9jQ5DLHq6aPMZLzaSvoWmFrdBbv9pxQfaL_IHSsv0UiMHQgeLV96EpUjfWS_hLXKNfPjSWsmdceQyf2OEIe1gAC7o2oOp3S4I9UlfKFypRqLfs3Jo6p-UtGQ","version":2}} -->

+107

2023/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])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":{"assign_to":"puzzle_input","day":"6","session_secret":"ADVENT_OF_CODE_SESSION","year":"2023"},"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("2023", "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, "Time:        44     80     65     72\nDistance:   208   1581   1050   1102"}

     

       22
       22
       +
       ```

     

       23
       23
       +
       

     

       24
       24
       +
       ```elixir

     

       25
       25
       +
       # puzzle_input =

     

       26
       26
       +
       """

     

       27
       27
       +
       Time:      7  15   30

     

       28
       28
       +
       Distance:  9  40  200

     

       29
       29
       +
       """

     

       30
       30
       +
       |> String.trim()

     

       31
       31
       +
       ```

     

       32
       32
       +
       

     

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

     

       34
       34
       +
       

     

       35
       35
       +
       ```

     

       36
       36
       +
       "Time:      7  15   30\nDistance:  9  40  200"

     

       37
       37
       +
       ```

     

       38
       38
       +
       

     

       39
       39
       +
       ```elixir

     

       40
       40
       +
       defmodule Day06 do

     

       41
       41
       +
         def solve(t, d) do

     

       42
       42
       +
           delta = t ** 2 - 4 * d

     

       43
       43
       +
       

     

       44
       44
       +
           sq_delta = :math.sqrt(delta)

     

       45
       45
       +
       

     

       46
       46
       +
           diff = if sq_delta == floor(sq_delta), do: 1, else: 0

     

       47
       47
       +
       

     

       48
       48
       +
           x1 = (-t + sq_delta) / -2

     

       49
       49
       +
           x2 = (-t - sq_delta) / -2

     

       50
       50
       +
       

     

       51
       51
       +
           ceil(x2) - ceil(x1) - diff

     

       52
       52
       +
         end

     

       53
       53
       +
       end

     

       54
       54
       +
       ```

     

       55
       55
       +
       

     

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

     

       57
       57
       +
       

     

       58
       58
       +
       ```

     

       59
       59
       +
       {:module, Day06, <<70, 79, 82, 49, 0, 0, 8, ...>>, {:solve, 2}}

     

       60
       60
       +
       ```

     

       61
       61
       +
       

     

       62
       62
       +
       ## Part 1

     

       63
       63
       +
       

     

       64
       64
       +
       ```elixir

     

       65
       65
       +
       puzzle_input

     

       66
       66
       +
       |> String.split("\n")

     

       67
       67
       +
       |> Enum.map(fn line ->

     

       68
       68
       +
         line

     

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

     

       70
       70
       +
         |> tl()

     

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

     

       72
       72
       +
       end)

     

       73
       73
       +
       |> Enum.zip()

     

       74
       74
       +
       |> Enum.map(fn {t, d} -> Day06.solve(t, d) end)

     

       75
       75
       +
       |> Enum.product()

     

       76
       76
       +
       ```

     

       77
       77
       +
       

     

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

     

       79
       79
       +
       

     

       80
       80
       +
       ```

     

       81
       81
       +
       32076

     

       82
       82
       +
       ```

     

       83
       83
       +
       

     

       84
       84
       +
       ## Part 2

     

       85
       85
       +
       

     

       86
       86
       +
       ```elixir

     

       87
       87
       +
       [t, d] =

     

       88
       88
       +
         puzzle_input

     

       89
       89
       +
         |> String.split("\n")

     

       90
       90
       +
         |> Enum.map(fn line ->

     

       91
       91
       +
           line

     

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

     

       93
       93
       +
           |> tl()

     

       94
       94
       +
           |> Enum.join()

     

       95
       95
       +
           |> String.to_integer()

     

       96
       96
       +
         end)

     

       97
       97
       +
       

     

       98
       98
       +
       Day06.solve(t, d)

     

       99
       99
       +
       ```

     

       100
       100
       +
       

     

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

     

       102
       102
       +
       

     

       103
       103
       +
       ```

     

       104
       104
       +
       34278221

     

       105
       105
       +
       ```

     

       106
       106
       +
       

     

       107
       107
       +
       <!-- livebook:{"offset":1728,"stamp":{"token":"XCP.RVwRJJq0k3Evn9IAmQDOmuVfBQ2xs0pbIqwAVIMLYEO8Olj2RUttefJ6ky9G2BD-EzyDh-ZjERuBL8PVkFPkYz8g7hdsY0keFA-TEIL4GC3n2j_IwPT1JHFDQ0FwiPBw5g","version":2}} -->

+180

2023/day07.livemd

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       # Untitled notebook

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

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

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":{"assign_to":"puzzle_input","day":"7","session_secret":"ADVENT_OF_CODE_SESSION","year":"2023"},"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("2023", "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
       +
        "7KAK7 63\n9889J 846\nJ37QA 670\nT2T2J 5\n827K6 552\nKTT5T 116\nJTJ63 457\n55656 482\nA924K 555\n323QQ 568\n2QQ5J 32\nJ4434 784\n9T5A4 738\nT666J 983\n6K6J2 351\n933TT 851\n95567 364\n5T598 858\n55TT4 895\n92T2T 893\n2638T 17\nTT3T9 509\n8T954 579\n834JQ 962\nA9TK7 710\n22552 201\nT7627 879\nK3795 875\nJ79A7 865\nJ9A99 986\n56674 627\n3QT25 470\n53553 542\n3T3K9 718\nAA4AJ 345\n95999 475\nK3335 221\n3QQQ3 207\nTAAAA 152\nA3AQ9 796\n7Q922 53\nJQJQQ 873\nJ888J 808\nTJ223 828\n52355 782\n72889 264\n4KA44 244\nQJK6K 964\nA3T76 71\n38A27 303\n5893T 841\n576J4 826\n884JQ 386\n27233 359\n45A55 906\nK7KT6 677\nT3KT3 254\n7K663 291\n78887 999\nAT8JA 609\n9A2T2 334\nJ3339 607\nJ99K9 427\nK2K66 909\nTT3J3 693\n65732 67\n5Q397 381\nQKJA4 276\n66678 582\n3553K 171\n2AJT7 631\n8JKKK 78\n44764 115\nK3K33 367\n46A66 407\n94673 646\n9QA53 597\nJQ33Q 213\n8A8J8 611\n7QQ77 426\nAJ99A 312\n77883 103\n6666J 914\n33365 495\n66565 890\n88899 258\n333A3 410\n8KT8K 463\n85888 241\n8TQA2 151\n666Q3 118\nQ684T 820\n82228 641\n5335J 644\n2Q7K6 806\n47747 538\nJTATA 186\n74979 127\n79TK9 142\n78787 764\n7QJTJ 650\nA2228 880\n24J4A 195\n6Q3T3 358\n5QJQT 286\n7Q7QQ 232\nJ9JA9 145\n39334 383\n94495 155\nK26K2 344\nT78QQ 76\nK292K 318\n7AJAA 562\n9875Q 876\nQ5555 82\nAT4TT 569\n77779 671\nQTTT2 994\n7T64Q 651\n74779 20\n88T48 639\n93999 373\n3KJQK 385\nT73TJ 612\n766K8 60\nTA538 161\n542T5 52\nK299T 249\nT3A2A 981\n92947 908\n866J2 21\nJ7K23 149\nJQ747 417\nK7J77 837\nAAA6A 925\n7TJ77 506\nK8QKK 248\nKAAAJ 931\nQQQ8Q 37\n79972 961\n777AA 56\n722J2 752\n64346 518\n5JTJ2 629\nK9999 898\nT2AQK 256\n66JJ6 222\nA7A3A 557\n877TT 247\nTKJ59 608\n53775 968\nT8TTT 136\n28862 691\n37QTT 252\nKJ442 772\n866J6 604\n324K5 596\nT7973 309\n2Q922 859\nJ4Q7Q 234\nKQ39T 355\nQ3Q35 635\nTJ428 498\nAKJ48 877\nQ3Q7J 183\n6K6KK 237\nA5Q7K 775\n8T22T 257\n8AA88 225\n777K4 523\nQJK78 917\nK5J82 788\nQ6JAA 339\nT3J63 483\n5555A 3\n7A333 31\nJ7QQ7 711\n54QKQ 726\nJ463A 363\nJJJJJ 905\n3T33T 702\nQ626Q 593\nKQ9KJ 855\n299A2 421\nQK57Q 868\nK29T3 570\n88338 836\n66696 637\n5A755 24\nT49T7 400\n6QJK6 366\nJ3J43 33\n65J66 701\n8J982 821\n2T68J 919\n4J44K 209\n97662 633\n7J344 135\nJK99K 269\n4547A 49\n6557Q 753\n85585 395\nJT555 465\n88884 800\n95A9J 980\n44J46 429\n8AJ8A 372\nK42Q8 184\n79863 329\nQQJQ3 203\n78A8K 166\n6Q7Q6 47\n87727 87\n55755 148\n99739 104\nK956J 357\n53533 10\n54AQ3 761\n66339 143\n38833 563\nAAAA2 304\n6KATK 768\nA6J83 101\n626J6 165\nJTJJQ 193\nK7444 949\n95432 420\nTTT96 311\n833AA 105\n38233 439\n2777Q 912\nJ6442 150\n56A3K 371\nJT24T 226\n4KK88 532\n2J972 823\nTA4Q7 945\n77TJT 578\n55T9A 683\nKJT3Q 394\nTT9TT 28\nT6A9A 932\n32466 306\n2A5J6 270\n8A863 915\n6J4AA 565\n3AJ82 260\n98789 96\n6666K 642\nKK587 982\nA8A3Q 795\nA333A 630\n79999 827\n587A6 587\n5888J 997\nTTT77 647\nQQQ88 412\n6346T 798\nJQQT9 507\nAA223 872\n75475 590\nK8374 680\n72252 464\nQ7775 594\nKAKQK 973\n5T4T4 353\nJQ3JQ 139\n99334 1\n646K4 90\n6AKA5 536\nT3KA9 296\n63QT9 11\nQ8AJ3 308\nAAA8A 922\nJ7722 954\nT8A32 891\nQAQQA 75\nT9TJ9 424\nA8573 786\n2T33J 485\n85T6T 834\n255QQ 405\nTJT8T 131\n89289 408\n9626T 515\n8J2A2 721\nJ4522 812\n7T757 79\n9A999 398\n554AJ 217\nKKKK8 362\nJQTJ3 746\nK8J76 960\nTK6QA 706\n5Q895 976\n33993 690\n9699A 320\nA8265 640\n66AAJ 958\n66664 48\n59Q2K 661\nJ8668 324\n9AJ25 889\n862Q8 546\n8K9T9 198\nK3K3K 215\nJTJ77 689\nAJTT5 377\n88JJ7 448\n8737J 688\n7KQKQ 51\nKKK5K 295\n79T9T 757\n59A47 502\n43AJ9 573\nK9792 605\n37Q33 824\nTTT6T 737\nA4A22 486\n652KK 478\nAK42Q 990\nQ44J5 853\n5Q999 902\n99JJJ 619\nJJQKK 714\nTA5JK 530\nAQQAA 756\nA6JAJ 43\n55KKK 832\n36A2J 374\n4333J 816\nA2J9A 461\n95Q49 292\nJK9A2 365\nJ5256 93\nKK6J6 953\n8QJ72 750\n95959 845\nKK4KK 57\nJ57Q2 686\n5QKA9 119\nJ5J99 342\nKKK2K 454\n33A3K 177\n688J2 409\nQJTTK 766\n3K978 741\n64T47 603\n34584 776\n89KT2 251\nT893T 653\nKK957 717\n9Q8Q5 959\nK5KQ5 174\n3Q223 456\n2J9Q4 934\nA37AQ 58\n42Q35 712\n33633 809\n57J3J 326\n58959 867\nQ838J 632\nQQKJK 936\n8Q7T7 238\nT2T2T 491\n2T987 391\n69KQT 6\nQ6J98 815\nA4JQ4 299\nKAKAJ 25\n8765J 792\n9492J 272\n5QQK5 64\nJ9966 348\n8K888 418\nK8833 813\n33853 129\n24344 321\nQ4444 970\n44QQT 55\n82T28 547\n97K7Q 262\n3A34A 255\nK5K9K 567\nQT4QT 65\n84484 211\nK54QT 471\n23K3K 951\nKTQ2J 157\nJQKKK 705\nJJ333 673\n44222 137\n26K72 991\nT59KT 34\nTQ7QT 684\nJ9J99 435\n26648 950\nT4TKA 758\n6K66K 294\n5JQ55 85\n392QT 387\n54A7J 773\n99Q9T 903\n56365 692\n44T24 490\n538Q4 261\n65277 703\n44A44 941\nJ2A34 535\n7J733 649\n2422T 467\n3J9AJ 554\n3KT3K 389\nA999A 288\n2Q5J" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       # puzzle_input =

     

       27
       27
       +
       """

     

       28
       28
       +
       32T3K 765

     

       29
       29
       +
       T55J5 684

     

       30
       30
       +
       KK677 28

     

       31
       31
       +
       KTJJT 220

     

       32
       32
       +
       QQQJA 483

     

       33
       33
       +
       """

     

       34
       34
       +
       |> String.trim()

     

       35
       35
       +
       ```

     

       36
       36
       +
       

     

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

     

       38
       38
       +
       

     

       39
       39
       +
       ```

     

       40
       40
       +
       "32T3K 765\nT55J5 684\nKK677 28\nKTJJT 220\nQQQJA 483"

     

       41
       41
       +
       ```

     

       42
       42
       +
       

     

       43
       43
       +
       ```elixir

     

       44
       44
       +
       defmodule Day07 do

     

       45
       45
       +
         def rate({hand, _}) do

     

       46
       46
       +
           {jokers, rest} = Map.pop(Enum.frequencies(hand), -1, 0)

     

       47
       47
       +
       

     

       48
       48
       +
           pos =

     

       49
       49
       +
             rest

     

       50
       50
       +
             |> Map.values()

     

       51
       51
       +
             |> Enum.sort(:desc)

     

       52
       52
       +
             |> case do

     

       53
       53
       +
               [] -> [jokers]

     

       54
       54
       +
               [v | rest] -> [v + jokers | rest]

     

       55
       55
       +
             end

     

       56
       56
       +
       

     

       57
       57
       +
           {pos, hand}

     

       58
       58
       +
         end

     

       59
       59
       +
       

     

       60
       60
       +
         @cards ~C[TJQKA] |> Enum.with_index(10) |> Map.new()

     

       61
       61
       +
       

     

       62
       62
       +
         def card_values(hand) do

     

       63
       63
       +
           for <<card <- hand>> do

     

       64
       64
       +
             Map.get(@cards, card, card - ?0)

     

       65
       65
       +
           end

     

       66
       66
       +
         end

     

       67
       67
       +
       

     

       68
       68
       +
         def rate_bids(hands) do

     

       69
       69
       +
           hands

     

       70
       70
       +
           |> Enum.with_index(1)

     

       71
       71
       +
           |> Enum.reduce(0, fn {{_, bid}, idx}, acc ->

     

       72
       72
       +
             acc + bid * idx

     

       73
       73
       +
           end)

     

       74
       74
       +
         end

     

       75
       75
       +
       end

     

       76
       76
       +
       ```

     

       77
       77
       +
       

     

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

     

       79
       79
       +
       

     

       80
       80
       +
       ```

     

       81
       81
       +
       {:module, Day07, <<70, 79, 82, 49, 0, 0, 12, ...>>, {:rate_bids, 1}}

     

       82
       82
       +
       ```

     

       83
       83
       +
       

     

       84
       84
       +
       ```elixir

     

       85
       85
       +
       hands =

     

       86
       86
       +
         puzzle_input

     

       87
       87
       +
         |> String.split("\n")

     

       88
       88
       +
         |> Enum.map(fn <<hand::binary-5>> <> " " <> bid ->

     

       89
       89
       +
           {Day07.card_values(hand), String.to_integer(bid)}

     

       90
       90
       +
         end)

     

       91
       91
       +
       ```

     

       92
       92
       +
       

     

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

     

       94
       94
       +
       

     

       95
       95
       +
       ```

     

       96
       96
       +
       [

     

       97
       97
       +
         {[7, 13, 14, 13, 7], 63},

     

       98
       98
       +
         {~c"\t\b\b\t\v", 846},

     

       99
       99
       +
         {[11, 3, 7, 12, 14], 670},

     

       100
       100
       +
         {[10, 2, 10, 2, 11], 5},

     

       101
       101
       +
         {[8, 2, 7, 13, 6], 552},

     

       102
       102
       +
         {[13, 10, 10, 5, 10], 116},

     

       103
       103
       +
         {[11, 10, 11, 6, 3], 457},

     

       104
       104
       +
         {[5, 5, 6, 5, 6], 482},

     

       105
       105
       +
         {[14, 9, 2, 4, 13], 555},

     

       106
       106
       +
         {[3, 2, 3, 12, 12], 568},

     

       107
       107
       +
         {[2, 12, 12, 5, 11], 32},

     

       108
       108
       +
         {[11, 4, 4, 3, 4], 784},

     

       109
       109
       +
         {[9, 10, 5, 14, 4], 738},

     

       110
       110
       +
         {[10, 6, 6, 6, 11], 983},

     

       111
       111
       +
         {[6, 13, 6, 11, 2], 351},

     

       112
       112
       +
         {[9, 3, 3, 10, 10], 851},

     

       113
       113
       +
         {[9, 5, 5, 6, 7], 364},

     

       114
       114
       +
         {[5, 10, 5, 9, 8], 858},

     

       115
       115
       +
         {[5, 5, 10, 10, 4], 895},

     

       116
       116
       +
         {[9, 2, 10, 2, 10], 893},

     

       117
       117
       +
         {[2, 6, 3, 8, 10], 17},

     

       118
       118
       +
         {[10, 10, 3, 10, 9], 509},

     

       119
       119
       +
         {[8, 10, 9, 5, 4], 579},

     

       120
       120
       +
         {[8, 3, 4, 11, 12], 962},

     

       121
       121
       +
         {[14, 9, 10, 13, 7], 710},

     

       122
       122
       +
         {[2, 2, 5, 5, 2], 201},

     

       123
       123
       +
         {[10, 7, 6, 2, 7], 879},

     

       124
       124
       +
         {[13, 3, 7, 9, 5], 875},

     

       125
       125
       +
         {[11, 7, 9, 14, 7], 865},

     

       126
       126
       +
         {[11, 9, 14, 9, 9], 986},

     

       127
       127
       +
         {[5, 6, 6, 7, 4], 627},

     

       128
       128
       +
         {[3, 12, 10, 2, 5], 470},

     

       129
       129
       +
         {[5, 3, 5, 5, 3], 542},

     

       130
       130
       +
         {[3, 10, 3, 13, 9], 718},

     

       131
       131
       +
         {[14, 14, 4, 14, 11], 345},

     

       132
       132
       +
         {[9, 5, 9, 9, 9], 475},

     

       133
       133
       +
         {[13, 3, 3, 3, 5], 221},

     

       134
       134
       +
         {[3, 12, 12, 12, 3], 207},

     

       135
       135
       +
         {[10, 14, 14, 14, 14], 152},

     

       136
       136
       +
         {[14, 3, 14, 12, 9], 796},

     

       137
       137
       +
         {[7, 12, 9, 2, 2], 53},

     

       138
       138
       +
         {~c"\v\f\v\f\f", 873},

     

       139
       139
       +
         {~c"\v\b\b\b\v", 808},

     

       140
       140
       +
         {[10, 11, 2, 2, 3], 828},

     

       141
       141
       +
         {[5, 2, 3, 5, ...], 782},

     

       142
       142
       +
         {[7, 2, 8, ...], 264},

     

       143
       143
       +
         {[4, 13, ...], 244},

     

       144
       144
       +
         {[12, ...], 964},

     

       145
       145
       +
         {[...], ...},

     

       146
       146
       +
         {...},

     

       147
       147
       +
         ...

     

       148
       148
       +
       ]

     

       149
       149
       +
       ```

     

       150
       150
       +
       

     

       151
       151
       +
       ## Part 1

     

       152
       152
       +
       

     

       153
       153
       +
       ```elixir

     

       154
       154
       +
       hands

     

       155
       155
       +
       |> Enum.sort_by(&Day07.rate/1)

     

       156
       156
       +
       |> Day07.rate_bids()

     

       157
       157
       +
       ```

     

       158
       158
       +
       

     

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

     

       160
       160
       +
       

     

       161
       161
       +
       ```

     

       162
       162
       +
       251121738

     

       163
       163
       +
       ```

     

       164
       164
       +
       

     

       165
       165
       +
       ## Part 2

     

       166
       166
       +
       

     

       167
       167
       +
       ```elixir

     

       168
       168
       +
       hands

     

       169
       169
       +
       |> Enum.map(fn {hand, bid} -> {Enum.map(hand, &if(&1 == 11, do: -1, else: &1)), bid} end)

     

       170
       170
       +
       |> Enum.sort_by(&Day07.rate/1)

     

       171
       171
       +
       |> Day07.rate_bids()

     

       172
       172
       +
       ```

     

       173
       173
       +
       

     

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

     

       175
       175
       +
       

     

       176
       176
       +
       ```

     

       177
       177
       +
       251421071

     

       178
       178
       +
       ```

     

       179
       179
       +
       

     

       180
       180
       +
       <!-- livebook:{"offset":7885,"stamp":{"token":"XCP.wRgoLUWae4DX2XUFjTo7CA3j7RlO-lLQQd2jtlaKP6rWdhi_OVydNRFeTmRoLmnU14Jb8Qb8scC1mQjIUhrSe0CuCogmDX7jjcItdJFOzvfF779xRDbllL3GnQv9Rg9vfQ","version":2}} -->

+73

2023/day08.livemd

···

       1
       1
       +
       # Day 08

     

       2
       2
       +
       

     

       3
       3
       +
       ```elixir

     

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

     

       5
       5
       +
       ```

     

       6
       6
       +
       

     

       7
       7
       +
       ## Section

     

       8
       8
       +
       

     

       9
       9
       +
       <!-- livebook:{"attrs":{"assign_to":"puzzle_input","day":"8","session_secret":"ADVENT_OF_CODE_SESSION","year":"2023"},"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("2023", "8", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       14
       14
       +
       ```

     

       15
       15
       +
       

     

       16
       16
       +
       ```elixir

     

       17
       17
       +
       # puzzle_input =

     

       18
       18
       +
       """

     

       19
       19
       +
       LR

     

       20
       20
       +
       

     

       21
       21
       +
       11A = (11B, XXX)

     

       22
       22
       +
       11B = (XXX, 11Z)

     

       23
       23
       +
       11Z = (11B, XXX)

     

       24
       24
       +
       22A = (22B, XXX)

     

       25
       25
       +
       22B = (22C, 22C)

     

       26
       26
       +
       22C = (22Z, 22Z)

     

       27
       27
       +
       22Z = (22B, 22B)

     

       28
       28
       +
       XXX = (XXX, XXX)

     

       29
       29
       +
       """

     

       30
       30
       +
       ```

     

       31
       31
       +
       

     

       32
       32
       +
       ```elixir

     

       33
       33
       +
       defmodule Day08 do

     

       34
       34
       +
         def find_path(instructions, pos, map) do

     

       35
       35
       +
           Enum.reduce_while(instructions, pos, fn

     

       36
       36
       +
             {_, idx}, <<_, _, ?Z>> -> {:halt, idx}

     

       37
       37
       +
             {step, _}, pos -> {:cont, elem(Map.fetch!(map, pos), step)}

     

       38
       38
       +
           end)

     

       39
       39
       +
         end

     

       40
       40
       +
       end

     

       41
       41
       +
       

     

       42
       42
       +
       [instructions | rest] =

     

       43
       43
       +
         String.split(puzzle_input, "\n", trim: true)

     

       44
       44
       +
       

     

       45
       45
       +
       instructions =

     

       46
       46
       +
         Stream.cycle(for <<c <- instructions>>, do: if(c == ?L, do: 0, else: 1))

     

       47
       47
       +
         |> Stream.with_index()

     

       48
       48
       +
       

     

       49
       49
       +
       map =

     

       50
       50
       +
         Map.new(rest, fn

     

       51
       51
       +
           <<src::binary-3>> <> " = (" <> <<left::binary-3>> <> ", " <> <<right::binary-3>> <> ")" ->

     

       52
       52
       +
             {src, {left, right}}

     

       53
       53
       +
         end)

     

       54
       54
       +
       ```

     

       55
       55
       +
       

     

       56
       56
       +
       ## Part 1

     

       57
       57
       +
       

     

       58
       58
       +
       ```elixir

     

       59
       59
       +
       Day08.find_path(instructions, "AAA", map)

     

       60
       60
       +
       ```

     

       61
       61
       +
       

     

       62
       62
       +
       ## Part 2

     

       63
       63
       +
       

     

       64
       64
       +
       ```elixir

     

       65
       65
       +
       starts = map |> Map.keys() |> Enum.filter(&String.ends_with?(&1, "A"))

     

       66
       66
       +
       

     

       67
       67
       +
       Task.async_stream(starts, &Day08.find_path(instructions, &1, map), ordered: false)

     

       68
       68
       +
       |> Enum.reduce(1, fn {:ok, a}, b ->

     

       69
       69
       +
         div(a * b, Integer.gcd(a, b))

     

       70
       70
       +
       end)

     

       71
       71
       +
       ```

     

       72
       72
       +
       

     

       73
       73
       +
       <!-- livebook:{"offset":1485,"stamp":{"token":"XCP.dP8RakyYvjO2Dt2LfELbhGu7h_AlwhvgijUPOM_xnTL158Wj_I2mpQbyuTUJEnrHmVyOVnplBQcB1UHSBWM-ogSxBCmlsFU8DVr00oukCY_wP9T2YAIinkNIn_0CtZ7tkg","version":2}} -->

+188

2023/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":{"assign_to":"puzzle_input","day":"9","session_secret":"ADVENT_OF_CODE_SESSION","year":"2023"},"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("2023", "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
       +
        "27 49 92 176 327 586 1039 1879 3511 6711 12850 24194 44291 78456 134365 222769 358339 560653 855336 1275364 1862543\n15 25 36 57 117 286 706 1643 3584 7420 14791 28745 55012 104457 197703 373565 703877 1318603 2446886 4482001 8081143\n2 -1 -1 5 35 140 429 1101 2482 5067 9586 17171 29829 51664 91688 169675 327410 648943 1295161 2560233 4960367\n17 40 75 124 195 314 553 1083 2269 4852 10332 21799 45683 95258 197352 404834 819561 1634448 3210609 6218318 11892083\n12 28 47 77 148 320 690 1410 2740 5170 9648 17942 33138 60228 106667 182671 300884 474856 715541 1024739 1384064\n23 34 56 98 179 335 630 1192 2323 4773 10330 22981 51089 111404 236460 488303 984007 1942732 3771076 7214380 13617999\n-3 9 34 76 147 268 465 760 1157 1623 2064 2296 2011 738 -2201 -7740 -17123 -31963 -54306 -86700 -132269\n2 5 10 28 85 240 617 1451 3148 6359 12068 21694 37207 61258 97323 149861 224486 328153 469358 658352 907369\n2 8 19 26 30 54 164 525 1536 4108 10175 23584 51670 108250 219765 438340 869318 1727304 3445143 6876026 13651774\n-7 -3 9 42 129 327 726 1476 2850 5366 9996 18495 33888 61158 108183 186975 315279 518595 832691 1306680 2006739\n14 15 24 47 93 174 306 517 868 1493 2664 4887 9035 16524 29538 51309 86458 141403 224840 348303 526809\n-4 10 50 125 241 410 669 1105 1873 3186 5269 8334 12802 20376 37376 83418 211850 554706 1416484 3461131 8070127\n15 39 76 141 268 519 996 1856 3329 5739 9528 15283 23766 35947 53040 76542 108275 150431 205620 276921 367936\n24 38 52 61 53 10 -73 -138 42 1075 4356 12809 32195 73394 156469 318214 626801 1211053 2319569 4439602 8532786\n4 10 36 100 243 556 1233 2668 5629 11577 23262 45830 88824 169667 319485 592472 1080426 1934604 3397664 5849192 9869161\n-4 7 35 84 170 335 665 1316 2552 4799 8719 15308 26022 42935 68933 107948 165236 247703 364283 526372 748322\n-7 4 31 85 196 437 976 2172 4734 9973 20207 39455 74747 138831 256043 475047 895657 1722829 3370197 6649632 13104456\n16 32 58 111 217 410 745 1344 2499 4865 9805 20028 40853 82880 167863 341774 703534 1466538 3085872 6511449 13672565\n-5 -11 -19 -29 -41 -55 -71 -89 -109 -131 -155 -181 -209 -239 -271 -305 -341 -379 -419 -461 -505\n5 8 27 84 220 507 1078 2190 4332 8382 15798 28785 50293 83555 130708 190077 252623 301509 328232 401228 871348\n22 31 48 86 172 357 726 1417 2671 4960 9297 17952 36037 74887 159044 340266 724833 1525270 3155647 6402851 12728283\n13 26 37 45 58 113 311 867 2175 4888 10013 19021 33972 57655 93743 146963 223281 330102 476485 673373 933838\n12 37 78 151 286 522 901 1478 2383 3991 7275 14433 29888 61749 123771 237731 435898 762853 1275224 2036831 3105150\n8 21 55 123 237 408 646 960 1358 1847 2433 3121 3915 4818 5832 6958 8196 9545 11003 12567 14233\n3 19 44 71 100 149 259 491 916 1602 2605 3974 5783 8206 11654 16996 25889 41245 67866 113281 188822\n8 19 57 138 279 498 814 1247 1818 2549 3463 4584 5937 7548 9444 11653 14204 17127 20453 24214 28443\n9 4 5 23 80 223 554 1285 2829 5953 12058 23725 45786 87356 165507 311589 581617 1072658 1947779 3472867 6069516\n4 5 15 44 100 191 336 594 1120 2264 4761 10142 21660 46317 99077 211200 446093 928628 1898502 3807091 7495429\n15 29 52 91 168 327 635 1168 1976 3031 4181 5172 5894 7252 13693 39949 128019 387751 1089032 2861339 7106618\n4 27 76 163 300 499 772 1131 1588 2155 2844 3667 4636 5763 7060 8539 10212 12091 14188 16515 19084\n0 14 49 126 288 620 1290 2632 5308 10611 21004 41028 78750 147953 271285 484572 842448 1425348 2347731 3767130 5893244\n3 5 19 56 140 317 663 1291 2357 4065 6671 10486 15878 23273 33155 46065 62599 83405 109179 140660 178624\n15 24 50 100 174 275 432 735 1381 2730 5370 10190 18460 31917 52856 84225 129723 193900 282258 401352 558890\n3 10 28 67 151 337 751 1653 3540 7288 14321 26777 47618 80603 130010 199955 293113 408598 538706 664167 747489\n20 41 74 126 209 345 579 1013 1892 3804 8106 17770 38987 84130 177153 363333 726644 1420251 2718970 5107486 9425181\n15 27 39 51 63 75 87 99 111 123 135 147 159 171 183 195 207 219 231 243 255\n8 21 58 139 303 630 1288 2630 5374 10904 21738 42245 79828 147184 267217 484267 889432 1675307 3248534 6450147 12967977\n12 18 24 30 36 42 48 54 60 66 72 78 84 " <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       lines =

     

       27
       27
       +
         puzzle_input

     

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

     

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

     

       30
       30
       +
           line

     

       31
       31
       +
           |> String.split()

     

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

     

       33
       33
       +
         end)

     

       34
       34
       +
       ```

     

       35
       35
       +
       

     

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

     

       37
       37
       +
       

     

       38
       38
       +
       ```

     

       39
       39
       +
       [

     

       40
       40
       +
         [27, 49, 92, 176, 327, 586, 1039, 1879, 3511, 6711, 12850, 24194, 44291, 78456, 134365, 222769,

     

       41
       41
       +
          358339, 560653, 855336, 1275364, 1862543],

     

       42
       42
       +
         [15, 25, 36, 57, 117, 286, 706, 1643, 3584, 7420, 14791, 28745, 55012, 104457, 197703, 373565,

     

       43
       43
       +
          703877, 1318603, 2446886, 4482001, 8081143],

     

       44
       44
       +
         [2, -1, -1, 5, 35, 140, 429, 1101, 2482, 5067, 9586, 17171, 29829, 51664, 91688, 169675, 327410,

     

       45
       45
       +
          648943, 1295161, 2560233, 4960367],

     

       46
       46
       +
         [17, 40, 75, 124, 195, 314, 553, 1083, 2269, 4852, 10332, 21799, 45683, 95258, 197352, 404834,

     

       47
       47
       +
          819561, 1634448, 3210609, 6218318, 11892083],

     

       48
       48
       +
         [12, 28, 47, 77, 148, 320, 690, 1410, 2740, 5170, 9648, 17942, 33138, 60228, 106667, 182671,

     

       49
       49
       +
          300884, 474856, 715541, 1024739, 1384064],

     

       50
       50
       +
         [23, 34, 56, 98, 179, 335, 630, 1192, 2323, 4773, 10330, 22981, 51089, 111404, 236460, 488303,

     

       51
       51
       +
          984007, 1942732, 3771076, 7214380, 13617999],

     

       52
       52
       +
         [-3, 9, 34, 76, 147, 268, 465, 760, 1157, 1623, 2064, 2296, 2011, 738, -2201, -7740, -17123,

     

       53
       53
       +
          -31963, -54306, -86700, -132269],

     

       54
       54
       +
         [2, 5, 10, 28, 85, 240, 617, 1451, 3148, 6359, 12068, 21694, 37207, 61258, 97323, 149861, 224486,

     

       55
       55
       +
          328153, 469358, 658352, 907369],

     

       56
       56
       +
         [2, 8, 19, 26, 30, 54, 164, 525, 1536, 4108, 10175, 23584, 51670, 108250, 219765, 438340, 869318,

     

       57
       57
       +
          1727304, 3445143, 6876026, 13651774],

     

       58
       58
       +
         [-7, -3, 9, 42, 129, 327, 726, 1476, 2850, 5366, 9996, 18495, 33888, 61158, 108183, 186975,

     

       59
       59
       +
          315279, 518595, 832691, 1306680, 2006739],

     

       60
       60
       +
         [14, 15, 24, 47, 93, 174, 306, 517, 868, 1493, 2664, 4887, 9035, 16524, 29538, 51309, 86458,

     

       61
       61
       +
          141403, 224840, 348303, 526809],

     

       62
       62
       +
         [-4, 10, 50, 125, 241, 410, 669, 1105, 1873, 3186, 5269, 8334, 12802, 20376, 37376, 83418, 211850,

     

       63
       63
       +
          554706, 1416484, 3461131, 8070127],

     

       64
       64
       +
         [15, 39, 76, 141, 268, 519, 996, 1856, 3329, 5739, 9528, 15283, 23766, 35947, 53040, 76542,

     

       65
       65
       +
          108275, 150431, 205620, 276921, 367936],

     

       66
       66
       +
         [24, 38, 52, 61, 53, 10, -73, -138, 42, 1075, 4356, 12809, 32195, 73394, 156469, 318214, 626801,

     

       67
       67
       +
          1211053, 2319569, 4439602, 8532786],

     

       68
       68
       +
         [4, 10, 36, 100, 243, 556, 1233, 2668, 5629, 11577, 23262, 45830, 88824, 169667, 319485, 592472,

     

       69
       69
       +
          1080426, 1934604, 3397664, 5849192, 9869161],

     

       70
       70
       +
         [-4, 7, 35, 84, 170, 335, 665, 1316, 2552, 4799, 8719, 15308, 26022, 42935, 68933, 107948, 165236,

     

       71
       71
       +
          247703, 364283, 526372, 748322],

     

       72
       72
       +
         [-7, 4, 31, 85, 196, 437, 976, 2172, 4734, 9973, 20207, 39455, 74747, 138831, 256043, 475047,

     

       73
       73
       +
          895657, 1722829, 3370197, 6649632, 13104456],

     

       74
       74
       +
         [16, 32, 58, 111, 217, 410, 745, 1344, 2499, 4865, 9805, 20028, 40853, 82880, 167863, 341774,

     

       75
       75
       +
          703534, 1466538, 3085872, 6511449, 13672565],

     

       76
       76
       +
         [-5, -11, -19, -29, -41, -55, -71, -89, -109, -131, -155, -181, -209, -239, -271, -305, -341,

     

       77
       77
       +
          -379, -419, -461, -505],

     

       78
       78
       +
         [5, 8, 27, 84, 220, 507, 1078, 2190, 4332, 8382, 15798, 28785, 50293, 83555, 130708, 190077,

     

       79
       79
       +
          252623, 301509, 328232, 401228, 871348],

     

       80
       80
       +
         [22, 31, 48, 86, 172, 357, 726, 1417, 2671, 4960, 9297, 17952, 36037, 74887, 159044, 340266,

     

       81
       81
       +
          724833, 1525270, 3155647, 6402851, 12728283],

     

       82
       82
       +
         [13, 26, 37, 45, 58, 113, 311, 867, 2175, 4888, 10013, 19021, 33972, 57655, 93743, 146963, 223281,

     

       83
       83
       +
          330102, 476485, 673373, 933838],

     

       84
       84
       +
         [12, 37, 78, 151, 286, 522, 901, 1478, 2383, 3991, 7275, 14433, 29888, 61749, 123771, 237731,

     

       85
       85
       +
          435898, 762853, 1275224, 2036831, 3105150],

     

       86
       86
       +
         [8, 21, 55, 123, 237, 408, 646, 960, 1358, 1847, 2433, 3121, 3915, 4818, 5832, 6958, 8196, 9545,

     

       87
       87
       +
          11003, 12567, 14233],

     

       88
       88
       +
         [3, 19, 44, 71, 100, 149, 259, 491, 916, 1602, 2605, 3974, 5783, 8206, 11654, 16996, 25889, 41245,

     

       89
       89
       +
          67866, 113281, 188822],

     

       90
       90
       +
         [8, 19, 57, 138, 279, 498, 814, 1247, 1818, 2549, 3463, 4584, 5937, 7548, 9444, 11653, 14204,

     

       91
       91
       +
          17127, 20453, 24214, 28443],

     

       92
       92
       +
         [9, 4, 5, 23, 80, 223, 554, 1285, 2829, 5953, 12058, 23725, 45786, 87356, 165507, 311589, 581617,

     

       93
       93
       +
          1072658, 1947779, 3472867, 6069516],

     

       94
       94
       +
         [4, 5, 15, 44, 100, 191, 336, 594, 1120, 2264, 4761, 10142, 21660, 46317, 99077, 211200, 446093,

     

       95
       95
       +
          928628, 1898502, 3807091, 7495429],

     

       96
       96
       +
         [15, 29, 52, 91, 168, 327, 635, 1168, 1976, 3031, 4181, 5172, 5894, 7252, 13693, 39949, 128019,

     

       97
       97
       +
          387751, 1089032, 2861339, 7106618],

     

       98
       98
       +
         [4, 27, 76, 163, 300, 499, 772, 1131, 1588, 2155, 2844, 3667, 4636, 5763, 7060, 8539, 10212,

     

       99
       99
       +
          12091, 14188, 16515, ...],

     

       100
       100
       +
         [0, 14, 49, 126, 288, 620, 1290, 2632, 5308, 10611, 21004, 41028, 78750, 147953, 271285, 484572,

     

       101
       101
       +
          842448, 1425348, 2347731, ...],

     

       102
       102
       +
         [3, 5, 19, 56, 140, 317, 663, 1291, 2357, 4065, 6671, 10486, 15878, 23273, 33155, 46065, 62599,

     

       103
       103
       +
          83405, ...],

     

       104
       104
       +
         [15, 24, 50, 100, 174, 275, 432, 735, 1381, 2730, 5370, 10190, 18460, 31917, 52856, 84225, 129723,

     

       105
       105
       +
          ...],

     

       106
       106
       +
         [3, 10, 28, 67, 151, 337, 751, 1653, 3540, 7288, 14321, 26777, 47618, 80603, 130010, 199955, ...],

     

       107
       107
       +
         [20, 41, 74, 126, 209, 345, 579, 1013, 1892, 3804, 8106, 17770, 38987, 84130, 177153, ...],

     

       108
       108
       +
         [15, 27, 39, 51, 63, 75, 87, 99, 111, 123, 135, 147, 159, 171, ...],

     

       109
       109
       +
         [8, 21, 58, 139, 303, 630, 1288, 2630, 5374, 10904, 21738, 42245, 79828, ...],

     

       110
       110
       +
         [12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, ...],

     

       111
       111
       +
         [0, 4, 25, 68, 141, 272, 548, 1191, 2693, 6050, 13171, ...],

     

       112
       112
       +
         [4, -3, -3, 13, 61, 170, 394, 850, 1809, 3869, ...],

     

       113
       113
       +
         [-7, -12, -10, 18, 99, 265, 551, 994, 1633, ...],

     

       114
       114
       +
         [10, 11, 22, 61, 152, 325, 616, 1067, ...],

     

       115
       115
       +
         [-3, 8, 30, 79, 184, 392, 785, ...],

     

       116
       116
       +
         [2, 3, 19, 75, 213, 511, ...],

     

       117
       117
       +
         [1, 16, 38, 75, 146, ...],

     

       118
       118
       +
         [3, 25, 64, 128, ...],

     

       119
       119
       +
         [15, 31, 66, ...],

     

       120
       120
       +
         [27, 52, ...],

     

       121
       121
       +
         [6, ...],

     

       122
       122
       +
         [...],

     

       123
       123
       +
         ...

     

       124
       124
       +
       ]

     

       125
       125
       +
       ```

     

       126
       126
       +
       

     

       127
       127
       +
       ```elixir

     

       128
       128
       +
       defmodule Day09 do

     

       129
       129
       +
         def extrapolate(list, field \\ &List.last/1) do

     

       130
       130
       +
           reduce(list, [field.(list)], field)

     

       131
       131
       +
         end

     

       132
       132
       +
       

     

       133
       133
       +
         defp reduce(list, acc, field) do

     

       134
       134
       +
           if Enum.all?(list, &(&1 == 0)) do

     

       135
       135
       +
             acc

     

       136
       136
       +
           else

     

       137
       137
       +
             new =

     

       138
       138
       +
               list

     

       139
       139
       +
               |> Enum.chunk_every(2, 1, :discard)

     

       140
       140
       +
               |> Enum.map(fn [a, b] -> b - a end)

     

       141
       141
       +
       

     

       142
       142
       +
             reduce(new, [field.(new) | acc], field)

     

       143
       143
       +
           end

     

       144
       144
       +
         end

     

       145
       145
       +
       end

     

       146
       146
       +
       ```

     

       147
       147
       +
       

     

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

     

       149
       149
       +
       

     

       150
       150
       +
       ```

     

       151
       151
       +
       {:module, Day09, <<70, 79, 82, 49, 0, 0, 10, ...>>, {:reduce, 3}}

     

       152
       152
       +
       ```

     

       153
       153
       +
       

     

       154
       154
       +
       ## Part 1

     

       155
       155
       +
       

     

       156
       156
       +
       ```elixir

     

       157
       157
       +
       lines

     

       158
       158
       +
       |> Enum.map(fn line ->

     

       159
       159
       +
         Day09.extrapolate(line)

     

       160
       160
       +
         |> Enum.reduce(&+/2)

     

       161
       161
       +
       end)

     

       162
       162
       +
       |> Enum.sum()

     

       163
       163
       +
       ```

     

       164
       164
       +
       

     

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

     

       166
       166
       +
       

     

       167
       167
       +
       ```

     

       168
       168
       +
       1842168671

     

       169
       169
       +
       ```

     

       170
       170
       +
       

     

       171
       171
       +
       ## Part 2

     

       172
       172
       +
       

     

       173
       173
       +
       ```elixir

     

       174
       174
       +
       lines

     

       175
       175
       +
       |> Enum.map(fn line ->

     

       176
       176
       +
         Day09.extrapolate(line, &List.first/1)

     

       177
       177
       +
         |> Enum.reduce(&-/2)

     

       178
       178
       +
       end)

     

       179
       179
       +
       |> Enum.sum()

     

       180
       180
       +
       ```

     

       181
       181
       +
       

     

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

     

       183
       183
       +
       

     

       184
       184
       +
       ```

     

       185
       185
       +
       903

     

       186
       186
       +
       ```

     

       187
       187
       +
       

     

       188
       188
       +
       <!-- livebook:{"offset":11034,"stamp":{"token":"XCP.4niSRZnU_1qf0GtnoryY24xBSp3eHuDV770anpiMIG4QlQY1-YQrGuwXL43UbHafeRUdUytg7ITWDNnIHchGL1JYNXi-59qaGTyx0nfkbcwCqqLa0ukaCsTcU-1fFxEk3w","version":2}} -->

+264

2023/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":{"assign_to":"puzzle_input","day":"10","session_secret":"ADVENT_OF_CODE_SESSION","year":"2023"},"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("2023", "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
       +
        "|-L.FL-FJFL.|7FJ7F|F7-7F77.FL7---.7FF77--.|-F|FF--7FF7F-7F--77FFFJFJF7.F-LF7LFJJ.F|.|77F7F---7FLL.|FFJ.FF7-77..F77.-F-7FL-FF|77F-FFLL-FJ-|.J\n|7JF77-|L7J-F-JJL7|-|LJLF-|7.|.LLLJ7|-7.LFJFF--JF7L7|||FJ|F-J77L|F7.L-FJF----L7.FF.FJ-J-L-7|L|LJ7FJJJ.F|L-7L7.FF-|-7F-|J..||LJ-|-J-.|L|J|LF|\nLJ-LL|F7|LL7LLL-|-F7||..||..FJ.FJJF-7JJ|.7JLL--7|L7LJLJ|FJL-77|..FFJ7FJ7L7-|-JL.F--7LJJ|LJJ.F-|L7.FF-L7-F-7F77|J7||FLFJ|FFLL7.|JFJJ--J|.7-7|\n|.FJ.|F7-7L77|||L7JL-7LF777-JJ.|7F-L7JFJ7|F-|.LLJ|L---7||F--J7JFLF|JF-.--7||J.|F-.7LLLFF7||7F777L7FJ-||LJ7|||F|L-7.JJ.||7||J7.|-LL.7J.F7L7--\nF-7LF||.FLJL-7|FF|L7FL-L||F-7|FL7LJ|L7L|.LLJ|FJJLF---7|||L---7L7|L|7||FLFLJ|-FF-7|777FJ7|-FFJ|L77LL-F.JJJL7LLJ.|L7FJFF-77LF-7-|-|77L|7.L--7|\nF-JF-L7--J|JLL7-|LJ|F|J7L|J.J-|F7J7F|JF-7.|LF7F77L--7||LJF---JL-JJ|LJ7FJL7L|JLFJF|7FF7.-JJFL7|-F77J-777JF|L7J.|--L|J7|7LJ7JFJJ..|-J--7.L7.FJ\nL7J|7||J--L-F7.||LFL-JF7.F7.|.FL7.FF7L|7F|FF-7F-7F7FJLJF7L----7JFFJJ.J|7L|7L7JLL|JFFJ7.|.|F-J|FJL7|F7-|F7JF|FF.|.||7L-J7LF-||.L7J7L7FJ7.L-.|\nL7.L-FJJJF|FJ-.|JF--J7FJ7LLJ-..LJF||L-7F-7-L7|L7|||L--7|L-----J-FF-F7FL77|---F7JLL-|JF-77FL-7LJF-JFJ|-|-7-7L-7-7-JLJ-|L7-JJLF7-J-7|L77JFJJ.|\nLL-|FJL7.L|J7|-L7F.|FL-.FJJ.F-F-F-7L-7LJFJ|F|L-JLJL7F7|L----7|.F7F7F7JJ-L--|JJ7|-7-LF|FJF7J|L-7||FJFJ.LLJ.77||.L.LF7LF-F77F-J.F7-J7L-F7FJF-.\nFJ.|J7L77-7LL7J-7---FJ-FL---|||FJFJLLL-7|F7FL-----7||||F--7FJ-FJ||LJ||..LF7|JL--F||.FJL7||LF-7|L7|FJF7-.F-LJ.-7.F7.77F7||7-|L7LJJJFJ.FJJF-L.\n|.F|F7-.|.JJ.L..L|JL7..FJL|FF-7L7L-7F--JLJ|7LF7F--JLJLJ|F7LJJFL7||F-J--J7|7..F|-FL|FL7FJ|L7L7LJFJ|L7||7F|J|L7.F7F77.FJ||L--7--7|7.L-7L-77J|7\nLF-LL.L7J.FF-.F-||--.|-|-F--|FJ7L-7|L--7F7|F-J||F7F---7|||F7LFFJLJL7JL|.FF-77FF7JJF77|||L7L-JF-JLL7||L7F7|F-|.||||LFL7||F7FJ-LJ-77J-J7.LJF7J\nFF.|..7JJ7FLJ7|L-7F|F|.|7LLL|L7F--JL7F7||LJL7FJLJLJLF7|||LJL7FJF---J-|F77|JL7L|||FJL-JL-7L--7L7F7FJ|L7||L7L-F-J|||F7F||||LJ7LLJ.7JFFLF-L7LJ-\nL.FJ-|77--F||F77JJLF-7-J7F7LL7||F--7||LJL7|FJL-7F--7|||LJF--JL7|F-7JF--F7|.L7.|L7L----7FJF7FJFJ||L7|FJ||FJ77L-7LJ||L-JLJL7-|..-.|F7--77LJ-|J\nF|.L7||--FLJ7.L7F-J|FJJFF7FF7||LJF7||L7F7L7L7F-JL-7||||F-JLF-7|LJFJ7JFLF--77L-L7|7FF-7|L7||L7L7||FJ|L7LJ|F7F-7|F-JL--7F--J7F|J-F|7|LLJL7JF|.\nJ|LF|FJFFL.|F7LLJ|.|L7F7||FJLJL--JLJL7LJL7L7|L--7FJLJLJ|LF-JFJ|F-JF7.|.L7FJF7JFJL7FJFJ|FJ||7L7||LJFJ7L7FJ||L7|||F-7F7||F7LLJJ7.FJ.F77JF|F7|F\n||JFJ|F|J|7|JJL|-7-L7LJ|||L-7F7F--7F7L7F7L7LJF--JL--7F7L7|F-JFJL-7||-F-7||FJL7L7FJL7L-JL7||F-JLJF-JLF-JL-J|FJLJLJFJ|LJLJ|7J.F|7LJL|--7FJF|||\nL7--.LLJJ--|.FFJF-7-L-7||L-7LJ||F7LJL7LJL7L-7L-7F7F-J|L7LJL77L7F-J|L7L7|||L-7|FJL7FJF-7FJ||L-7F7|F7JL7F7F-JL--7F-J|L--7FJF77J|F|JLL7FLFLLJ|F\n.JLLF77.L-.|.LJ-7||FF-J||F-JF7LJ|L--7L-7FJF7|F-J||L--JLL-7FJF7||F7L7|FJ||L7FJLJF-JL-J||L7|L-7LJ|||L7FJ|||JF7F-J|F--7F-JL-JL7F---7JJ|F-JJ7LL-\n7-F7|FLJ7|7L-|.FJFL-L-7||L7FJL7LL-7FJF7|L-JLJL-7|L7F-7F7FJ|FJLJLJL7||L7||FJL-7FJF7F7F7|FJ|F-JF7|||FJ|FJLJFJ|L-7||F-JL--7F-7LJF--JJ7||||.7F|.\nL7LL|J|FFJ7FL7.FFJFFF-JLJFJL7FJF7FJ|FJ||F7F---7||FJL7||||FJ|F-7F7FJ||FJLJL7FFJL-J||LJLJL7|L-7||||||L||F7FJFJF-JLJ|F7F7FJL7L7FJF7.F7J-FF.FL-7\nLJ.LL7-J-JL|F|F---7FJF7F7L-7|L7|LJFJL7|LJLJF7FJLJL-7|LJ|||L||7LJLJJ|||F---JFJF---JL---7FJ|F-J|LJ||L7||||L7||L---7LJ|||L7FJ-|L-JL-J|.F-JFF.L7\nFJF|.L--L|-FLFL--7|L7||||F-J|FJL-7L7FJ|7F--JLJF----JL-7LJL7|L---7F7|LJL-7F7|FJF-7F-7F7|L7|L-7L7FJ|FJ|||L7|L7-F-7L-7LJL-JL-7L--7F--J.|.7JL|L|\nF-|77FJLFFJ|J.|F7|L7LJLJ||F-JL7F7L7|L7L7L----7L----7F7L-7FJ|F---J||L---7||LJL7L7|L7|||L7||F-JFJL-J|FJ||FJ|FJFJFJF7|F---7F7L7.LLJJJ.--7J.F777\n|..77-L-7-.LF7FJLJFJ7FF-J|L--7||L7||FJFJF7F7L|F---7|||F7|L7|L--7FJL7F7FJ||F7FJFJ|FJLJL7|||L7FJF7F-JL7LJL7|L-JFJFJLJ|F7F|||FJ-LJ|LLL.J|F-F.|.\n-7-LL|7FJ7L-|-|F-7L--7L-7|F7L|||FJ||L7|F|||L7||JF7LJ|LJ|L7||F--JL7FJ||L7|||LJL|FJL---7||||FJ|FJLJF--JF--J|F--JFJF--J|L7|||L7JFFF7L|7.L|F77J7\nF|7J.-J-LL7L-JLJ7L7F-JF-JLJL-JLJ|FJL7|L7||L7LJL7||F7L-7L7|||L-7F7|L7|L7|||L---JL7F-7FJ||LJL-J|FF7L-7FJ|F-JL7F7L7L7F7|FJLJL-J-F-7.F|F7JL-JFFF\nFLF.LLL7|.|-7.F7F7||F7L-------7FJL7FJL7|||LL7F-J|||L--JFJ|||F-J|||FJL7||LJF-----JL7||FJ|F---7L-J|F7||F7L--7|||.|FJ|LJ|F7.F7|7L7L7-J|FJL|LLJJ\nLJ.|7|LF|7J.LFJLJLJLJL7F--7F--JL--JL7FJ|||F-JL-7||L---7|FJLJL-7|LJL77|||F-JF-7-F7FJLJ|7LJF--JF--J|||LJ|FF7|||L-JL-JF7LJ|FJL77FJFJ|.JJ7F-J|||\nFF-|-J|" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       # puzzle_input =

     

       27
       27
       +
       """

     

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

     

       29
       29
       +
       .S-------7.

     

       30
       30
       +
       .|F-----7|.

     

       31
       31
       +
       .||.....||.

     

       32
       32
       +
       .||.....||.

     

       33
       33
       +
       .|L-7.F-J|.

     

       34
       34
       +
       .|..|.|..|.

     

       35
       35
       +
       .L--J.L--J.

     

       36
       36
       +
       ...........

     

       37
       37
       +
       """

     

       38
       38
       +
       ```

     

       39
       39
       +
       

     

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

     

       41
       41
       +
       

     

       42
       42
       +
       ```

     

       43
       43
       +
       "...........\n.S-------7.\n.|F-----7|.\n.||.....||.\n.||.....||.\n.|L-7.F-J|.\n.|..|.|..|.\n.L--J.L--J.\n...........\n"

     

       44
       44
       +
       ```

     

       45
       45
       +
       

     

       46
       46
       +
       ```elixir

     

       47
       47
       +
       defmodule Day10 do

     

       48
       48
       +
         @pipes %{

     

       49
       49
       +
           ?| => %{s: {{0, 1}, :s}, n: {{0, -1}, :n}},

     

       50
       50
       +
           ?- => %{e: {{1, 0}, :e}, w: {{-1, 0}, :w}},

     

       51
       51
       +
           ?L => %{s: {{1, 0}, :e}, w: {{0, -1}, :n}},

     

       52
       52
       +
           ?J => %{s: {{-1, 0}, :w}, e: {{0, -1}, :n}},

     

       53
       53
       +
           ?7 => %{n: {{-1, 0}, :w}, e: {{0, 1}, :s}},

     

       54
       54
       +
           ?F => %{n: {{1, 0}, :e}, w: {{0, 1}, :s}}

     

       55
       55
       +
         }

     

       56
       56
       +
       

     

       57
       57
       +
         for {k, v} <- @pipes do

     

       58
       58
       +
           v = Macro.escape(v)

     

       59
       59
       +
           def symbol_to_map(unquote(k)), do: unquote(v)

     

       60
       60
       +
           def map_to_symbol(unquote(v)), do: unquote(k)

     

       61
       61
       +
         end

     

       62
       62
       +
       

     

       63
       63
       +
         def symbol_to_map(?S), do: :start

     

       64
       64
       +
         def map_to_symbol(nil), do: nil

     

       65
       65
       +
       

     

       66
       66
       +
         @around [

     

       67
       67
       +
           {{0, -1}, :n, :s},

     

       68
       68
       +
           {{0, 1}, :s, :n},

     

       69
       69
       +
           {{-1, 0}, :w, :e},

     

       70
       70
       +
           {{1, 0}, :e, :w}

     

       71
       71
       +
         ]

     

       72
       72
       +
       

     

       73
       73
       +
         def start(map) do

     

       74
       74
       +
           {sx, sy} = start = Enum.find_value(map, fn {k, v} -> if v == :start, do: k end)

     

       75
       75
       +
       

     

       76
       76
       +
           routes =

     

       77
       77
       +
             for {{dx, dy}, face_next, route} <- @around,

     

       78
       78
       +
                 pipe = map[{sx + dx, sy + dy}] || %{},

     

       79
       79
       +
                 Map.has_key?(pipe, face_next),

     

       80
       80
       +
                 do: route

     

       81
       81
       +
       

     

       82
       82
       +
           dbg(routes)

     

       83
       83
       +
           smap = start_to_map(routes)

     

       84
       84
       +
           begin = smap |> Map.values() |> hd()

     

       85
       85
       +
           start_map = Map.merge(smap, %{start: begin})

     

       86
       86
       +
       

     

       87
       87
       +
           {start, Map.put(map, start, start_map)}

     

       88
       88
       +
         end

     

       89
       89
       +
       

     

       90
       90
       +
         defp start_to_map(next) do

     

       91
       91
       +
           Enum.find_value(@pipes, fn {_, map} ->

     

       92
       92
       +
             if Enum.all?(next, &Map.has_key?(map, &1)), do: map

     

       93
       93
       +
           end)

     

       94
       94
       +
         end

     

       95
       95
       +
       end

     

       96
       96
       +
       ```

     

       97
       97
       +
       

     

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

     

       99
       99
       +
       

     

       100
       100
       +
       ```

     

       101
       101
       +
       {:module, Day10, <<70, 79, 82, 49, 0, 0, 20, ...>>, {:start_to_map, 1}}

     

       102
       102
       +
       ```

     

       103
       103
       +
       

     

       104
       104
       +
       ```elixir

     

       105
       105
       +
       pipes =

     

       106
       106
       +
         for {line, y} <- Enum.with_index(String.split(puzzle_input)),

     

       107
       107
       +
             {segment, x} <- Enum.with_index(String.to_charlist(line)),

     

       108
       108
       +
             segment in ~c'|-LJ7FS',

     

       109
       109
       +
             into: %{} do

     

       110
       110
       +
           {{x, y}, Day10.symbol_to_map(segment)}

     

       111
       111
       +
         end

     

       112
       112
       +
       

     

       113
       113
       +
       {start, pipes} = Day10.start(pipes)

     

       114
       114
       +
       

     

       115
       115
       +
       dbg(pipes[start])

     

       116
       116
       +
       

     

       117
       117
       +
       rat =

     

       118
       118
       +
         Stream.unfold({start, :start}, fn {{x, y} = pos, face} ->

     

       119
       119
       +
           {{dx, dy}, f} = pipes[pos][face]

     

       120
       120
       +
           next_pos = {x + dx, y + dy}

     

       121
       121
       +
       

     

       122
       122
       +
           {next_pos, {next_pos, f}}

     

       123
       123
       +
         end)

     

       124
       124
       +
       ```

     

       125
       125
       +
       

     

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

     

       127
       127
       +
       

     

       128
       128
       +
       ```

     

       129
       129
       +
       [:n, :e]

     

       130
       130
       +
       ```

     

       131
       131
       +
       

     

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

     

       133
       133
       +
       

     

       134
       134
       +
       ```

     

       135
       135
       +
       %{start: {{0, 1}, :s}, e: {{0, 1}, :s}, n: {{-1, 0}, :w}}

     

       136
       136
       +
       ```

     

       137
       137
       +
       

     

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

     

       139
       139
       +
       

     

       140
       140
       +
       ```

     

       141
       141
       +
       #Function<63.53678557/2 in Stream.unfold/2>

     

       142
       142
       +
       ```

     

       143
       143
       +
       

     

       144
       144
       +
       ## Part 1

     

       145
       145
       +
       

     

       146
       146
       +
       ```elixir

     

       147
       147
       +
       length =

     

       148
       148
       +
         rat

     

       149
       149
       +
         |> Stream.with_index(1)

     

       150
       150
       +
         |> Enum.find_value(fn {p, idx} -> if p == start, do: idx end)

     

       151
       151
       +
       

     

       152
       152
       +
       div(length, 2)

     

       153
       153
       +
       ```

     

       154
       154
       +
       

     

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

     

       156
       156
       +
       

     

       157
       157
       +
       ```

     

       158
       158
       +
       7066

     

       159
       159
       +
       ```

     

       160
       160
       +
       

     

       161
       161
       +
       ## Part 2

     

       162
       162
       +
       

     

       163
       163
       +
       ```elixir

     

       164
       164
       +
       map =

     

       165
       165
       +
         rat

     

       166
       166
       +
         |> Enum.take(length + 1)

     

       167
       167
       +
         |> Map.new(&{&1, pipes[&1]})

     

       168
       168
       +
       ```

     

       169
       169
       +
       

     

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

     

       171
       171
       +
       

     

       172
       172
       +
       ```

     

       173
       173
       +
       %{

     

       174
       174
       +
         {18, 103} => %{e: {{0, 1}, :s}, n: {{-1, 0}, :w}},

     

       175
       175
       +
         {61, 121} => %{w: {{0, 1}, :s}, n: {{1, 0}, :e}},

     

       176
       176
       +
         {112, 138} => %{s: {{1, 0}, :e}, w: {{0, -1}, :n}},

     

       177
       177
       +
         {37, 47} => %{e: {{0, 1}, :s}, n: {{-1, 0}, :w}},

     

       178
       178
       +
         {77, 129} => %{s: {{0, 1}, :s}, n: {{0, -1}, :n}},

     

       179
       179
       +
         {120, 47} => %{s: {{-1, 0}, :w}, e: {{0, -1}, :n}},

     

       180
       180
       +
         {116, 69} => %{s: {{0, 1}, :s}, n: {{0, -1}, :n}},

     

       181
       181
       +
         {124, 56} => %{s: {{0, 1}, :s}, n: {{0, -1}, :n}},

     

       182
       182
       +
         {117, 125} => %{w: {{-1, 0}, :w}, e: {{1, 0}, :e}},

     

       183
       183
       +
         {32, 15} => %{w: {{-1, 0}, :w}, e: {{1, 0}, :e}},

     

       184
       184
       +
         {103, 106} => %{s: {{0, 1}, :s}, n: {{0, -1}, :n}},

     

       185
       185
       +
         {30, 113} => %{w: {{-1, 0}, :w}, e: {{1, 0}, :e}},

     

       186
       186
       +
         {123, 104} => %{e: {{0, 1}, :s}, n: {{-1, 0}, :w}},

     

       187
       187
       +
         {89, 14} => %{s: {{0, 1}, :s}, n: {{0, -1}, :n}},

     

       188
       188
       +
         {35, 30} => %{s: {{0, 1}, :s}, n: {{0, -1}, :n}},

     

       189
       189
       +
         {37, 53} => %{w: {{0, 1}, :s}, n: {{1, 0}, :e}},

     

       190
       190
       +
         {77, 130} => %{s: {{0, 1}, :s}, n: {{0, -1}, :n}},

     

       191
       191
       +
         {78, 98} => %{s: {{0, 1}, :s}, n: {{0, -1}, :n}},

     

       192
       192
       +
         {101, 62} => %{w: {{0, 1}, :s}, n: {{1, 0}, :e}},

     

       193
       193
       +
         {95, 56} => %{w: {{-1, 0}, :w}, e: {{1, 0}, :e}},

     

       194
       194
       +
         {102, 74} => %{w: {{-1, 0}, :w}, e: {{1, 0}, :e}},

     

       195
       195
       +
         {11, 39} => %{w: {{0, 1}, :s}, n: {{1, 0}, :e}},

     

       196
       196
       +
         {65, 43} => %{s: {{0, 1}, :s}, n: {{0, -1}, :n}},

     

       197
       197
       +
         {22, 38} => %{s: {{1, 0}, :e}, w: {{0, -1}, :n}},

     

       198
       198
       +
         {14, 86} => %{w: {{-1, 0}, :w}, e: {{1, 0}, :e}},

     

       199
       199
       +
         {49, 117} => %{e: {{0, 1}, :s}, n: {{-1, 0}, :w}},

     

       200
       200
       +
         {20, 41} => %{s: {{-1, 0}, :w}, e: {{0, -1}, :n}},

     

       201
       201
       +
         {29, 25} => %{s: {{0, 1}, :s}, n: {{0, -1}, :n}},

     

       202
       202
       +
         {86, 10} => %{w: {{0, 1}, :s}, n: {{1, 0}, :e}},

     

       203
       203
       +
         {83, 36} => %{e: {{0, 1}, :s}, n: {{-1, 0}, :w}},

     

       204
       204
       +
         {29, 26} => %{s: {{-1, 0}, :w}, e: {{0, -1}, :n}},

     

       205
       205
       +
         {47, 27} => %{s: {{-1, 0}, :w}, e: {{0, -1}, :n}},

     

       206
       206
       +
         {31, 42} => %{s: {{-1, 0}, :w}, e: {{0, -1}, :n}},

     

       207
       207
       +
         {120, 42} => %{e: {{0, 1}, :s}, n: {{-1, 0}, :w}},

     

       208
       208
       +
         {121, 77} => %{s: {{0, 1}, :s}, n: {{0, -1}, :n}},

     

       209
       209
       +
         {103, 39} => %{s: {{1, 0}, :e}, w: {{0, -1}, :n}},

     

       210
       210
       +
         {102, 57} => %{e: {{0, 1}, :s}, n: {{-1, 0}, :w}},

     

       211
       211
       +
         {32, 111} => %{e: {{0, 1}, :s}, n: {{-1, 0}, :w}},

     

       212
       212
       +
         {84, 102} => %{s: {{0, 1}, :s}, n: {{0, -1}, :n}},

     

       213
       213
       +
         {67, 98} => %{s: {{-1, 0}, :w}, e: {{0, -1}, :n}},

     

       214
       214
       +
         {119, 60} => %{s: {{0, 1}, :s}, n: {{0, -1}, :n}},

     

       215
       215
       +
         {116, 96} => %{w: {{-1, 0}, :w}, e: {{1, 0}, :e}},

     

       216
       216
       +
         {13, 85} => %{s: {{0, 1}, :s}, n: {{0, -1}, :n}},

     

       217
       217
       +
         {82, 60} => %{w: {{-1, 0}, :w}, e: {{1, 0}, :e}},

     

       218
       218
       +
         {132, 99} => %{w: {{-1, 0}, :w}, e: {{1, 0}, :e}},

     

       219
       219
       +
         {111, 108} => %{s: {{1, 0}, :e}, w: {{0, ...}, :n}},

     

       220
       220
       +
         {111, 103} => %{s: {{-1, ...}, :w}, e: {{...}, ...}},

     

       221
       221
       +
         {15, 92} => %{e: {{...}, ...}, n: {...}},

     

       222
       222
       +
         {58, ...} => %{s: {...}, ...},

     

       223
       223
       +
         {...} => %{...},

     

       224
       224
       +
         ...

     

       225
       225
       +
       }

     

       226
       226
       +
       ```

     

       227
       227
       +
       

     

       228
       228
       +
       ```elixir

     

       229
       229
       +
       {min_x, max_x, min_y, max_y} =

     

       230
       230
       +
         Enum.reduce(Map.keys(map), {:inf, -1, :inf, -1}, fn {x, y}, {min_x, max_x, min_y, max_y} ->

     

       231
       231
       +
           {min(min_x, x), max(max_x, x), min(min_y, y), max(max_y, y)}

     

       232
       232
       +
         end)

     

       233
       233
       +
       

     

       234
       234
       +
       Enum.reduce(min_y..max_y, 0, fn y, acc ->

     

       235
       235
       +
         {_, new_acc, _} =

     

       236
       236
       +
           Enum.reduce(min_x..max_x, {_in? = false, acc, nil}, fn x, {in?, count, cut} ->

     

       237
       237
       +
             pos = {x, y}

     

       238
       238
       +
             pipe = Day10.map_to_symbol(map[pos])

     

       239
       239
       +
       

     

       240
       240
       +
             case {in?, cut, pipe} do

     

       241
       241
       +
               # Empty - count

     

       242
       242
       +
               {true, _, nil} -> {true, count + 1, nil}

     

       243
       243
       +
               {false, _, nil} -> {false, count, nil}

     

       244
       244
       +
               # Keeping same in? over dead ends or horizontal pipes

     

       245
       245
       +
               {in?, ?F, ?J} -> {in?, count, nil}

     

       246
       246
       +
               {in?, ?L, ?7} -> {in?, count, nil}

     

       247
       247
       +
               {in?, cut, ?-} -> {in?, count, cut}

     

       248
       248
       +
               # crossing pipes

     

       249
       249
       +
               {in?, _, cut} when cut in ~c[FL] -> {not in?, count, cut}

     

       250
       250
       +
               {in?, _, _} -> {not in?, count, nil}

     

       251
       251
       +
             end

     

       252
       252
       +
           end)

     

       253
       253
       +
       

     

       254
       254
       +
         new_acc

     

       255
       255
       +
       end)

     

       256
       256
       +
       ```

     

       257
       257
       +
       

     

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

     

       259
       259
       +
       

     

       260
       260
       +
       ```

     

       261
       261
       +
       401

     

       262
       262
       +
       ```

     

       263
       263
       +
       

     

       264
       264
       +
       <!-- livebook:{"offset":10970,"stamp":{"token":"XCP.eg8I0JKuYGKRQ6ZLEkgXh_CgBWFloHr69nddniRhrGb8VYehWkNOR5xKnO3pCjta4lPqCOhary3a6WOL4GEwXCX8z-X23nu4atIlpcMYS7lwpipAaHv0JWjqM8DTukYlMg","version":2}} -->

+125

2023/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":{"assign_to":"puzzle_input","day":"11","session_secret":"ADVENT_OF_CODE_SESSION","year":"2023"},"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("2023", "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,

     

       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.....#." <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       lines = String.split(puzzle_input, "\n", trim: true)

     

       27
       27
       +
       

     

       28
       28
       +
       galaxies =

     

       29
       29
       +
         for {line, y} <- Enum.with_index(lines),

     

       30
       30
       +
             {d, x} <- Enum.with_index(String.to_charlist(line)),

     

       31
       31
       +
             d == ?#,

     

       32
       32
       +
             do: {x, y}

     

       33
       33
       +
       

     

       34
       34
       +
       {sx, sy} =

     

       35
       35
       +
         Enum.reduce(galaxies, {0, 0}, fn {x, y}, {mx, my} -> {max(x, mx), max(y, my)} end)

     

       36
       36
       +
       ```

     

       37
       37
       +
       

     

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

     

       39
       39
       +
       

     

       40
       40
       +
       ```

     

       41
       41
       +
       {139, 139}

     

       42
       42
       +
       ```

     

       43
       43
       +
       

     

       44
       44
       +
       ```elixir

     

       45
       45
       +
       [rows, cols] =

     

       46
       46
       +
         Enum.reduce(galaxies, [MapSet.new(), MapSet.new()], fn {x, y}, [rows, cols] ->

     

       47
       47
       +
           [MapSet.put(rows, y), MapSet.put(cols, x)]

     

       48
       48
       +
         end)

     

       49
       49
       +
       

     

       50
       50
       +
       empty_rows = MapSet.difference(MapSet.new(0..sy), rows) |> MapSet.to_list() |> Enum.sort()

     

       51
       51
       +
       empty_cols = MapSet.difference(MapSet.new(0..sx), cols) |> MapSet.to_list() |> Enum.sort()

     

       52
       52
       +
       

     

       53
       53
       +
       {empty_rows, empty_cols}

     

       54
       54
       +
       ```

     

       55
       55
       +
       

     

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

     

       57
       57
       +
       

     

       58
       58
       +
       ```

     

       59
       59
       +
       {[23, 54, 77, 81, 87, 91, 106, 107], ~c".178SYh"}

     

       60
       60
       +
       ```

     

       61
       61
       +
       

     

       62
       62
       +
       ```elixir

     

       63
       63
       +
       defmodule Day11 do

     

       64
       64
       +
         def reduce_unique_pairs(xs, init, fun) when is_function(fun, 3) do

     

       65
       65
       +
           do_map(hd(xs), tl(xs), fun, init)

     

       66
       66
       +
         end

     

       67
       67
       +
       

     

       68
       68
       +
         def do_map(_h, [], _fun, acc), do: acc

     

       69
       69
       +
       

     

       70
       70
       +
         def do_map(a, xs, fun, acc) do

     

       71
       71
       +
           new =

     

       72
       72
       +
             Enum.reduce(xs, acc, fn b, acc1 -> fun.(a, b, acc1) end)

     

       73
       73
       +
       

     

       74
       74
       +
           do_map(hd(xs), tl(xs), fun, new)

     

       75
       75
       +
         end

     

       76
       76
       +
       

     

       77
       77
       +
         def expand({x, y}, empty_rows, empty_cols, m \\ 2) do

     

       78
       78
       +
           {x + delta(x, empty_cols) * (m - 1), y + delta(y, empty_rows) * (m - 1)}

     

       79
       79
       +
         end

     

       80
       80
       +
       

     

       81
       81
       +
         defp delta(p, empty) do

     

       82
       82
       +
           Enum.count(empty, &(p > &1))

     

       83
       83
       +
         end

     

       84
       84
       +
       end

     

       85
       85
       +
       ```

     

       86
       86
       +
       

     

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

     

       88
       88
       +
       

     

       89
       89
       +
       ```

     

       90
       90
       +
       {:module, Day11, <<70, 79, 82, 49, 0, 0, 12, ...>>, {:delta, 2}}

     

       91
       91
       +
       ```

     

       92
       92
       +
       

     

       93
       93
       +
       ## Part 1

     

       94
       94
       +
       

     

       95
       95
       +
       ```elixir

     

       96
       96
       +
       galaxies

     

       97
       97
       +
       |> Enum.map(&Day11.expand(&1, empty_rows, empty_cols))

     

       98
       98
       +
       |> Day11.reduce_unique_pairs(0, fn {xa, ya}, {xb, yb}, acc ->

     

       99
       99
       +
         acc + abs(xb - xa) + abs(yb - ya)

     

       100
       100
       +
       end)

     

       101
       101
       +
       ```

     

       102
       102
       +
       

     

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

     

       104
       104
       +
       

     

       105
       105
       +
       ```

     

       106
       106
       +
       9686930

     

       107
       107
       +
       ```

     

       108
       108
       +
       

     

       109
       109
       +
       ## Part 2

     

       110
       110
       +
       

     

       111
       111
       +
       ```elixir

     

       112
       112
       +
       galaxies

     

       113
       113
       +
       |> Enum.map(&Day11.expand(&1, empty_rows, empty_cols, 1_000_000))

     

       114
       114
       +
       |> Day11.reduce_unique_pairs(0, fn {xa, ya}, {xb, yb}, acc ->

     

       115
       115
       +
         acc + abs(xb - xa) + abs(yb - ya)

     

       116
       116
       +
       end)

     

       117
       117
       +
       ```

     

       118
       118
       +
       

     

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

     

       120
       120
       +
       

     

       121
       121
       +
       ```

     

       122
       122
       +
       630728425490

     

       123
       123
       +
       ```

     

       124
       124
       +
       

     

       125
       125
       +
       <!-- livebook:{"offset":6621,"stamp":{"token":"XCP.eVlqF57ZVWEep_9Yi2Bop2YbV2ltU4T8e1DrVKC83DPGypJtqq5uBZpnlG1ix3mgZ2cTntGIcUv867ImHAf_1T32D0t35IKejAKx886nb4XpUxf8FuS27jeNiQIFpCl4Pg","version":2}} -->

+184

2023/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])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":{"assign_to":"puzzle_input","day":"12","session_secret":"ADVENT_OF_CODE_SESSION","year":"2023"},"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("2023", "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
       +
        ".#??..#??.?. 3,1,1,1\n???.##??#??????#???# 1,13,1\n.??#.?#??#????#?? 2,4,1,1,1\n???#??#.???#.?#??#?# 4,2,1,2,1,4\n????#?##???#.??.? 2,2,6,1\n.?????#???.###.##? 7,3,2\n.###?..#??????#???? 4,8,1\n??????????????? 1,1,1,2,1\n???.????????#? 1,3,1,1\n???.#..?#.?#?#??#?. 2,1,1,5,1\n.?..??#.????. 1,3,1,2\n.#?.??#?????##.# 1,2,1,3,1\n?###????.#?? 5,1,2\n?#??.????? 2,4\n?.#????#?????#??#?? 1,6,1,4,1\n#????????#?#?? 1,7,1,1\n?#??.?????? 3,1,1\n?..??#?###?? 1,6\n???.?.??#??##?? 1,1,1,5,1\n#???#.?????? 2,1,3,1\n?###??.??.?#???..? 4,1,2,1,1,1\n?.#???#?.?? 2,1,1\n#??##????##??????#? 7,5,2\n????#????????????# 1,6,1,1,2\n#?.?.##???? 1,1,5\n.?????.?#???????? 1,2,2,2,1\n#??.???#?.????? 2,5,1,1\n?????????.#???. 6,2\n?????????? 1,1,4\n?#??#??#?## 1,7\n????#?##???#? 1,6,1,1\n??#??#.???#?????? 1,1,1,7,1\n?????##?.?#??. 1,2,4\n???##????###????. 4,7\n?.?.?.?#???? 1,1,6\n???..??.????.###??. 2,2,2,5\n????##??#????? 1,7,1,1\n???..????#??? 2,6\n.??.????????. 1,2\n?.#?.????? 1,2\n??????.#???#? 2,5\n?????#.###???#.???# 6,7,1,1\n##.????##..#??#?. 2,6,1,1\n?????.??.?????????. 1,6\n??????..#?# 4,3\n#??????#??..?#? 10,2\n?.?????.?#??? 1,2\n???#??????.. 2,4\n.#?#???####??.?#?##? 12,5\n?.?????##??? 3,4\n?###?###????????# 10,3\n.?????????#? 1,5\n#?##????#???? 1,2,2,1\n.??????.??#???. 1,2,1,1,1\n??#.?#.????# 1,2,1,1\n???????.?#??????.?? 2,1,1,8,1\n???#??.?#???? 5,2,2\n?#??????###???. 2,8\n.??????#???????#? 1,12\n??..???#?#??? 1,6\n?.??????.. 1,1,3\n??#??.?#??#. 1,1,1,1\n?#?????.??????. 1,1,6\n.#?#?????#?#???#?.?? 5,9\n???#???#.#?##????? 5,1,7,1\n?#.??#??#?..?? 1,5,1\n#???#????#?.? 1,1,6,1\n????????.#? 4,1\n????#?#?#??.??.?? 8,1\n???#?????#?#?..#? 4,1,4,1\n??.??????#??.?#??#. 1,3,1,1\n.????????????? 1,2,2,1\n#.?#?#?#?.??? 1,6,1\n?#??#??..?#?? 3,2,3\n..#?.?#??#?# 2,6\n???#?.?..???## 3,1,2\n?????.?#?.???## 3,3,3\n??.?????..????? 3,5\n?.?????##? 1,1,2\n?.??#.#????#???.. 1,3,1,1,4\n??#??#?#?##????.# 3,3,6,1\n?.?.?.?####???.#. 1,8,1\n?##?????#?.?#.. 3,1,1,2,1\n???#???????.#. 2,4,1\n????.??.?#???? 1,3\n.?#?#?#??????##??? 2,11,2\n??.?#?.#?. 2,2,2\n????#...?#???# 4,5\n.??..???#??#?#? 2,1,1,3\n????#.?????? 3,6\n????.?????? 1,1,2\n????#?????.?# 1,2,2,2\n.?#?????.??.? 3,1,1,1\n???#??.?#.??. 1,3,2,2\n?##???????#???????# 2,9,1\n?##?????????.?? 8,1\n.#???????.??#???? 1,4,4\n.?#?.#??.? 1,1,1\n??.?#??????#? 4,3\n??#?#??#??.?? 3,2,1\n.#?.???##? 1,5\n?????.#?.???#? 2,1,1,4\n##????#??? 4,1,1\n?????????# 1,2,3\n??#?#?????##? 4,3\n?#.???##?#????#?##. 1,12\n#.?##???#???..??.?? 1,6,1,2,1\n?#????#??#.#?.##?# 5,1,1,1,4\n?#????#.#??#..? 1,3,1,1,1\n??###?.?.????. 5,2\n.????????#.#? 5,2,1\n.?.#.???..??#.?? 1,1,1,3,1\n#????????.??????. 4,4,2,1,1\n?.??????#? 3,3\n...?#.#.???##? 2,1,1,2\n??????????#.???.?#?? 7,1,1,1\n.????##?#??.???#???? 7,5\n??.#?.???? 1,2,2\n?.#??#??#?? 1,4,2\n????#?????? 1,4,2\n??.???????? 1,1,2\n??#????????#??#???? 3,3,7\n?????????##?.??#?. 1,1,2,1,3,2\n??#????????????.??? 2,11\n??#?.?#???#?##????. 4,3,4,1\n????.???????.?? 1,3\n????#.##?? 1,1,4\n#?????#?????.##?## 2,7,5\n#??.??..?#?#.? 2,1,4\n.??.??.?.?????##? 1,1,1,4\n??.???????#??? 1,7,1\n.#.??.?##???#.? 1,1,3,2,1\n#??.??##??.?#?.#?#?? 3,4,1,4\n???..?????????.# 2,1,3,1,1\n??#.?????#?##.?#.# 2,6,2,1,1\n?#?.?.#??#?? 1,6\n?###????#?.? 6,2\n?.?????????????.?? 1,1,1,1,4,1\n????.?#?##??#??. 1,1,5,2\n???????.????# 1,1,1,3\n##???.????#???# 2,1,1,1,5\n.#?##???####?.??#.?? 4,5,2\n????????#?#?.?#?? 1,1,3,1,3\n?.?????#?. 2,2\n?#???????????#.????? 7,2,1,1,1\n????????#..##. 1,2,2,2\n#?#?##?#??. 3,5\n???#????###????????. 17,1\n.????#???## 1,3,4\n??####??#??#?#?#?#?? 6,6,4\n??????#????.?.?? 1,3,1,1,1\n..?##?.?.?. 3,1\n.???####?????#? 8,1\n.???????#?..??.?# 1,3,1,2,1\n??.?#?????? 1,2,2\n??#???#..?#?????#??? 4,1,5,1,2\n??#?...#?? 4,1\n??????.#?#?##??.?? 2,7\n.???????##???. 1,9\n?..#.????#??#???#?? 1,3,9\n?#??????????#???.#?? 4,3,1,1,3\n.?????#???.??#?.?. 4,1\n??#.?##?#??##??#?#? 1,1,12,1\n?##??#??##???#.?.. 2,9\n#??????#??? 3,4\n##???.?#..#.?# 5,2,1,2\n???.?.???# 2,1,3\n?.?????.?? 2,2\n???.?????#?.?????? 1,2,2\n.#????#????.? 1,6\n????.#.?#??????#???? 1,1,1,1,2,7\n?.???.#.??##???#?? 1,1,1,1,8\n??????.?#? 4,2\n#??..?????#? 2,1,2,1\n?##.#.????##?# 2,1,2,4\n????????#???. 9,1\n??..????.? 1,4\n????#???#?.? 9,1\n#???.??????? 3,1,2,1\n.??????.?##??#. 6,3,1\n#.?.?#????#??#? 1,2,1,2,2\n##??##?.??? 6,1\n?????.????#???? 1,1,6" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       defmodule Day12 do

     

       27
       27
       +
         def parse_pattern(pattern) do

     

       28
       28
       +
           pattern

     

       29
       29
       +
           |> String.to_charlist()

     

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

     

       31
       31
       +
           |> do_chunking()

     

       32
       32
       +
           |> Enum.chunk_by(&(elem(&1, 0) == :gap))

     

       33
       33
       +
           |> Enum.reject(&match?([{:gap, _}], &1))

     

       34
       34
       +
         end

     

       35
       35
       +
       

     

       36
       36
       +
         defp do_chunking([start | rest]), do: do_chunking(start, rest, 1)

     

       37
       37
       +
       

     

       38
       38
       +
         defp do_chunking(curr, [], acc), do: [{curr, acc}]

     

       39
       39
       +
         defp do_chunking(curr, [curr | rest], acc), do: do_chunking(curr, rest, acc + 1)

     

       40
       40
       +
         defp do_chunking(curr, [next | rest], acc), do: [{curr, acc} | do_chunking(next, rest, 1)]

     

       41
       41
       +
       

     

       42
       42
       +
         defp symbol_to_type(?.), do: :gap

     

       43
       43
       +
         defp symbol_to_type(??), do: :wild

     

       44
       44
       +
         defp symbol_to_type(?#), do: :lava

     

       45
       45
       +
       end

     

       46
       46
       +
       ```

     

       47
       47
       +
       

     

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

     

       49
       49
       +
       

     

       50
       50
       +
       ```

     

       51
       51
       +
       {:module, Day12, <<70, 79, 82, 49, 0, 0, 10, ...>>, {:symbol_to_type, 1}}

     

       52
       52
       +
       ```

     

       53
       53
       +
       

     

       54
       54
       +
       ```elixir

     

       55
       55
       +
       puzzles =

     

       56
       56
       +
         puzzle_input

     

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

     

       58
       58
       +
         |> Enum.map(fn line ->

     

       59
       59
       +
           [pattern, values] = String.split(line)

     

       60
       60
       +
           values = values |> String.split(",") |> Enum.map(&String.to_integer/1)

     

       61
       61
       +
       

     

       62
       62
       +
           {Day12.parse_pattern(pattern), values}

     

       63
       63
       +
         end)

     

       64
       64
       +
       ```

     

       65
       65
       +
       

     

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

     

       67
       67
       +
       

     

       68
       68
       +
       ```

     

       69
       69
       +
       [

     

       70
       70
       +
         {[[lava: 1, wild: 2], [lava: 1, wild: 2], [wild: 1]], [3, 1, 1, 1]},

     

       71
       71
       +
         {[[wild: 3], [lava: 2, wild: 2, lava: 1, wild: 6, lava: 1, wild: 3, lava: 1]], [1, 13, 1]},

     

       72
       72
       +
         {[[wild: 2, lava: 1], [wild: 1, lava: 1, wild: 2, lava: 1, wild: 4, lava: 1, wild: 2]],

     

       73
       73
       +
          [2, 4, 1, 1, 1]},

     

       74
       74
       +
         {[

     

       75
       75
       +
            [wild: 3, lava: 1, wild: 2, lava: 1],

     

       76
       76
       +
            [wild: 3, lava: 1],

     

       77
       77
       +
            [wild: 1, lava: 1, wild: 2, lava: 1, wild: 1, lava: 1]

     

       78
       78
       +
          ], [4, 2, 1, 2, 1, 4]},

     

       79
       79
       +
         {[[wild: 4, lava: 1, wild: 1, lava: 2, wild: 3, lava: 1], [wild: 2], [wild: 1]], [2, 2, 6, 1]},

     

       80
       80
       +
         {[[wild: 5, lava: 1, wild: 3], [lava: 3], [lava: 2, wild: 1]], [7, 3, 2]},

     

       81
       81
       +
         {[[lava: 3, wild: 1], [lava: 1, wild: 6, lava: 1, wild: 4]], [4, 8, 1]},

     

       82
       82
       +
         {[[wild: 15]], [1, 1, 1, 2, 1]},

     

       83
       83
       +
         {[[wild: 3], [wild: 8, lava: 1, wild: 1]], [1, 3, 1, 1]},

     

       84
       84
       +
         {[

     

       85
       85
       +
            [wild: 3],

     

       86
       86
       +
            [lava: 1],

     

       87
       87
       +
            [wild: 1, lava: 1],

     

       88
       88
       +
            [wild: 1, lava: 1, wild: 1, lava: 1, wild: 2, lava: 1, wild: 1]

     

       89
       89
       +
          ], [2, 1, 1, 5, 1]},

     

       90
       90
       +
         {[[wild: 1], [wild: 2, lava: 1], [wild: 4]], [1, 3, 1, 2]},

     

       91
       91
       +
         {[[lava: 1, wild: 1], [wild: 2, lava: 1, wild: 5, lava: 2], [lava: 1]], [1, 2, 1, 3, 1]},

     

       92
       92
       +
         {[[wild: 1, lava: 3, wild: 4], [lava: 1, wild: 2]], [5, 1, 2]},

     

       93
       93
       +
         {[[wild: 1, lava: 1, wild: 2], [wild: 5]], [2, 4]},

     

       94
       94
       +
         {[[wild: 1], [lava: 1, wild: 4, lava: 1, wild: 5, lava: 1, wild: 2, lava: 1, wild: 2]],

     

       95
       95
       +
          [1, 6, 1, 4, 1]},

     

       96
       96
       +
         {[[lava: 1, wild: 8, lava: 1, wild: 1, lava: 1, wild: 2]], [1, 7, 1, 1]},

     

       97
       97
       +
         {[[wild: 1, lava: 1, wild: 2], [wild: 6]], [3, 1, 1]},

     

       98
       98
       +
         {[[wild: 1], [wild: 2, lava: 1, wild: 1, lava: 3, wild: 2]], [1, 6]},

     

       99
       99
       +
         {[[wild: 3], [wild: 1], [wild: 2, lava: 1, wild: 2, lava: 2, wild: 2]], [1, 1, 1, 5, 1]},

     

       100
       100
       +
         {[[lava: 1, wild: 3, lava: 1], [wild: 6]], [2, 1, 3, 1]},

     

       101
       101
       +
         {[[wild: 1, lava: 3, wild: 2], [wild: 2], [wild: 1, lava: 1, wild: 3], [wild: 1]],

     

       102
       102
       +
          [4, 1, 2, 1, 1, 1]},

     

       103
       103
       +
         {[[wild: 1], [lava: 1, wild: 3, lava: 1, wild: 1], [wild: 2]], [2, 1, 1]},

     

       104
       104
       +
         {[[lava: 1, wild: 2, lava: 2, wild: 4, lava: 2, wild: 6, lava: 1, wild: 1]], [7, 5, 2]},

     

       105
       105
       +
         {[[wild: 4, lava: 1, wild: 12, lava: 1]], [1, 6, 1, 1, 2]},

     

       106
       106
       +
         {[[lava: 1, wild: 1], [wild: 1], [lava: 2, wild: 4]], [1, 1, 5]},

     

       107
       107
       +
         {[[wild: 5], [wild: 1, lava: 1, wild: 8]], [1, 2, 2, 2, 1]},

     

       108
       108
       +
         {[[lava: 1, wild: 2], [wild: 3, lava: 1, wild: 1], [wild: 5]], [2, 5, 1, 1]},

     

       109
       109
       +
         {[[wild: 9], [lava: 1, wild: 3]], [6, 2]},

     

       110
       110
       +
         {[[wild: 10]], [1, 1, 4]},

     

       111
       111
       +
         {[[wild: 1, lava: 1, wild: 2, lava: 1, wild: 2, lava: 1, wild: 1, lava: 2]], [1, 7]},

     

       112
       112
       +
         {[[wild: 4, lava: 1, wild: 1, lava: 2, wild: 3, lava: 1, wild: 1]], [1, 6, 1, 1]},

     

       113
       113
       +
         {[[wild: 2, lava: 1, wild: 2, lava: 1], [wild: 3, lava: 1, wild: 6]], [1, 1, 1, 7, 1]},

     

       114
       114
       +
         {[[wild: 5, lava: 2, wild: 1], [wild: 1, lava: 1, wild: 2]], [1, 2, 4]},

     

       115
       115
       +
         {[[wild: 3, lava: 2, wild: 4, lava: 3, wild: 4]], [4, 7]},

     

       116
       116
       +
         {[[wild: 1], [wild: 1], [wild: 1], [wild: 1, lava: 1, wild: 4]], [1, 1, 6]},

     

       117
       117
       +
         {[[wild: 3], [wild: 2], [wild: 4], [lava: 3, wild: 2]], [2, 2, 2, 5]},

     

       118
       118
       +
         {[[wild: 4, lava: 2, wild: 2, lava: 1, wild: 5]], [1, 7, 1, 1]},

     

       119
       119
       +
         {[[wild: 3], [wild: 4, lava: 1, wild: 3]], [2, 6]},

     

       120
       120
       +
         {[[wild: 2], [wild: 8]], [1, 2]},

     

       121
       121
       +
         {[[wild: 1], [lava: 1, wild: 1], [wild: 5]], [1, 2]},

     

       122
       122
       +
         {[[wild: 6], [lava: 1, wild: 3, lava: 1, wild: 1]], [2, 5]},

     

       123
       123
       +
         {[[wild: 5, lava: 1], [lava: 3, wild: 3, lava: 1], [wild: 3, lava: 1]], [6, 7, 1, 1]},

     

       124
       124
       +
         {[[lava: 2], [wild: 4, lava: 2], [lava: 1, wild: 2, lava: 1, ...]], [2, 6, 1, 1]},

     

       125
       125
       +
         {[[wild: 5], [wild: 2], [wild: 9]], [1, 6]},

     

       126
       126
       +
         {[[wild: 6], [lava: 1, wild: 1, ...]], [4, 3]},

     

       127
       127
       +
         {[[lava: 1, wild: 6, ...], [wild: 1, ...]], [10, 2]},

     

       128
       128
       +
         {[[wild: 1], [...], ...], [1, ...]},

     

       129
       129
       +
         {[[...]], [...]},

     

       130
       130
       +
         {[...], ...},

     

       131
       131
       +
         {...},

     

       132
       132
       +
         ...

     

       133
       133
       +
       ]

     

       134
       134
       +
       ```

     

       135
       135
       +
       

     

       136
       136
       +
       ## Part 1

     

       137
       137
       +
       

     

       138
       138
       +
       ```elixir

     

       139
       139
       +
       defmodule Day12.Part1 do

     

       140
       140
       +
         def count_combinations([], []), do: 1

     

       141
       141
       +
         def count_combinations([[{:lava, lava} | _] | _], [segment | _]) when lava > segment, do: 0

     

       142
       142
       +
         def count_combinations(chunks, segments) when length(chunks) > length(segments), do: 0

     

       143
       143
       +
       

     

       144
       144
       +
         def count_combinations([chunk | rest], [segment | srest]) do

     

       145
       145
       +
           chunk_length = chunk_length(chunk)

     

       146
       146
       +
       

     

       147
       147
       +
           cond do

     

       148
       148
       +
             chunk_length < segment ->

     

       149
       149
       +
               0

     

       150
       150
       +
       

     

       151
       151
       +
             chunk_length == segment ->

     

       152
       152
       +
               count_combinations(rest, srest) + 1

     

       153
       153
       +
       

     

       154
       154
       +
             true ->

     

       155
       155
       +
               raise "Unimplemented"

     

       156
       156
       +
           end

     

       157
       157
       +
         end

     

       158
       158
       +
       

     

       159
       159
       +
         defp chunk_length(list), do: Enum.reduce(list, 0, fn {_, val}, acc -> acc + val end)

     

       160
       160
       +
       

     

       161
       161
       +
         defp chunk_splits(remaining, 0), do: {1, [remaining]}

     

       162
       162
       +
         defp chunk_splits([], segment) when segment > 0, do: {0, []}

     

       163
       163
       +
         defp chunk_splits([{:lava, n} | rest], segment), do: chunk_splits(rest, segment - n)

     

       164
       164
       +
       end

     

       165
       165
       +
       ```

     

       166
       166
       +
       

     

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

     

       168
       168
       +
       

     

       169
       169
       +
       ```

     

       170
       170
       +
       warning: variable "rest" is unused (if the variable is not meant to be used, prefix it with an underscore)

     

       171
       171
       +
         2023/day12.livemd#cell:h2soewijh5haeddpkqukqr3fug26rvi6:6: Day12.Part1.count_combinations/2

     

       172
       172
       +
       

     

       173
       173
       +
       warning: variable "srest" is unused (if the variable is not meant to be used, prefix it with an underscore)

     

       174
       174
       +
         2023/day12.livemd#cell:h2soewijh5haeddpkqukqr3fug26rvi6:6: Day12.Part1.count_combinations/2

     

       175
       175
       +
       

     

       176
       176
       +
       ```

     

       177
       177
       +
       

     

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

     

       179
       179
       +
       

     

       180
       180
       +
       ```

     

       181
       181
       +
       {:module, Day12.Part1, <<70, 79, 82, 49, 0, 0, 9, ...>>, {:chunk_length, 1}}

     

       182
       182
       +
       ```

     

       183
       183
       +
       

     

       184
       184
       +
       <!-- livebook:{"offset":10867,"stamp":{"token":"XCP.pErJuFAGcK1hyBg5n9FHQQCOc5uSp_xseil4UKha7AOJ2dF-diuCgS0T9sDTdi3bmDpRyQ3_9AYatfSZ6gVmYo8z2aHjDHdLDSoMb7a-ccykpMXbZIu3HqQdRGPO_mU6Fw","version":2}} -->

+303

2023/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
       +
       ## Setup

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":{"assign_to":"puzzle_input","day":"13","session_secret":"ADVENT_OF_CODE_SESSION","year":"2023"},"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("2023", "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
       +
        ".#..#......\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###.###\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##.#.....\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####.#.....\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......#....#...\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#.#.#.#.#..\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#....##........\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#.##...\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.##.#.#\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.##.##..#\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#..#..##..#\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
       +
       # puzzle_input =

     

       27
       27
       +
       """

     

       28
       28
       +
       #.##..##.

     

       29
       29
       +
       ..#.##.#.

     

       30
       30
       +
       ##......#

     

       31
       31
       +
       ##......#

     

       32
       32
       +
       ..#.##.#.

     

       33
       33
       +
       ..##..##.

     

       34
       34
       +
       #.#.##.#.

     

       35
       35
       +
       

     

       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
       +
       "#.##..##.\n..#.##.#.\n##......#\n##......#\n..#.##.#.\n..##..##.\n#.#.##.#.\n\n#...##..#\n#....#..#\n..##..###\n#####.##.\n#####.##.\n..##..###\n#....#..#\n"

     

       50
       50
       +
       ```

     

       51
       51
       +
       

     

       52
       52
       +
       ```elixir

     

       53
       53
       +
       defmodule Day13 do

     

       54
       54
       +
         def find_axes(list) do

     

       55
       55
       +
           reversed = Enum.reverse(list)

     

       56
       56
       +
       

     

       57
       57
       +
           len = length(list)

     

       58
       58
       +
       

     

       59
       59
       +
           back = dbg(do_find(list, 0))

     

       60
       60
       +
           front = dbg(do_find(reversed, 0))

     

       61
       61
       +
       

     

       62
       62
       +
           [

     

       63
       63
       +
             if(back, do: div(len - back, 2) + back),

     

       64
       64
       +
             if(front, do: div(len - front, 2))

     

       65
       65
       +
           ]

     

       66
       66
       +
           |> Enum.filter(& &1)

     

       67
       67
       +
         end

     

       68
       68
       +
       

     

       69
       69
       +
         defp do_find([_], _), do: nil

     

       70
       70
       +
       

     

       71
       71
       +
         defp do_find([_ | a], n) when rem(n, 2) == 0, do: do_find(a, n + 1)

     

       72
       72
       +
       

     

       73
       73
       +
         defp do_find(a, n) do

     

       74
       74
       +
           if palindrome?(a) do

     

       75
       75
       +
             n

     

       76
       76
       +
           else

     

       77
       77
       +
             do_find(tl(a), n + 1)

     

       78
       78
       +
           end

     

       79
       79
       +
         end

     

       80
       80
       +
       

     

       81
       81
       +
         def palindrome?(list) do

     

       82
       82
       +
           list == Enum.reverse(list)

     

       83
       83
       +
         end

     

       84
       84
       +
       

     

       85
       85
       +
         def print_mirror({rows, cols, _, _}) do

     

       86
       86
       +
           width = length(cols)

     

       87
       87
       +
       

     

       88
       88
       +
           display =

     

       89
       89
       +
             for row <- rows do

     

       90
       90
       +
               for digit <- Integer.digits(row, 2) do

     

       91
       91
       +
                 if digit == 1, do: "#", else: "."

     

       92
       92
       +
               end

     

       93
       93
       +
               |> List.to_string()

     

       94
       94
       +
               |> String.pad_leading(width, ".")

     

       95
       95
       +
             end

     

       96
       96
       +
       

     

       97
       97
       +
           IO.puts(Enum.intersperse(display, "\n"))

     

       98
       98
       +
         end

     

       99
       99
       +
       end

     

       100
       100
       +
       ```

     

       101
       101
       +
       

     

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

     

       103
       103
       +
       

     

       104
       104
       +
       ```

     

       105
       105
       +
       {:module, Day13, <<70, 79, 82, 49, 0, 0, 20, ...>>, {:print_mirror, 1}}

     

       106
       106
       +
       ```

     

       107
       107
       +
       

     

       108
       108
       +
       ```elixir

     

       109
       109
       +
       mirrors =

     

       110
       110
       +
         puzzle_input

     

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

     

       112
       112
       +
         |> Enum.map(fn grid ->

     

       113
       113
       +
           mirror =

     

       114
       114
       +
             grid

     

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

     

       116
       116
       +
             |> Enum.map(fn line ->

     

       117
       117
       +
               for <<c <- line>>, do: if(c == ?#, do: 1, else: 0)

     

       118
       118
       +
             end)

     

       119
       119
       +
       

     

       120
       120
       +
           rows = Enum.map(mirror, &Integer.undigits(&1, 2))

     

       121
       121
       +
           cols = Enum.zip_with(mirror, &Integer.undigits(&1, 2))

     

       122
       122
       +
       

     

       123
       123
       +
           row = Day13.find_axes(rows)

     

       124
       124
       +
           col = Day13.find_axes(cols)

     

       125
       125
       +
       

     

       126
       126
       +
           {rows, cols, row, col}

     

       127
       127
       +
         end)

     

       128
       128
       +
       ```

     

       129
       129
       +
       

     

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

     

       131
       131
       +
       

     

       132
       132
       +
       ```

     

       133
       133
       +
       [

     

       134
       134
       +
         {[576, 320, 272, 1423, 591, 1391, 1833], [11, 69, 59, 8, 102, 3, 16, 15, 14, 14, 15], [], ~c"\t"},

     

       135
       135
       +
         {[727, 486, 2044, 819, 819, 2044, 486, 727, 1325, 503, 193, 292, 196],

     

       136
       136
       +
          [1168, 6048, 4058, 7405, 7405, 4058, 6056, 1168, 7419, 7016, 4924], [4], []},

     

       137
       137
       +
         {[26, 71, 71, 27, 18, 6, 84, 35, 104, 119, 119, 104, 35],

     

       138
       138
       +
          [3166, 63, 4940, 4626, 3276, 8109, 3629], ~c"\n", []},

     

       139
       139
       +
         {[87, 27, 15, 97, 97, 15, 27, 87, 95, 6, 34, 95, 67, 77, 77, 75, 95],

     

       140
       140
       +
          [78655, 12352, 100129, 52527, 84909, 118771, 130879], [4], []},

     

       141
       141
       +
         {[28948, 11524, 7312, 7312, 11520, 28948, 29291],

     

       142
       142
       +
          [67, 103, 91, 60, 60, 1, 102, 24, 1, 1, 90, 1, 98, 1, 1], [], [14]},

     

       143
       143
       +
         {[416, 418, 83, 97, 289, 332, 332, 289, 97, 83, 418, 416, 330],

     

       144
       144
       +
          [6631, 6150, 1753, 6966, 1032, 193, 192, 3085, 1848], [6], []},

     

       145
       145
       +
         {[4683, 7, 7, 4683, 7229, 385, 6553, 7228, 387, 2069, 3123, 1441, 7806, 3255, 1634],

     

       146
       146
       +
          [19844, 1462, 1183, 18437, 840, 842, 18437, 1183, 1462, 19844, 13478, 30807, 32634], [2], []},

     

       147
       147
       +
         {[370, 1952, 364, 197, 1856, 2039, 327, 1910, 1827, 1562, 1931, 448, 916, 1738, 1738],

     

       148
       148
       +
          [9971, 9975, 30684, 10783, 24459, 29376, 17060, 4147, 7044, 17395, 2896], [14], []},

     

       149
       149
       +
         {[23425, 9523, 6472, 17236, 17278, 32285, 23094, 6647, 6649, 6649, 6647, 23094, 32285, 17278,

     

       150
       150
       +
           17172],

     

       151
       151
       +
          [20239, 8708, 21500, 21500, 8708, 20239, 31987, 16624, 7410, 9722, 12287, 5734, 3999, 9626,

     

       152
       152
       +
           25332], [], [3]},

     

       153
       153
       +
         {[264, 15458, 32359, 32359, 408, 15867, 9722],

     

       154
       154
       +
          [24, 59, 58, 58, 59, 24, 71, 7, 59, 59, 7, 71, 24, 59, 26], [], [3]},

     

       155
       155
       +
         {[131059, 65309, 65301, 91878, 23060, 16956, 82644, 33027, 33027, 82646, 16956],

     

       156
       156
       +
          [1170, 1804, 2035, 1920, 1856, 1856, 1920, 2035, 1804, 1170, 1170, 1185, 1907, 545, 1011, 1166,

     

       157
       157
       +
           1804], [], [5]},

     

       158
       158
       +
         {[186, 107, 407, 407, 107, 186, 1364, 211, 753, 689, 211, 1364, 186, 107, 407],

     

       159
       159
       +
          [264, 96, 6409, 23285, 9690, 26214, 23549, 26118, 6409, 32407, 15603], [3], []},

     

       160
       160
       +
         {[11602, 63, 29650, 28032, 4705, 11550, 24734, 7756, 24972],

     

       161
       161
       +
          [101, 365, 82, 298, 298, 82, 361, 101, 338, 144, 460, 143, 143, 460, 144], [], ~c"\f"},

     

       162
       162
       +
         {[1980, 10172, 22140, 25983, 11116, 6500, 30788, 5172, 18740, 8239, 24, 16875, 24967, 735, 9604,

     

       163
       163
       +
           16836, 17152],

     

       164
       164
       +
          [25907, 46228, 19968, 7424, 123396, 118793, 112951, 98366, 31786, 129952, 123720, 127208, 130974,

     

       165
       165
       +
           8376, 8376], [], [14]},

     

       166
       166
       +
         {[19591, 18951, 632, 14023, 883, 13066, 12628],

     

       167
       167
       +
          [96, 11, 11, 96, 72, 62, 7, 72, 29, 20, 21, 18, 105, 110, 108], [], [2]},

     

       168
       168
       +
         {[899, 258, 495, 1418, 1167, 1703, 1703, 1167, 1418, 495, 258, 899, 722, 284, 284, 658, 899],

     

       169
       169
       +
          [16128, 68659, 123373, 98227, 16528, 19584, 30, 29580, 24204, 131059, 89761], [6], []},

     

       170
       170
       +
         {[115, 15, 37, 88, 68, 68, 88], ~c"OPI)6`p", [5], []},

     

       171
       171
       +
         {[4128, 20521, 10128, 10326, 8166, 6048, 7398, 20431, 16118, 18505, 24601, 774, 13488],

     

       172
       172
       +
          [2092, 1557, 6609, 888, 1521, 1458, 1442, 1521, 888, 6609, 1557, 2092, 882, 882, 2092], [],

     

       173
       173
       +
          ~c"\r"},

     

       174
       174
       +
         {~c"\v\bOO\b\v]5.62.5", [1600, 63, 109, 8146, 1659, 5790, 5857], [3], []},

     

       175
       175
       +
         {[70, 115, 52, 470, 102, 462, 84, 484, 62, 444, 467, 127, 127, 465, 444, 62, 484],

     

       176
       176
       +
          [10957, 10957, 114297, 54199, 58878, 2486, 98231, 113010, 32888], [], [1]},

     

       177
       177
       +
         {[198, 306, 463, 310, 204, 315, 219, 27, 217, 216, 216, 217, 27],

     

       178
       178
       +
          [3712, 5470, 5470, 2688, 2815, 1535, 5888, 7905, 1267], ~c"\n", []},

     

       179
       179
       +
         {[71371, 104223, 104221, 71371, 8422, 31421, 31421, 8422, 71371],

     

       180
       180
       +
          [481, 192, 12, 30, 493, 12, 481, 493, 192, 319, 307, 30, 204, 493, 222, 435, 493], [6], []},

     

       181
       181
       +
         {[13279, 13278, 13719, 19445, 8600, 26086, 518, 26199, 3242, 2488, 2488],

     

       182
       182
       +
          [168, 1896, 1792, 135, 300, 1688, 2019, 2023, 1704, 167, 1995, 1607, 1976, 1852, 1416], ~c"\n",

     

       183
       183
       +
          []},

     

       184
       184
       +
         {[1237, 2022, 1161, 1161, 2022, 1237, 1177, 1131, 2029, 79, 1946],

     

       185
       185
       +
          [2045, 581, 581, 2037, 1646, 588, 1073, 415, 1638, 587, 1470], [3], []},

     

       186
       186
       +
         {[111450, 7065, 54910, 54910, 7065, 111450, 127548, 25051, 61861, 61569, 102656, 53858, 127683,

     

       187
       187
       +
           87229, 114432],

     

       188
       188
       +
          [17175, 23421, 6638, 17381, 32639, 9217, 6147, 32525, 26321, 9446, 23180, 6474, 32642, 32642,

     

       189
       189
       +
           6466, 23180, 9446], [3], []},

     

       190
       190
       +
         {[20, 22, 436, 394, 359, 359, 394], [31, 25, 6, 22, 112, 9, 118, 47, 6], [5], []},

     

       191
       191
       +
         {[100217, 100217, 46111, 64677, 64959, 18555, 64861, 131030, 388, 112431, 66318, 67525, 118470],

     

       192
       192
       +
          [6191, 8041, 993, 1896, 1896, 993, 8043, 6191, 6526, 819, 6371, 7048, 7648, 7628, 1919, 1453,

     

       193
       193
       +
           8138], [1], []},

     

       194
       194
       +
         {[291, 1, 24, 28, 1, 291, 492], [67, 1, 1, 67, 24, 25, 9, 66, 102], [], [2]},

     

       195
       195
       +
         {~c"2aa2\n}|\n2", [204, 493, 301, 30, 12, 307, 200], [2], []},

     

       196
       196
       +
         {[3115, 4616, 3100, 4656, 4643, 1344, 167], [44, 80, 82, 44, 2, 1, 2, 77, 24, 112, 17, 69, 69],

     

       197
       197
       +
          [], ~c"\f"},

     

       198
       198
       +
         {[67339, 92194, 8007, 70176, 4382, 5406, 70176, 8007, 92194, 67339, 55372, 10833, 123746, 57569,

     

       199
       199
       +
           57569],

     

       200
       200
       +
          [26980, 23, 8279, 8271, 8080, 12504, 21152, 22956, 22180, 3, 4255, 10567, 1544, 17968, 5776,

     

       201
       201
       +
           30436, 20651], [14], []},

     

       202
       202
       +
         {[6424, 26178, 346, 6490, 23485, 15384, 14592, 9703, 26392, 23515, 32280, 32475, 15706, 32358,

     

       203
       203
       +
           9471, 23320, 17254],

     

       204
       204
       +
          [37355, 36732, 81146, 81146, 35708, 37355, 96147, 4772, 58045, 4621, 96758, 96758, 4621, 58045,

     

       205
       205
       +
           4772], [], ~c"\v"},

     

       206
       206
       +
         {[75457, 7450, 103542, 100685, 20575, 20575, 117069, 103542, 7450, 75457, 75457, 7450, 103542,

     

       207
       207
       +
           117069, 20575],

     

       208
       208
       +
          [22966, 6534, 1795, 16432, 14029, 10570, 28924, 16432, 10570, 16432, 24503, 4228, 14029, 12107,

     

       209
       209
       +
           8071, ...], ~c"\n", []},

     

       210
       210
       +
         {[114654, 1118, 92031, 101299, 101299, 92031, 1118, 114654, 31935, 80545, 20702, 1480, 17953,

     

       211
       211
       +
           69836, 60269, ...],

     

       212
       212
       +
          [96904, 78341, 18775, 84868, 66504, 78725, 118578, 96919, 96805, 78826, 118382, 31124, 130880,

     

       213
       213
       +
           118637, ...], [4], []},

     

       214
       214
       +
         {[14474, 14474, 17870, 27951, 39, 7069, 240, 31399, 31655, 240, 7069],

     

       215
       215
       +
          [396, 1676, 1581, 1709, 384, 45, 421, 1855, 274, 222, 51, 1953, 493, ...], [1], []},

     

       216
       216
       +
         {[36, 36, 84, 53, 75, 28, 32, 126, 125, 125, 126, 36, 28, ...],

     

       217
       217
       +
          [5362, 27129, 6901, 1782, 31485, 1170, 3171], [1], []},

     

       218
       218
       +
         {[4259, 8068, 7, 8168, 4551, 6595, 1584, 4292, 84],

     

       219
       219
       +
          [442, 168, 164, 164, 184, 442, 59, 292, 5, 32, 211, ...], [], ~c"\f"},

     

       220
       220
       +
         {[130987, 86, 74905, 93, 126, 56186, 81145, 81094, 23097, 81025, 124915, ...],

     

       221
       221
       +
          [20924, 16916, 16980, 20924, 17386, 17386, 20924, 16980, 16916, 20924, ...], [], [5]},

     

       222
       222
       +
         {[38804, 125056, 92872, 151, 1196, 129732, 62279], [50, 99, 51, 51, 67, 50, 68, 83, 65, ...], [],

     

       223
       223
       +
          [16]},

     

       224
       224
       +
         {[54, 11, 393, 54, 127, 127, 54, 393, 11, ...],

     

       225
       225
       +
          [1056, 1057, 388, 5069, 5071, 3510, 5066, 7130, ...], [5], []},

     

       226
       226
       +
         {[391, 2025, 404, 2039, 188, 1629, 1605, 1894, ...],

     

       227
       227
       +
          [44902, 44902, 123750, 127129, 44866, 45628, 31078, ...], [], [1]},

     

       228
       228
       +
         {[1658, 1655, 26, 2019, 1637, 1649, 1655, ...], [446, 444, 34, 34, 444, 446, ...], [], [3]},

     

       229
       229
       +
         {[365, 1438, 1069, 780, 1216, 1664, ...], [14332, 2892, 27071, 10003, 17863, ...], [14], []},

     

       230
       230
       +
         {[7917, 64, 436, 297, 7982, ...], [70857, 70889, 70889, 70857, ...], [], [2]},

     

       231
       231
       +
         {[7224, 12736, 21104, 27923, ...], [32323, 42255, 121795, ...], [5], []},

     

       232
       232
       +
         {[203, 313, 1753, ...], [5527, 5527, ...], [], [...]},

     

       233
       233
       +
         {[41, 73, ...], [685, ...], [], ...},

     

       234
       234
       +
         {[116426, ...], [...], ...},

     

       235
       235
       +
         {[...], ...},

     

       236
       236
       +
         {...},

     

       237
       237
       +
         ...

     

       238
       238
       +
       ]

     

       239
       239
       +
       ```

     

       240
       240
       +
       

     

       241
       241
       +
       ## Part 1

     

       242
       242
       +
       

     

       243
       243
       +
       ```elixir

     

       244
       244
       +
       Enum.map(mirrors, fn {_, _, row, col} ->

     

       245
       245
       +
         List.first(col, 0) + List.first(row, 0) * 100

     

       246
       246
       +
       end)

     

       247
       247
       +
       |> Enum.sum()

     

       248
       248
       +
       ```

     

       249
       249
       +
       

     

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

     

       251
       251
       +
       

     

       252
       252
       +
       ```

     

       253
       253
       +
       40006

     

       254
       254
       +
       ```

     

       255
       255
       +
       

     

       256
       256
       +
       ## Part 2

     

       257
       257
       +
       

     

       258
       258
       +
       ```elixir

     

       259
       259
       +
       defmodule Day13.Part2 do

     

       260
       260
       +
         import Bitwise

     

       261
       261
       +
       

     

       262
       262
       +
         def alternatives(list, a, n) do

     

       263
       263
       +
           l = length(list)

     

       264
       264
       +
       

     

       265
       265
       +
           list =

     

       266
       266
       +
             for i <- 0..n,

     

       267
       267
       +
                 d = bsl(1, i),

     

       268
       268
       +
                 j <- 0..l,

     

       269
       269
       +
                 desmudged = List.update_at(list, j, &bxor(&1, d)),

     

       270
       270
       +
                 v <- Day13.find_axes(desmudged),

     

       271
       271
       +
                 v not in a,

     

       272
       272
       +
                 do: v

     

       273
       273
       +
       

     

       274
       274
       +
           Enum.dedup(list)

     

       275
       275
       +
         end

     

       276
       276
       +
       end

     

       277
       277
       +
       ```

     

       278
       278
       +
       

     

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

     

       280
       280
       +
       

     

       281
       281
       +
       ```

     

       282
       282
       +
       {:module, Day13.Part2, <<70, 79, 82, 49, 0, 0, 11, ...>>, {:alternatives, 3}}

     

       283
       283
       +
       ```

     

       284
       284
       +
       

     

       285
       285
       +
       ```elixir

     

       286
       286
       +
       mirrors

     

       287
       287
       +
       |> Enum.with_index()

     

       288
       288
       +
       |> Enum.map(fn {{rows, cols, row, col}, _idx} ->

     

       289
       289
       +
         row = List.first(Day13.Part2.alternatives(rows, row, length(cols)), 0)

     

       290
       290
       +
         col = List.first(Day13.Part2.alternatives(cols, col, length(rows)), 0)

     

       291
       291
       +
       

     

       292
       292
       +
         row * 100 + col

     

       293
       293
       +
       end)

     

       294
       294
       +
       |> Enum.sum()

     

       295
       295
       +
       ```

     

       296
       296
       +
       

     

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

     

       298
       298
       +
       

     

       299
       299
       +
       ```

     

       300
       300
       +
       28627

     

       301
       301
       +
       ```

     

       302
       302
       +
       

     

       303
       303
       +
       <!-- livebook:{"offset":14833,"stamp":{"token":"XCP.8-i47duAdnzdKS-qi8IVDyDE21kJUyqTX55xsBPltOjjVtrJUuw2vu5-Ufhj9sPB_IGriiYKDwSN8h0k2cz2-dY78-3ZRE77glupVo5cCwEbWm4pbp6TLRefkSB06zCZdQ","version":2}} -->

+430

2023/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])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":{"assign_to":"puzzle_input","day":"14","session_secret":"ADVENT_OF_CODE_SESSION","year":"2023"},"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("2023", "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
       +
        "####....#..O#O..#.....OO.O#..O.......O.#OO.#...O.O..O..O..OO.##.O#...........#....##O#..O#.O.O......\n....#..#.........O.O#..OO#OO....O.....#O.#.O##..#...OO#OOO.O...#...O..#.O.#....##.....#O............\n...#O..#........#....O...O.......O#.##.O.......O..O#O#.#OO....O..O.......#O.........#O.#.O...#...#..\n#O...O...O.O..O..OO.#...O.O#....##O.##..#.OOO#...OO.#...OOO.#.O.#....#....O..##.....OO....#..O...#O.\n.#.......##.#...#...O............O...#......#..#.OO...O#....O.#..........O..O.OOO#.#O#....OO..#.#O.#\n..#..........#..O.O#.....O.OOO.#.##...##...OO..#..#.O#..OO.O#..#O..#O.O#.O.O#..#.#OOO..#OO.O.##..#..\n#..#....O.#O.O.#...O......O...###O.#...OOO#..#.O..#O.O..O.#OO...O...#..#OOO.....O...O...OO..##....O.\n...##....#..#.O#..#O...#.#......##.OO.O.......O....#O#..OOOO#....O.#OO.#O....#...O#O#..O.#.....O....\n...#O....#.#O........O.O#O....O...#.O....#....#...#O.....O.O.O.#.#.......#.........#O#........O.....\n...O...#.O#....#O#O.....O..O#...#O........O.#.##.....O.#...O..#...##O.#.#O#..O..##......#O.#...O#..#\n#..OO#.#.........O#......#O.##.O#...O..#.#.#.OO........#......#....#..#.......O.#O.##.###.####....O.\nO..O...#O..O..##.O..............#O......OOO#...#.#.#.........OO....OO....O#.#.O#.O.........#.......O\n..O#.#....O..#....#OO..##...#..#...O..##O...##.O..O.OO.#.###...O..#.OO..O#...#......#.....O.#..O..#.\nO..####.O..O.OO##.O...O..O#.#O..O...O..........#O.#..#..O..O#..O##O.O.#O.#..O.OO.O..#...O.#O..O.O.#.\n.......O..........#...OO.O#.#.#OOOO...OO#O..O.#.#......#O.#.#...#.O#......O.O.OO...#.##..#.O.#..O..#\n.#.....#O........#.O...#........O............#O......##.O..O..#.#......O#O..O...O..O.#.O...O.#..OOOO\n.......O#...O...OO#.....#..O.#O..##..#O.#....OO.##.#O#......O#..O....OO..#...#O...O...##O..O###..OOO\n...O...#..O..O..#O.O......#.O...#..O#..#..O.OO...O....O.#O#..###O....O..##OOO.#O.....#...#.....#...O\nO...OO.#...#...O.O..#O.OO..O.#.#.#O#.O.#.O..O#O.....##O..O#.O..O........O...#.......O#.#...#.#..OO..\n..OO..#.#.O#.OOO.....##.O..OOO##O#.O..O.##OOO...O..##.O......#O.##..#O..O....#.##.O###...##..O......\n.......O..OO....##......O..O#O.O.O#....#O.....#....O..O.OO...#.O.#..#....#.O..#O....O......##O.....#\n......O..#...O..O#O.#.O.......#.O#.....O.O#..#.#...O..##......O.O..O#.#.#..#.O.#O.O#.O.#......#.O...\n....O.....O..O.......#.O.OO.....O##....##.#OO..#O..#.#...##..O#O.O...O..OO..##....O#O..O....#...O.#O\n.......O.##O.#O#.........O#.OO....###.OO..O.#..#.....OO.O.O...O......O..O..O....O...#.#....#....#O..\nO..#O......#.O..#O.O.#......O#..#.O##..#.#.O.....#.O...O..OO..####.#...##......#.....#O#......OO.O.#\n...OOO.#O....O#O...O.##OO..#....OO...O.#.....OO.#OOO.#.........#....O....#.#..O.#O#.#...O.O...O.#...\n..O.#.OOO..O.#...#OO.#.O.##OO..O..####.#....#.OO##O..#.O..O#..O#....#..O#..#.O.O..O...O...O.....O.O.\n.#.#O.O..#.O.O##.....O#..#..#..OO##...OOO.#O...#.O#...#O....#OO.OO..#.OO#.OO#O#............O......#.\nO#..#....O...#.#.O....#.OOO.#.OO.....OO###.O..#..#.O..#...#.#....O#.O#....#.#.O.#.....#....O.....O#.\nO..O.#.....#.....OOO..O..OOO.#..#.##.O..O.......#..O.##O#...#.#.......#.#....#.O.O..OO..#.O..#..O#O.\n...O...O#....#O.......#........#.O.O..O.#O#...O...#..O.#..OO#O...#........O...#.....OO.#...#.O...#.#\nO.#.O#...O#....#OO.O.##......O...##..#..O#.#.#O.....OOO..#O....#...O..O#O....#.#....OO.#..#.....OO.#\n...O#..O.#.#..O........O.....#.........#.....O.......O......#..#.#O....#O.O#O.#..##O#....#O...O.O...\n#..O.O...O#..O.O.#O..#...O#....#..#...O..#O...O.....O..OO#OOO#OOO...#.O...#.OO#O.....#O.#.........O.\nO.O...#....O#OO...O.OO..#..OO...#..O..O.O....#...#..O..OOO#.....#..OO.#O....O.#.O.OOO.#OO....##OO..O\n.#O#.#.##...###O..O#...#.O.#.O...O#.O.....O....O..OOO....#...O...OO.....#.#O#O..#O......#.O.....#.#O\nO.#O.OO......##......O..OOO##.OOO.#..O...O.O#..#O.#O.O......#................##..#....#O......#.....\n........#.....##...OO.O......#..#.......#O.....O....O....#O.##..OO...O...O..........#..O.....OO...#.\n#..O.#.......O......O#.O..........#O#.O#.#..#..O..O#.O.O..O.O........O......O..O.O..O.O..#O....O#.#.\n...#...OO#..#..##.O.....O...........O.#O#O...##...O..#..#..O....#..O#O.##..O##......OOO....##..###.#\n.#..#....OOO......O#O...##O..O.OO...O..#.....#.O..##...." <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       puzzle_input =

     

       27
       27
       +
         """

     

       28
       28
       +
         O....#....

     

       29
       29
       +
         O.OO#....#

     

       30
       30
       +
         .....##...

     

       31
       31
       +
         OO.#O....O

     

       32
       32
       +
         .O.....O#.

     

       33
       33
       +
         O.#..O.#.#

     

       34
       34
       +
         ..O..#O..O

     

       35
       35
       +
         .......O..

     

       36
       36
       +
         #....###..

     

       37
       37
       +
         #OO..#....

     

       38
       38
       +
         """

     

       39
       39
       +
       ```

     

       40
       40
       +
       

     

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

     

       42
       42
       +
       

     

       43
       43
       +
       ```

     

       44
       44
       +
       "O....#....\nO.OO#....#\n.....##...\nOO.#O....O\n.O.....O#.\nO.#..O.#.#\n..O..#O..O\n.......O..\n#....###..\n#OO..#....\n"

     

       45
       45
       +
       ```

     

       46
       46
       +
       

     

       47
       47
       +
       ```elixir

     

       48
       48
       +
       map =

     

       49
       49
       +
         puzzle_input

     

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

     

       51
       51
       +
         |> Enum.with_index(0)

     

       52
       52
       +
         |> Enum.flat_map(fn {line, y} ->

     

       53
       53
       +
           line

     

       54
       54
       +
           |> String.to_charlist()

     

       55
       55
       +
           |> Enum.with_index()

     

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

     

       57
       57
       +
           |> Enum.map(fn

     

       58
       58
       +
             {?#, x} -> {{x, y}, :cube}

     

       59
       59
       +
             {?O, x} -> {{x, y}, :round}

     

       60
       60
       +
           end)

     

       61
       61
       +
         end)

     

       62
       62
       +
         |> Map.new()

     

       63
       63
       +
       

     

       64
       64
       +
       {width, height} = Enum.reduce(map, {0, 0}, fn {{x, y}, _}, {w, h} -> {max(x, w), max(y, h)} end)

     

       65
       65
       +
       ```

     

       66
       66
       +
       

     

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

     

       68
       68
       +
       

     

       69
       69
       +
       ```

     

       70
       70
       +
       {9, 9}

     

       71
       71
       +
       ```

     

       72
       72
       +
       

     

       73
       73
       +
       ## Part 1

     

       74
       74
       +
       

     

       75
       75
       +
       ```elixir

     

       76
       76
       +
       defmodule Day14 do

     

       77
       77
       +
         def weight(map, width, height) do

     

       78
       78
       +
           for(col <- 0..width, do: Day14.column_weight(map, col, height))

     

       79
       79
       +
           |> Enum.sum()

     

       80
       80
       +
         end

     

       81
       81
       +
       

     

       82
       82
       +
         def column_weight(map, col, height) do

     

       83
       83
       +
           do_column_weight(map, col, height, 0, 0, height)

     

       84
       84
       +
         end

     

       85
       85
       +
       

     

       86
       86
       +
         defp do_column_weight(_map, _col, -1, stack, sum, height) do

     

       87
       87
       +
           sum + sum(height + 1, stack)

     

       88
       88
       +
         end

     

       89
       89
       +
       

     

       90
       90
       +
         defp do_column_weight(map, col, row, stack, sum, height) do

     

       91
       91
       +
           case Map.fetch(map, {col, row}) do

     

       92
       92
       +
             :error ->

     

       93
       93
       +
               do_column_weight(map, col, row - 1, stack, sum, height)

     

       94
       94
       +
       

     

       95
       95
       +
             {:ok, :cube} ->

     

       96
       96
       +
               do_column_weight(map, col, row - 1, 0, sum + sum(height - row, stack), height)

     

       97
       97
       +
       

     

       98
       98
       +
             {:ok, :round} ->

     

       99
       99
       +
               do_column_weight(map, col, row - 1, stack + 1, sum, height)

     

       100
       100
       +
           end

     

       101
       101
       +
         end

     

       102
       102
       +
       

     

       103
       103
       +
         def sum(_, 0), do: 0

     

       104
       104
       +
         def sum(s, n), do: div((2 * s - n + 1) * n, 2)

     

       105
       105
       +
       

     

       106
       106
       +
         def print(map, width, height) do

     

       107
       107
       +
           for y <- 0..height do

     

       108
       108
       +
             row =

     

       109
       109
       +
               for x <- 0..width do

     

       110
       110
       +
                 case Map.get(map, {x, y}) do

     

       111
       111
       +
                   nil -> " "

     

       112
       112
       +
                   :cube -> "#"

     

       113
       113
       +
                   :round -> "O"

     

       114
       114
       +
                 end

     

       115
       115
       +
               end

     

       116
       116
       +
       

     

       117
       117
       +
             ["#{y}\t", row, "\n"]

     

       118
       118
       +
           end

     

       119
       119
       +
           |> IO.puts()

     

       120
       120
       +
         end

     

       121
       121
       +
       end

     

       122
       122
       +
       ```

     

       123
       123
       +
       

     

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

     

       125
       125
       +
       

     

       126
       126
       +
       ```

     

       127
       127
       +
       {:module, Day14, <<70, 79, 82, 49, 0, 0, 15, ...>>, {:print, 3}}

     

       128
       128
       +
       ```

     

       129
       129
       +
       

     

       130
       130
       +
       ```elixir

     

       131
       131
       +
       Day14.print(map, width, height)

     

       132
       132
       +
       ```

     

       133
       133
       +
       

     

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

     

       135
       135
       +
       

     

       136
       136
       +
       ```

     

       137
       137
       +
       0	O    #    

     

       138
       138
       +
       1	O OO#    #

     

       139
       139
       +
       2	     ##   

     

       140
       140
       +
       3	OO #O    O

     

       141
       141
       +
       4	 O     O# 

     

       142
       142
       +
       5	O #  O # #

     

       143
       143
       +
       6	  O  #O  O

     

       144
       144
       +
       7	       O  

     

       145
       145
       +
       8	#    ###  

     

       146
       146
       +
       9	#OO  #    

     

       147
       147
       +
       

     

       148
       148
       +
       ```

     

       149
       149
       +
       

     

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

     

       151
       151
       +
       

     

       152
       152
       +
       ```

     

       153
       153
       +
       :ok

     

       154
       154
       +
       ```

     

       155
       155
       +
       

     

       156
       156
       +
       ```elixir

     

       157
       157
       +
       Day14.weight(map, width, height)

     

       158
       158
       +
       ```

     

       159
       159
       +
       

     

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

     

       161
       161
       +
       

     

       162
       162
       +
       ```

     

       163
       163
       +
       136

     

       164
       164
       +
       ```

     

       165
       165
       +
       

     

       166
       166
       +
       ## Part 2

     

       167
       167
       +
       

     

       168
       168
       +
       ```elixir

     

       169
       169
       +
       defmodule Day14.Part2 do

     

       170
       170
       +
         def round(map, width, height) do

     

       171
       171
       +
           map

     

       172
       172
       +
           |> move(width, height)

     

       173
       173
       +
           |> rotate(height)

     

       174
       174
       +
           |> move(height, width)

     

       175
       175
       +
           |> rotate(width)

     

       176
       176
       +
           |> move(width, height)

     

       177
       177
       +
           |> rotate(height)

     

       178
       178
       +
           |> move(height, width)

     

       179
       179
       +
           |> rotate(width)

     

       180
       180
       +
         end

     

       181
       181
       +
       

     

       182
       182
       +
         def move(map, width, height) do

     

       183
       183
       +
           for(x <- 0..width, col = move_column(map, x, height), c <- col, into: %{}, do: c)

     

       184
       184
       +
         end

     

       185
       185
       +
       

     

       186
       186
       +
         def move_column(map, col, height) do

     

       187
       187
       +
           do_move(map, col, height, 0, [])

     

       188
       188
       +
         end

     

       189
       189
       +
       

     

       190
       190
       +
         defp do_move(_map, col, -1, stack, acc) do

     

       191
       191
       +
           expand_stack(0, col, stack) ++ acc

     

       192
       192
       +
         end

     

       193
       193
       +
       

     

       194
       194
       +
         defp do_move(map, col, row, stack, acc) do

     

       195
       195
       +
           case Map.fetch(map, {col, row}) do

     

       196
       196
       +
             :error ->

     

       197
       197
       +
               do_move(map, col, row - 1, stack, acc)

     

       198
       198
       +
       

     

       199
       199
       +
             {:ok, :cube} ->

     

       200
       200
       +
               do_move(

     

       201
       201
       +
                 map,

     

       202
       202
       +
                 col,

     

       203
       203
       +
                 row - 1,

     

       204
       204
       +
                 0,

     

       205
       205
       +
                 expand_stack(row + 1, col, stack) ++ [{{col, row}, :cube} | acc]

     

       206
       206
       +
               )

     

       207
       207
       +
       

     

       208
       208
       +
             {:ok, :round} ->

     

       209
       209
       +
               do_move(map, col, row - 1, stack + 1, acc)

     

       210
       210
       +
           end

     

       211
       211
       +
         end

     

       212
       212
       +
       

     

       213
       213
       +
         defp expand_stack(start, col, len) do

     

       214
       214
       +
           for y <- 0..(len - 1)//1, do: {{col, start + y}, :round}

     

       215
       215
       +
         end

     

       216
       216
       +
       

     

       217
       217
       +
         def rotate(map, height) do

     

       218
       218
       +
           Map.new(map, fn {{x, y}, v} ->

     

       219
       219
       +
             {{height - y, x}, v}

     

       220
       220
       +
           end)

     

       221
       221
       +
         end

     

       222
       222
       +
       

     

       223
       223
       +
         def rounds_with_memoisation(map, width, height) do

     

       224
       224
       +
           Stream.iterate(map, &round(&1, width, height))

     

       225
       225
       +
         end

     

       226
       226
       +
       end

     

       227
       227
       +
       ```

     

       228
       228
       +
       

     

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

     

       230
       230
       +
       

     

       231
       231
       +
       ```

     

       232
       232
       +
       {:module, Day14.Part2, <<70, 79, 82, 49, 0, 0, 17, ...>>, {:rounds_with_memoisation, 3}}

     

       233
       233
       +
       ```

     

       234
       234
       +
       

     

       235
       235
       +
       ```elixir

     

       236
       236
       +
       {nmap, _, _} =

     

       237
       237
       +
         Day14.Part2.rounds_with_memoisation(map, width, height)

     

       238
       238
       +
         |> Stream.with_index()

     

       239
       239
       +
         |> Enum.reduce_while(%{}, fn {map, idx}, set ->

     

       240
       240
       +
           case Map.fetch(set, map) do

     

       241
       241
       +
             :error -> {:cont, Map.put(set, map, idx)}

     

       242
       242
       +
             {:ok, prev} -> {:halt, {map, idx, prev}}

     

       243
       243
       +
           end

     

       244
       244
       +
         end)

     

       245
       245
       +
       ```

     

       246
       246
       +
       

     

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

     

       248
       248
       +
       

     

       249
       249
       +
       ```

     

       250
       250
       +
       {%{

     

       251
       251
       +
          {9, 8} => :round,

     

       252
       252
       +
          {4, 6} => :round,

     

       253
       253
       +
          {9, 9} => :round,

     

       254
       254
       +
          {7, 7} => :round,

     

       255
       255
       +
          {9, 7} => :round,

     

       256
       256
       +
          {1, 5} => :round,

     

       257
       257
       +
          {7, 5} => :cube,

     

       258
       258
       +
          {8, 1} => :round,

     

       259
       259
       +
          {0, 8} => :cube,

     

       260
       260
       +
          {9, 5} => :cube,

     

       261
       261
       +
          {4, 1} => :cube,

     

       262
       262
       +
          {9, 6} => :round,

     

       263
       263
       +
          {5, 9} => :cube,

     

       264
       264
       +
          {8, 7} => :round,

     

       265
       265
       +
          {6, 4} => :round,

     

       266
       266
       +
          {5, 4} => :round,

     

       267
       267
       +
          {9, 1} => :cube,

     

       268
       268
       +
          {5, 6} => :cube,

     

       269
       269
       +
          {5, 2} => :cube,

     

       270
       270
       +
          {4, 9} => :round,

     

       271
       271
       +
          {2, 5} => :cube,

     

       272
       272
       +
          {3, 9} => :round,

     

       273
       273
       +
          {0, 9} => :cube,

     

       274
       274
       +
          {4, 8} => :round,

     

       275
       275
       +
          {6, 2} => :cube,

     

       276
       276
       +
          {7, 8} => :cube,

     

       277
       277
       +
          {6, 5} => :round,

     

       278
       278
       +
          {6, 8} => :cube,

     

       279
       279
       +
          {2, 3} => :round,

     

       280
       280
       +
          {5, 0} => :cube,

     

       281
       281
       +
          {5, 8} => :cube,

     

       282
       282
       +
          {7, 4} => :round,

     

       283
       283
       +
          {3, 3} => :cube,

     

       284
       284
       +
          {8, 4} => :cube,

     

       285
       285
       +
          {2, 9} => :round

     

       286
       286
       +
        }, 10, 3}

     

       287
       287
       +
       ```

     

       288
       288
       +
       

     

       289
       289
       +
       ```elixir

     

       290
       290
       +
       Day14.Part2.rounds_with_memoisation(map, width, height)

     

       291
       291
       +
       |> Enum.take(11)

     

       292
       292
       +
       |> Stream.each(&Day14.print(&1, width, height))

     

       293
       293
       +
       |> Enum.map(&Day14.weight(&1, width, height))

     

       294
       294
       +
       |> IO.inspect(charlists: :as_lists)

     

       295
       295
       +
       ```

     

       296
       296
       +
       

     

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

     

       298
       298
       +
       

     

       299
       299
       +
       ```

     

       300
       300
       +
       0	O    #    

     

       301
       301
       +
       1	O OO#    #

     

       302
       302
       +
       2	     ##   

     

       303
       303
       +
       3	OO #O    O

     

       304
       304
       +
       4	 O     O# 

     

       305
       305
       +
       5	O #  O # #

     

       306
       306
       +
       6	  O  #O  O

     

       307
       307
       +
       7	       O  

     

       308
       308
       +
       8	#    ###  

     

       309
       309
       +
       9	#OO  #    

     

       310
       310
       +
       

     

       311
       311
       +
       0	     #    

     

       312
       312
       +
       1	    #   O#

     

       313
       313
       +
       2	   OO##   

     

       314
       314
       +
       3	 OO#      

     

       315
       315
       +
       4	     OOO# 

     

       316
       316
       +
       5	 O#   O# #

     

       317
       317
       +
       6	    O#    

     

       318
       318
       +
       7	      OOOO

     

       319
       319
       +
       8	#   O###  

     

       320
       320
       +
       9	#  OO#    

     

       321
       321
       +
       

     

       322
       322
       +
       0	     #    

     

       323
       323
       +
       1	    #   O#

     

       324
       324
       +
       2	     ##   

     

       325
       325
       +
       3	  O#      

     

       326
       326
       +
       4	     OOO# 

     

       327
       327
       +
       5	 O#   O# #

     

       328
       328
       +
       6	    O#   O

     

       329
       329
       +
       7	       OOO

     

       330
       330
       +
       8	#  OO###  

     

       331
       331
       +
       9	# OOO#   O

     

       332
       332
       +
       

     

       333
       333
       +
       0	     #    

     

       334
       334
       +
       1	    #   O#

     

       335
       335
       +
       2	     ##   

     

       336
       336
       +
       3	  O#      

     

       337
       337
       +
       4	     OOO# 

     

       338
       338
       +
       5	 O#   O# #

     

       339
       339
       +
       6	    O#   O

     

       340
       340
       +
       7	       OOO

     

       341
       341
       +
       8	#   O### O

     

       342
       342
       +
       9	# OOO#   O

     

       343
       343
       +
       

     

       344
       344
       +
       0	     #    

     

       345
       345
       +
       1	    #   O#

     

       346
       346
       +
       2	     ##   

     

       347
       347
       +
       3	  O#      

     

       348
       348
       +
       4	     OOO# 

     

       349
       349
       +
       5	 O#   O# #

     

       350
       350
       +
       6	    O#   O

     

       351
       351
       +
       7	       OOO

     

       352
       352
       +
       8	#   O### O

     

       353
       353
       +
       9	#  OO#  OO

     

       354
       354
       +
       

     

       355
       355
       +
       0	     #    

     

       356
       356
       +
       1	    #   O#

     

       357
       357
       +
       2	     ##   

     

       358
       358
       +
       3	   #      

     

       359
       359
       +
       4	     OOO# 

     

       360
       360
       +
       5	 O#   O# #

     

       361
       361
       +
       6	    O#   O

     

       362
       362
       +
       7	      OOOO

     

       363
       363
       +
       8	#   O### O

     

       364
       364
       +
       9	#  OO#  OO

     

       365
       365
       +
       

     

       366
       366
       +
       0	     #    

     

       367
       367
       +
       1	    #   O#

     

       368
       368
       +
       2	     ##   

     

       369
       369
       +
       3	   #      

     

       370
       370
       +
       4	     OOO# 

     

       371
       371
       +
       5	 O#   O# #

     

       372
       372
       +
       6	    O#   O

     

       373
       373
       +
       7	      OOOO

     

       374
       374
       +
       8	#    ### O

     

       375
       375
       +
       9	# OOO#  OO

     

       376
       376
       +
       

     

       377
       377
       +
       0	     #    

     

       378
       378
       +
       1	    #   O#

     

       379
       379
       +
       2	     ##   

     

       380
       380
       +
       3	  O#      

     

       381
       381
       +
       4	      OO# 

     

       382
       382
       +
       5	 O#   O# #

     

       383
       383
       +
       6	    O#   O

     

       384
       384
       +
       7	      OOOO

     

       385
       385
       +
       8	#    ### O

     

       386
       386
       +
       9	# OOO#  OO

     

       387
       387
       +
       

     

       388
       388
       +
       0	     #    

     

       389
       389
       +
       1	    #   O#

     

       390
       390
       +
       2	     ##   

     

       391
       391
       +
       3	  O#      

     

       392
       392
       +
       4	      OO# 

     

       393
       393
       +
       5	 O#   O# #

     

       394
       394
       +
       6	    O#    

     

       395
       395
       +
       7	      OOOO

     

       396
       396
       +
       8	#   O### O

     

       397
       397
       +
       9	# OOO#  OO

     

       398
       398
       +
       

     

       399
       399
       +
       0	     #    

     

       400
       400
       +
       1	    #   O#

     

       401
       401
       +
       2	     ##   

     

       402
       402
       +
       3	  O#      

     

       403
       403
       +
       4	     OOO# 

     

       404
       404
       +
       5	 O#   O# #

     

       405
       405
       +
       6	    O#    

     

       406
       406
       +
       7	      OOOO

     

       407
       407
       +
       8	#   O### O

     

       408
       408
       +
       9	# OOO#   O

     

       409
       409
       +
       

     

       410
       410
       +
       0	     #    

     

       411
       411
       +
       1	    #   O#

     

       412
       412
       +
       2	     ##   

     

       413
       413
       +
       3	  O#      

     

       414
       414
       +
       4	     OOO# 

     

       415
       415
       +
       5	 O#   O# #

     

       416
       416
       +
       6	    O#   O

     

       417
       417
       +
       7	       OOO

     

       418
       418
       +
       8	#   O### O

     

       419
       419
       +
       9	# OOO#   O

     

       420
       420
       +
       

     

       421
       421
       +
       [136, 129, 114, 110, 110, 105, 103, 106, 111, 114, 110]

     

       422
       422
       +
       ```

     

       423
       423
       +
       

     

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

     

       425
       425
       +
       

     

       426
       426
       +
       ```

     

       427
       427
       +
       [136, 129, 114, 110, 110, 105, 103, 106, 111, 114, 110]

     

       428
       428
       +
       ```

     

       429
       429
       +
       

     

       430
       430
       +
       <!-- livebook:{"offset":13089,"stamp":{"token":"XCP.6NDtt8fJ01JLOq3nTevL25H4mHLTDc6Od4j4bkK8EzYDIEbnkcC_afNOcboznLxeJd_Vr-eQOTfSeVj0rfhlPWRbNSo_OLjTWZxTnB_TdqgAr5J0iWjRjf2BDccO40DsHw","version":2}} -->

+130

2023/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":{"assign_to":"puzzle_input","day":"15","session_secret":"ADVENT_OF_CODE_SESSION","year":"2023"},"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("2023", "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
       +
        "kv-,lmv-,zlg=4,hn=2,qp=8,dxd-,pk=3,pxfnc-,jgjch-,dp=3,lffh-,sprsl=1,hns=6,fl=1,hn-,ltgg-,hl-,gx-,sv-,lz-,qqxd-,jxgxjv-,hvlh=2,tnf=8,sprsl=1,tbxjmh=7,cv=3,zl-,tbcz=3,gcknh=6,jqzcc=2,gdx-,kqfg=5,lrc=1,gqq-,ztl-,cct-,ktb=8,vs-,cnpx=4,hsq=3,ht-,nb-,mqv=1,vvhsz-,bhqq=6,tdc=6,zf=6,qxh=6,th-,ltl-,rpk=9,krn=3,mqh=9,zt-,hm=9,tbxjmh=7,rmc-,qvsq=9,gdr-,czq-,jk-,lnrsql=7,fqqz-,kfrtbv-,bmm=7,psxz=3,qkr=7,ckf=5,dl-,psfh-,qqrmbj=5,tnvl-,ffnx-,ttd-,tg-,hhhk-,qx-,ldx=1,gr=6,tvj-,jqzcc=4,gvk=3,nft=2,rc=4,hk=5,tbxjmh=8,mlxs-,lmv=3,ht=7,jgb-,tbxjmh-,gmfc=2,bxg-,tmqp-,gld-,kcvf-,ggdr-,psxz=1,lt-,cm-,pxfnc-,sdmhxq-,brr=6,bjv-,th-,td=1,jsvc-,rkjbzv=1,cbbq-,nqpsc-,cgvvt-,vtm-,vk=3,tjr=9,pbm=7,gjl-,fkrl-,js=2,zjn=2,sprsl=9,rk=7,hpd=8,bgmhj-,czq-,xxcfk=9,qdxb-,ns=1,mx-,dhs-,xf-,ttd=9,tvj=8,kng-,hm-,rpk=5,hrk-,lpbk-,lbzxd=8,vmcj-,mmb-,ks-,ks=6,mx=6,xq=8,mkn-,cnpx-,rx=3,vfpj-,zl-,tgt=4,krn=7,hmr=4,gcknh-,rg=9,nb=3,jc-,qdxb=2,lffh-,ksclkb=6,pxrflz-,kkxp-,tbcz-,zt-,ltn-,rmc=1,cpscb-,zsrpq-,snnd-,kg=6,fbhvr-,kng=9,mck=3,xtz=7,bbsn=9,ht=9,zgq-,bh-,spv=5,rjg=7,tsc=1,dbvmr=3,hk-,nkg-,vzlvs-,bcxgj=1,sqhb=6,tv-,tlt-,vqm=4,vmcj=6,rx=3,hmr-,jzpt-,pmq-,hrk-,jx=2,bq=4,dxn=3,tgsr-,xlkg-,nrj-,lz-,bnlk=2,jxp=1,hfztr=8,gt=2,lgn=7,dpmt-,xj-,pj-,nzx-,jn=8,hpd-,dfgm-,qkr-,qqrmbj=1,tpn=5,rc=8,hnhm=1,vzlvs=6,bt=8,mhzf=2,hrk-,vzlvs-,sfg-,jzpt-,jqzcc=3,vvt-,ffnx=6,btt-,pbm-,hzkpq-,gdr-,mx=6,rn=9,qkr=6,ks-,zf-,nkg=2,ptrtg-,dxn-,xf-,cv-,vf=5,qk=4,zlg=8,sfg=3,sn-,hsq=5,tg=8,dn=2,jn=1,spv=9,hhhk=9,nkc=7,rm=3,hrhmdx-,zdtxcq=3,chb-,jxb-,psfh=9,pn-,jgb=2,clh=9,crg-,vgxg-,kq=3,qfz=6,rq=3,qvz=2,dl-,vtm-,rn-,kng=5,jv-,cgz=7,fff=7,gmfc=6,jgb=4,zf-,bt-,lqkmtd-,xlv=3,pjn=6,bstf-,rn-,kb-,tcp-,bx-,gkj-,vpp-,fznq-,xlg=8,qdq=2,hk=1,gdr=6,qd-,nsc=3,vfpj=7,qjjnq-,sstlb-,zs=6,qhm-,pmq-,gqblq-,pnnd=9,ztl=1,bmmdqk-,fkpd-,mm-,gs-,bnlk-,sstlb-,ct=6,hstx-,khq=9,gjd=3,fbhvr-,qqxd-,hrhmdx-,vnj=3,lrc-,hnhm=7,lsr=4,gqblq-,sprsl=7,gfm-,dg-,fmf=5,tsc=9,sz=1,tpn=6,gld-,rmc=4,spv-,xhs=2,hn-,sfv=8,rhg-,dd-,fzl-,hlq=3,czq=4,nvm-,fhgz=1,jzrz=4,jntz-,jj=2,rpk=8,bjv=3,lgn=7,hzj-,xhd=8,nnx-,gdr-,hzls=9,kdt-,vvt-,bgmhj=1,ldx=7,tcp-,kntk=9,brv-,xd=6,cn-,pdb-,jk-,qh-,vmcj-,jj=6,dn=9,mdzv-,pvk=4,gmfc-,rmj-,sh-,cl=6,pvk=1,mk=7,hx=5,gqq=5,jc-,qf-,tmqp-,srtm-,fqqz=1,rjkvz=4,nff=4,vs=6,zsrpq-,bpkc-,qqxd-,lsbk-,gcknh=9,gmfc-,nxrcnk-,gjl=5,th-,tsc-,pdqkq=6,zk-,zt=6,bp-,hn-,pd=5,jqjdg=6,pjm=7,dh-,mlnc-,psfh-,rm-,nndl=2,tnf=5,gt-,dfm-,rlr=2,pmbfzf-,lt-,vgxg-,xlv-,qr=6,xqst-,pjm-,prj=8,ztgp-,zt-,lrc=2,pln-,bd-,cmnj-,xp=5,cm-,bcqvf=9,gp=8,bd=4,hvlh=4,bpkc=9,ld-,vj-,lnrsql-,vsp-,prj=8,fbhvr-,bd=8,qf=2,zjn-,tbxjmh-,xhs-,kcvf=4,tgsr=4,zk-,sxz-,hmr=4,pj=9,hl-,sgl-,jz-,mbm-,gjl=8,sstlb-,vdd=7,nb=5,snvxq-,fz=3,bh=6,db-,vdd=2,bmmdqk-,qsbf=2,tv=1,prj=5,kqp-,vzlvs-,lplqhd-,tqtqg=5,ddq=4,mmz-,vfdtt=4,vvhsz=8,zq=3,pn=7,lgn-,tzpv-,zqq-,fzc-,rl-,srtm-,tpn-,cl=7,fz=7,tnvl-,dhx-,td-,hzkpq-,kqfg-,xbz=5,rpk-,nbhcs=5,jj-,xp=2,kp=8,rfxck-,vj=8,bvfl-,hft=8,jj=4,qtd-,bcqvf-,dh=3,xt-,mbc-,msd=7,zqq=7,pdqkq-,qr=4,rhg=2,vzlvs=9,dh=2,hrhmdx-,vvt-,zs=8,dxd-,gkxmlj-,tgsr=1,tf=5,qdxb-,kq=7,mlxs-,jjxlh=8,lplqhd-,rjkvz=3,fph=6,lmv-,mdx-,kcvf=5,vtd-,khq-,gqblq-,hzj=1,mkn-,bxg=7,qtd-,bnlk=9,ltn-,vnz=8,mk-,xnrnz=7,skmhp=3,ddq-,rc=5,vnj=6,sz=5,cl=6,qvz=1,vdd=4,hft=6,rmq=9,jntz=5,qs-,zqq-,mqh-,qh-,hh-,dbnrnp-,nrj-,mqv-,rmj-,nqpsc-,tq=5,cnk-,qctz=4,xfdh=9,ptrtg=7,nvm-,xlkg-,psgp=6,ns-,rrxq-,bcxgj-,xhs-,jgmn=6,mcs=9,gs-,kntk-,fp-,xd-,pn=8,tzpv=3,rrxq=4,vdd=1,xhd-,rmj-,mx-,spq=8,qqkv=8,mjpb=5,vgxg=8,sfv-,gld-,qqkv=7,rh-,tj=3,snnd=8,bd-,vgxg=6,kng-,gvk=3,jjxlh=5,jgm=5,qvsq-,nkc-,bqntx-,cfn=6,crg=1,kng-,hvlh-,xtxc=1,qqxd-,fzl=3,hjs=4,nvm-,hzkpq-,rk-,jv-,rjkvz-,cjq-,lkmj-,vtj-,xhp=1,qf=2,cnpx=9,psxz-,mcs-,jx=6,hx-,bt-,nsc=2,qctz-,rx-,kdt-,dbvmr-,ctn=8,lrc-,xmvfk-,xh-,vqm=8,mlnc=4,jgb-,cbbq-,vk-,csg-,jntz-,pcdffj-,xt-,xj-,fp-,bt-,kntk=1,ztl-,qkr-,clh-,bq=8,ztgp-,mk-,xfdh-,ncsm-,zhj-,tlt-,ncsm=1,mbc-,tqtqg-,pb-,bqgs=5,fhgz-,ksb-,lsr-,qvz-,tk=5,hns=5,pbxm=8,ct-,lrc-,flrj-,zd-,pg-,pdqkq=1,gxxk-,ffnx=4,zlg-,ts=5,bgmhj-,jjx=7,vl-,hx=1,jgmn-,lkmj-,rrgf-,qphsv=9,xj=1,cx-,prj=6,jndqj-,dxd=6,mcs-,rhg=2,jk=3,qsn-,jmfhs-,hk-,ts=7,pk=9,vmcj-,nzx-,bt-,mqh-,ctc-,nkg=4,rpk-,pdb=" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       # puzzle_input = "rn=1,cm-,qp=3,cm=2,qp-,pc=4,ot=9,ab=5,pc-,pc=6,ot=7"

     

       27
       27
       +
       ```

     

       28
       28
       +
       

     

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

     

       30
       30
       +
       

     

       31
       31
       +
       ```

     

       32
       32
       +
       nil

     

       33
       33
       +
       ```

     

       34
       34
       +
       

     

       35
       35
       +
       ```elixir

     

       36
       36
       +
       defmodule Day15 do

     

       37
       37
       +
         def hash(binary) do

     

       38
       38
       +
           for <<c <- binary>>, reduce: 0, do: (acc -> Bitwise.band((c + acc) * 17, 0xFF))

     

       39
       39
       +
         end

     

       40
       40
       +
       end

     

       41
       41
       +
       ```

     

       42
       42
       +
       

     

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

     

       44
       44
       +
       

     

       45
       45
       +
       ```

     

       46
       46
       +
       {:module, Day15, <<70, 79, 82, 49, 0, 0, 7, ...>>, {:hash, 1}}

     

       47
       47
       +
       ```

     

       48
       48
       +
       

     

       49
       49
       +
       ```elixir

     

       50
       50
       +
       segments =

     

       51
       51
       +
         puzzle_input

     

       52
       52
       +
         |> String.split(",")

     

       53
       53
       +
       ```

     

       54
       54
       +
       

     

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

     

       56
       56
       +
       

     

       57
       57
       +
       ```

     

       58
       58
       +
       ["kv-", "lmv-", "zlg=4", "hn=2", "qp=8", "dxd-", "pk=3", "pxfnc-", "jgjch-", "dp=3", "lffh-",

     

       59
       59
       +
        "sprsl=1", "hns=6", "fl=1", "hn-", "ltgg-", "hl-", "gx-", "sv-", "lz-", "qqxd-", "jxgxjv-",

     

       60
       60
       +
        "hvlh=2", "tnf=8", "sprsl=1", "tbxjmh=7", "cv=3", "zl-", "tbcz=3", "gcknh=6", "jqzcc=2", "gdx-",

     

       61
       61
       +
        "kqfg=5", "lrc=1", "gqq-", "ztl-", "cct-", "ktb=8", "vs-", "cnpx=4", "hsq=3", "ht-", "nb-",

     

       62
       62
       +
        "mqv=1", "vvhsz-", "bhqq=6", "tdc=6", "zf=6", "qxh=6", "th-", ...]

     

       63
       63
       +
       ```

     

       64
       64
       +
       

     

       65
       65
       +
       ## Part 1

     

       66
       66
       +
       

     

       67
       67
       +
       ```elixir

     

       68
       68
       +
       segments

     

       69
       69
       +
       |> Enum.map(&Day15.hash/1)

     

       70
       70
       +
       |> Enum.sum()

     

       71
       71
       +
       ```

     

       72
       72
       +
       

     

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

     

       74
       74
       +
       

     

       75
       75
       +
       ```

     

       76
       76
       +
       506869

     

       77
       77
       +
       ```

     

       78
       78
       +
       

     

       79
       79
       +
       ## Part 2

     

       80
       80
       +
       

     

       81
       81
       +
       ```elixir

     

       82
       82
       +
       segments

     

       83
       83
       +
       |> Enum.map(fn step ->

     

       84
       84
       +
         [_, label, action] = Regex.run(~r/([a-z]+)(-|=\d+)/, step)

     

       85
       85
       +
       

     

       86
       86
       +
         box = Day15.hash(label)

     

       87
       87
       +
       

     

       88
       88
       +
         case action do

     

       89
       89
       +
           "-" -> {box, label, :rm}

     

       90
       90
       +
           "=" <> rest -> {box, label, {:add, String.to_integer(rest)}}

     

       91
       91
       +
         end

     

       92
       92
       +
       end)

     

       93
       93
       +
       |> Enum.reduce(%{}, fn {box, label, action}, map ->

     

       94
       94
       +
         curr = map[box] || []

     

       95
       95
       +
       

     

       96
       96
       +
         next =

     

       97
       97
       +
           case action do

     

       98
       98
       +
             {:add, f} ->

     

       99
       99
       +
               if Enum.any?(curr, &(elem(&1, 0) == label)) do

     

       100
       100
       +
                 List.keyreplace(curr, label, 0, {label, f})

     

       101
       101
       +
               else

     

       102
       102
       +
                 [{label, f} | curr]

     

       103
       103
       +
               end

     

       104
       104
       +
       

     

       105
       105
       +
             :rm ->

     

       106
       106
       +
               List.keydelete(curr, label, 0)

     

       107
       107
       +
           end

     

       108
       108
       +
       

     

       109
       109
       +
         Map.put(map, box, next)

     

       110
       110
       +
       end)

     

       111
       111
       +
       |> Enum.map(fn {box, lenses} ->

     

       112
       112
       +
         box = box + 1

     

       113
       113
       +
       

     

       114
       114
       +
         lenses

     

       115
       115
       +
         |> Enum.reverse()

     

       116
       116
       +
         |> Enum.with_index(1)

     

       117
       117
       +
         |> Enum.map(fn {{_, f}, id} -> box * id * f end)

     

       118
       118
       +
         |> Enum.sum()

     

       119
       119
       +
       end)

     

       120
       120
       +
       |> Enum.sum()

     

       121
       121
       +
       |> dbg()

     

       122
       122
       +
       ```

     

       123
       123
       +
       

     

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

     

       125
       125
       +
       

     

       126
       126
       +
       ```

     

       127
       127
       +
       271384

     

       128
       128
       +
       ```

     

       129
       129
       +
       

     

       130
       130
       +
       <!-- livebook:{"offset":6563,"stamp":{"token":"XCP.ikIQAzWaCpMFzPgSppGb8erUqNQTiTQKVT4Z8-snaHPxRPHLJ4FSFvjZQhOg5ALkY4RVu78B3ZYCWSkqZ0vt8iql9ZvmaUtNNTG10v5VUIi3Jt0IgRmOCL0PL47Vn3f_gQ","version":2}} -->

+178

2023/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])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":{"assign_to":"puzzle_input","day":"16","session_secret":"ADVENT_OF_CODE_SESSION","year":"2023"},"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("2023", "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\\.................\\....\\...../........|........|....../.\\....-....-..................|../...|...\\./...........\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............./..../....-...|........../-.............\\......................................\\/........-..-....\n.................\\\\...............|\\\\...........\\.........../......-.......-............\\..............-..-..\\\n...|..../..|../..|........./.../.-..............................\\.........-........................|.\\....||..\n......................./..|....-..............................-........................././../................\n../.\\.............//.\\.|..................-.....\\...........|..././............/...................." <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       # puzzle_input =

     

       27
       27
       +
       ~S"""

     

       28
       28
       +
       .|...\....

     

       29
       29
       +
       |.-.\.....

     

       30
       30
       +
       .....|-...

     

       31
       31
       +
       ........|.

     

       32
       32
       +
       ..........

     

       33
       33
       +
       .........\

     

       34
       34
       +
       ..../.\\..

     

       35
       35
       +
       .-.-/..|..

     

       36
       36
       +
       .|....-|.\

     

       37
       37
       +
       ..//.|....

     

       38
       38
       +
       """

     

       39
       39
       +
       ```

     

       40
       40
       +
       

     

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

     

       42
       42
       +
       

     

       43
       43
       +
       ```

     

       44
       44
       +
       ".|...\\....\n|.-.\\.....\n.....|-...\n........|.\n..........\n.........\\\n..../.\\\\..\n.-.-/..|..\n.|....-|.\\\n..//.|....\n"

     

       45
       45
       +
       ```

     

       46
       46
       +
       

     

       47
       47
       +
       ```elixir

     

       48
       48
       +
       lines = String.split(puzzle_input, "\n", trim: true)

     

       49
       49
       +
       

     

       50
       50
       +
       map =

     

       51
       51
       +
         for {line, y} <- Enum.with_index(lines),

     

       52
       52
       +
             {char, x} <- line |> String.to_charlist() |> Enum.with_index(),

     

       53
       53
       +
             char not in ~c".",

     

       54
       54
       +
             into: %{},

     

       55
       55
       +
             do: {{y, x}, <<char>>}

     

       56
       56
       +
       

     

       57
       57
       +
       {height, width} = {byte_size(hd(lines)) - 1, length(lines) - 1}

     

       58
       58
       +
       ```

     

       59
       59
       +
       

     

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

     

       61
       61
       +
       

     

       62
       62
       +
       ```

     

       63
       63
       +
       {109, 109}

     

       64
       64
       +
       ```

     

       65
       65
       +
       

     

       66
       66
       +
       ```elixir

     

       67
       67
       +
       defmodule Day16 do

     

       68
       68
       +
         defguard in_map(yx, hw) when elem(yx, 0) in 0..elem(hw, 0) and elem(yx, 1) in 0..elem(hw, 1)

     

       69
       69
       +
       

     

       70
       70
       +
         def traverse(map, wh, start \\ {{0, 0}, :right}),

     

       71
       71
       +
           do: do_traverse(map, wh, start, _acc = MapSet.new(), _visited = MapSet.new())

     

       72
       72
       +
       

     

       73
       73
       +
         defp do_traverse(map, hw, {xy, dir} = pos, acc, visited) when in_map(xy, hw) do

     

       74
       74
       +
           if pos not in visited do

     

       75
       75
       +
             acc = MapSet.put(acc, xy)

     

       76
       76
       +
       

     

       77
       77
       +
             case Map.fetch(map, xy) do

     

       78
       78
       +
               :error ->

     

       79
       79
       +
                 do_traverse(map, hw, next(xy, dir), acc, visited)

     

       80
       80
       +
       

     

       81
       81
       +
               {:ok, "|"} when dir in ~w[up down]a ->

     

       82
       82
       +
                 do_traverse(map, hw, next(xy, dir), acc, visited)

     

       83
       83
       +
       

     

       84
       84
       +
               {:ok, "-"} when dir in ~w[left right]a ->

     

       85
       85
       +
                 do_traverse(map, hw, next(xy, dir), acc, visited)

     

       86
       86
       +
       

     

       87
       87
       +
               {:ok, mirror} when mirror in ~w[/ \\] ->

     

       88
       88
       +
                 next = mirror(mirror, dir)

     

       89
       89
       +
                 do_traverse(map, hw, next(xy, next), acc, MapSet.put(visited, pos))

     

       90
       90
       +
       

     

       91
       91
       +
               {:ok, "|"} when dir in ~w[left right]a ->

     

       92
       92
       +
                 # Add both sides to visited, as it will result in the same outcome

     

       93
       93
       +
                 visited =

     

       94
       94
       +
                   visited

     

       95
       95
       +
                   |> MapSet.put({xy, :left})

     

       96
       96
       +
                   |> MapSet.put({xy, :right})

     

       97
       97
       +
       

     

       98
       98
       +
                 {acc, visited} = do_traverse(map, hw, next(xy, :up), acc, visited)

     

       99
       99
       +
                 do_traverse(map, hw, next(xy, :down), acc, visited)

     

       100
       100
       +
       

     

       101
       101
       +
               {:ok, "-"} when dir in ~w[up down]a ->

     

       102
       102
       +
                 # Add both sides to visited, as it will result in the same outcome

     

       103
       103
       +
                 visited =

     

       104
       104
       +
                   visited

     

       105
       105
       +
                   |> MapSet.put({xy, :up})

     

       106
       106
       +
                   |> MapSet.put({xy, :down})

     

       107
       107
       +
       

     

       108
       108
       +
                 {acc, visited} = do_traverse(map, hw, next(xy, :left), acc, visited)

     

       109
       109
       +
                 do_traverse(map, hw, next(xy, :right), acc, visited)

     

       110
       110
       +
             end

     

       111
       111
       +
           else

     

       112
       112
       +
             {acc, visited}

     

       113
       113
       +
           end

     

       114
       114
       +
         end

     

       115
       115
       +
       

     

       116
       116
       +
         defp do_traverse(_, _wh, _pos, acc, visited) do

     

       117
       117
       +
           {acc, visited}

     

       118
       118
       +
         end

     

       119
       119
       +
       

     

       120
       120
       +
         defp mirror("/", :up), do: :right

     

       121
       121
       +
         defp mirror("/", :left), do: :down

     

       122
       122
       +
         defp mirror("/", :down), do: :left

     

       123
       123
       +
         defp mirror("/", :right), do: :up

     

       124
       124
       +
       

     

       125
       125
       +
         defp mirror("\\", :up), do: :left

     

       126
       126
       +
         defp mirror("\\", :left), do: :up

     

       127
       127
       +
         defp mirror("\\", :down), do: :right

     

       128
       128
       +
         defp mirror("\\", :right), do: :down

     

       129
       129
       +
       

     

       130
       130
       +
         defp next({y, x}, :up), do: {{y - 1, x}, :up}

     

       131
       131
       +
         defp next({y, x}, :left), do: {{y, x - 1}, :left}

     

       132
       132
       +
         defp next({y, x}, :down), do: {{y + 1, x}, :down}

     

       133
       133
       +
         defp next({y, x}, :right), do: {{y, x + 1}, :right}

     

       134
       134
       +
       end

     

       135
       135
       +
       ```

     

       136
       136
       +
       

     

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

     

       138
       138
       +
       

     

       139
       139
       +
       ```

     

       140
       140
       +
       {:module, Day16, <<70, 79, 82, 49, 0, 0, 28, ...>>, {:next, 2}}

     

       141
       141
       +
       ```

     

       142
       142
       +
       

     

       143
       143
       +
       ## Part 1

     

       144
       144
       +
       

     

       145
       145
       +
       ```elixir

     

       146
       146
       +
       {path, _} = Day16.traverse(map, {height, width})

     

       147
       147
       +
       

     

       148
       148
       +
       MapSet.size(path)

     

       149
       149
       +
       ```

     

       150
       150
       +
       

     

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

     

       152
       152
       +
       

     

       153
       153
       +
       ```

     

       154
       154
       +
       7242

     

       155
       155
       +
       ```

     

       156
       156
       +
       

     

       157
       157
       +
       ## Part 2

     

       158
       158
       +
       

     

       159
       159
       +
       ```elixir

     

       160
       160
       +
       start_points =

     

       161
       161
       +
         Enum.concat([

     

       162
       162
       +
           Enum.flat_map(0..height, &[{{&1, 0}, :right}, {{&1, width}, :left}]),

     

       163
       163
       +
           Enum.flat_map(0..width, &[{{0, &1}, :down}, {{height, &1}, :up}])

     

       164
       164
       +
         ])

     

       165
       165
       +
       

     

       166
       166
       +
       start_points

     

       167
       167
       +
       |> Task.async_stream(&Day16.traverse(map, {height, width}, &1))

     

       168
       168
       +
       |> Stream.map(fn {:ok, {path, _}} -> MapSet.size(path) end)

     

       169
       169
       +
       |> Enum.max()

     

       170
       170
       +
       ```

     

       171
       171
       +
       

     

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

     

       173
       173
       +
       

     

       174
       174
       +
       ```

     

       175
       175
       +
       7572

     

       176
       176
       +
       ```

     

       177
       177
       +
       

     

       178
       178
       +
       <!-- livebook:{"offset":8394,"stamp":{"token":"XCP.G2qkGI0iiEpXKpxgmF3X_dOzQWYnfJes3P9XQazzqVafzbVljgd42sRxbC_RC5Nc9-rrcx45UodmXf17HwB9X_4sZz6up_iLXNZDUxXQ0eGyvZkk_NcBMt5FRaALMHBiHw","version":2}} -->

+310

2023/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])

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":{"assign_to":"puzzle_input","day":"18","session_secret":"ADVENT_OF_CODE_SESSION","year":"2023"},"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("2023", "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
       +
        "L 5 (#0760b2)\nU 4 (#058b53)\nL 3 (#d05a12)\nD 4 (#058b51)\nL 6 (#12ee82)\nU 6 (#63c403)\nL 4 (#065a12)\nU 8 (#a44373)\nL 7 (#7581c2)\nU 7 (#334ec3)\nL 3 (#35e792)\nU 5 (#079963)\nL 3 (#1737b0)\nU 4 (#29a7a3)\nL 2 (#705a02)\nU 5 (#7151e3)\nL 4 (#705a00)\nU 4 (#43f5a3)\nL 5 (#1737b2)\nU 8 (#61a8c3)\nL 5 (#6005d2)\nD 3 (#20f4c1)\nL 3 (#4aa812)\nD 3 (#8163b1)\nL 4 (#80ac22)\nD 4 (#5e64c1)\nL 7 (#cb5430)\nD 5 (#7ac2d1)\nR 7 (#920132)\nD 6 (#a44371)\nL 6 (#944582)\nU 3 (#bc3423)\nL 5 (#71c1b2)\nU 4 (#88e6f3)\nL 4 (#0e35f2)\nU 5 (#11fa31)\nL 8 (#6ab312)\nU 5 (#5c3df1)\nR 8 (#40be22)\nU 3 (#5c3df3)\nR 9 (#42e412)\nU 6 (#11fa33)\nR 5 (#178f02)\nU 10 (#88e6f1)\nL 2 (#cff5f2)\nU 6 (#41fb73)\nL 5 (#247782)\nU 4 (#8d6d73)\nL 5 (#139492)\nU 8 (#6360d3)\nR 4 (#1688c2)\nU 2 (#28eb43)\nR 5 (#7d6230)\nU 6 (#769093)\nR 3 (#7d6232)\nU 5 (#487383)\nL 5 (#4fe4c2)\nU 4 (#784971)\nL 7 (#649a42)\nU 3 (#81c8d1)\nL 6 (#3e8422)\nU 5 (#2e26f3)\nL 5 (#880bd2)\nU 4 (#cbeb53)\nL 6 (#3c3a82)\nU 3 (#990203)\nL 8 (#18ce92)\nU 6 (#3bd723)\nL 10 (#8b17c2)\nU 5 (#931f03)\nR 7 (#56b4b2)\nU 3 (#1c3d03)\nR 2 (#693490)\nU 7 (#a5d813)\nL 4 (#693492)\nU 7 (#454523)\nR 8 (#749e20)\nU 3 (#b6ecd3)\nL 8 (#1e69b0)\nU 6 (#0cd813)\nR 4 (#a286d0)\nU 8 (#8249a3)\nR 6 (#c431e0)\nU 10 (#64b5d3)\nR 3 (#26fee0)\nU 7 (#3a6403)\nR 7 (#44c0a2)\nU 8 (#574291)\nR 2 (#9bf502)\nU 5 (#574293)\nR 5 (#0a7b22)\nU 8 (#12e553)\nR 2 (#67c0e0)\nU 3 (#ab6f63)\nR 7 (#922b60)\nD 6 (#680283)\nR 5 (#637c90)\nD 5 (#b10343)\nR 3 (#954ed0)\nD 8 (#254333)\nL 8 (#3f16a0)\nD 3 (#55f2c3)\nR 4 (#2465e0)\nD 9 (#6b7461)\nR 6 (#8b2b00)\nD 7 (#6b7463)\nR 5 (#7ae9f0)\nD 3 (#584e33)\nR 3 (#4fd2d2)\nD 4 (#30e451)\nR 3 (#682c22)\nD 3 (#30e453)\nR 4 (#727be2)\nD 8 (#85b173)\nL 4 (#3a8c50)\nD 3 (#004a23)\nR 2 (#6eef60)\nD 3 (#92b8d3)\nR 5 (#bdb140)\nU 8 (#8500b3)\nR 5 (#2e42f2)\nD 8 (#531953)\nR 3 (#9358a2)\nD 5 (#14d4b3)\nR 6 (#b19aa2)\nD 8 (#14d4b1)\nR 8 (#3e0d32)\nU 8 (#274023)\nR 3 (#b2d1a2)\nU 3 (#274021)\nR 8 (#206d02)\nU 6 (#2d02d3)\nR 4 (#0bd782)\nU 3 (#483403)\nR 9 (#7d6fc0)\nU 5 (#717513)\nR 9 (#5e63a0)\nU 6 (#614071)\nR 6 (#6df500)\nU 9 (#6f14e1)\nR 5 (#9229d0)\nU 5 (#6f14e3)\nL 5 (#0993b0)\nU 4 (#614073)\nL 3 (#aad3a0)\nU 7 (#2aed13)\nL 7 (#117f30)\nU 8 (#b185d3)\nL 3 (#a39640)\nU 10 (#a408b1)\nL 5 (#1e31b0)\nU 4 (#5af491)\nL 3 (#43ff50)\nU 4 (#125121)\nR 5 (#2321b0)\nU 4 (#4a6de1)\nR 6 (#80c430)\nU 5 (#4a6de3)\nL 5 (#8fe3b0)\nU 4 (#483d91)\nR 8 (#012050)\nU 3 (#3730e1)\nR 5 (#d36d12)\nU 8 (#7d5761)\nR 7 (#d36d10)\nU 7 (#21b1c1)\nR 9 (#8ea5e2)\nU 7 (#602a01)\nR 8 (#aae3f2)\nU 5 (#8d2981)\nR 5 (#263f72)\nU 5 (#2a3471)\nR 7 (#263f70)\nU 2 (#88ea21)\nR 3 (#3f5f62)\nU 6 (#5e1cc1)\nR 5 (#adffb0)\nU 6 (#104941)\nR 5 (#073230)\nU 4 (#25be03)\nL 9 (#1a2fd0)\nU 5 (#3d1233)\nR 9 (#879540)\nU 4 (#5c9671)\nL 2 (#6ad9e0)\nU 8 (#5c9673)\nL 7 (#3bb750)\nU 3 (#3d1231)\nR 11 (#080ca0)\nU 4 (#25be01)\nR 4 (#50a100)\nU 5 (#163541)\nL 5 (#27ff80)\nU 3 (#ab8481)\nR 4 (#549890)\nU 7 (#010511)\nL 4 (#749c72)\nU 4 (#46cfe1)\nL 5 (#a03822)\nD 5 (#594361)\nL 2 (#12a9f0)\nD 9 (#509f91)\nL 3 (#c051f0)\nU 3 (#509f93)\nL 7 (#41d8b0)\nD 3 (#80af51)\nL 3 (#549892)\nD 9 (#29c701)\nL 5 (#58fe00)\nD 5 (#4ef833)\nR 5 (#4ad860)\nD 7 (#aa4b13)\nL 7 (#6d6810)\nD 8 (#774e21)\nL 6 (#631140)\nU 8 (#4c9b31)\nL 4 (#4a8a50)\nD 3 (#61b9d1)\nL 6 (#665fd0)\nD 5 (#4edd51)\nR 6 (#46f5d0)\nD 3 (#109bd1)\nL 6 (#896f50)\nD 5 (#3ab8e1)\nL 3 (#6f6ce0)\nD 4 (#5acd11)\nL 5 (#1d15b2)\nU 4 (#032e23)\nL 10 (#8d6c92)\nU 3 (#032e21)\nR 10 (#4e59f2)\nU 5 (#70a541)\nL 5 (#1102a0)\nU 8 (#8b66f1)\nL 5 (#871710)\nU 10 (#be4e51)\nR 3 (#871712)\nU 11 (#1182c1)\nR 3 (#1102a2)\nD 9 (#493441)\nR 8 (#7a6b80)\nD 4 (#c3daa1)\nR 3 (#8a38d0)\nU 3 (#07ac71)\nR 4 (#131b90)\nU 5 (#34c6e1)\nR 4 (#914cf2)\nU 5 (#0e9af1)\nR 3 (#6c62d2)\nU 3 (#3af801)\nL 6 (#0018c0)\nU 7 (#2b7361)\nL 4 (#55fb20)\nU 5 (#8a33c1)\nR 4 (#a79be0)\nU 4 (#59acf1)\nR 7 (#bb8240)\nD 5 (#77ca71)\nR 7 (#894bd0)\nU 5 (#a12ff1)\nR 3 (#437630)\nD 4 (#1dbba1)\nR 10 (#4c87b0)\nU 6 (#9ea131)\nR 2 (#4c87b2)\nU 4 (#19f7e1)\nL 11 (#85c770)\nU 4 (#220631)\nL 9 (#224540)\nU 5 (#d4ac83)\nL 4 (#421610)\nU 3 (#23ae63)\nL 9 (#8259c0)\nD 4 (#1b4b51)\nR 6 (#b84e80)\nD 11 (#9b8e41)\nL 6 (#29c310)\nD 4 (#9cba93)\nL 6 (#2e33e0)\nU 10 (#1d8b03)\nL 5 (#2578e2)\nU 7 (#0c7911)\nL 2 (#6112e2)\nU 2 (#0c7913)\nL 7 (#621cb2)\nD 8 (#4164f3)\nL 4 (#080dd2)\nU 11 (#574773)\nR 7 (#6ab252)\nU 3 (#4224b3)\nR 3 (#898930)\nU 2 (#c8" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       # puzzle_input =

     

       27
       27
       +
       """

     

       28
       28
       +
       R 6 (#70c710)

     

       29
       29
       +
       D 5 (#0dc571)

     

       30
       30
       +
       L 2 (#5713f0)

     

       31
       31
       +
       D 2 (#d2c081)

     

       32
       32
       +
       R 2 (#59c680)

     

       33
       33
       +
       D 2 (#411b91)

     

       34
       34
       +
       L 5 (#8ceee2)

     

       35
       35
       +
       U 2 (#caa173)

     

       36
       36
       +
       L 1 (#1b58a2)

     

       37
       37
       +
       U 2 (#caa171)

     

       38
       38
       +
       R 2 (#7807d2)

     

       39
       39
       +
       U 3 (#a77fa3)

     

       40
       40
       +
       L 2 (#015232)

     

       41
       41
       +
       U 2 (#7a21e3)

     

       42
       42
       +
       """

     

       43
       43
       +
       ```

     

       44
       44
       +
       

     

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

     

       46
       46
       +
       

     

       47
       47
       +
       ```

     

       48
       48
       +
       "R 6 (#70c710)\nD 5 (#0dc571)\nL 2 (#5713f0)\nD 2 (#d2c081)\nR 2 (#59c680)\nD 2 (#411b91)\nL 5 (#8ceee2)\nU 2 (#caa173)\nL 1 (#1b58a2)\nU 2 (#caa171)\nR 2 (#7807d2)\nU 3 (#a77fa3)\nL 2 (#015232)\nU 2 (#7a21e3)\n"

     

       49
       49
       +
       ```

     

       50
       50
       +
       

     

       51
       51
       +
       ```elixir

     

       52
       52
       +
       commands =

     

       53
       53
       +
         puzzle_input

     

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

     

       55
       55
       +
         |> Enum.map(fn <<dir>> <> " " <> rest ->

     

       56
       56
       +
           {len, " (#" <> <<hex::binary-6>> <> ")"} = Integer.parse(rest)

     

       57
       57
       +
           {dir, len, hex}

     

       58
       58
       +
         end)

     

       59
       59
       +
       ```

     

       60
       60
       +
       

     

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

     

       62
       62
       +
       

     

       63
       63
       +
       ```

     

       64
       64
       +
       [

     

       65
       65
       +
         {76, 5, "0760b2"},

     

       66
       66
       +
         {85, 4, "058b53"},

     

       67
       67
       +
         {76, 3, "d05a12"},

     

       68
       68
       +
         {68, 4, "058b51"},

     

       69
       69
       +
         {76, 6, "12ee82"},

     

       70
       70
       +
         {85, 6, "63c403"},

     

       71
       71
       +
         {76, 4, "065a12"},

     

       72
       72
       +
         {85, 8, "a44373"},

     

       73
       73
       +
         {76, 7, "7581c2"},

     

       74
       74
       +
         {85, 7, "334ec3"},

     

       75
       75
       +
         {76, 3, "35e792"},

     

       76
       76
       +
         {85, 5, "079963"},

     

       77
       77
       +
         {76, 3, "1737b0"},

     

       78
       78
       +
         {85, 4, "29a7a3"},

     

       79
       79
       +
         {76, 2, "705a02"},

     

       80
       80
       +
         {85, 5, "7151e3"},

     

       81
       81
       +
         {76, 4, "705a00"},

     

       82
       82
       +
         {85, 4, "43f5a3"},

     

       83
       83
       +
         {76, 5, "1737b2"},

     

       84
       84
       +
         {85, 8, "61a8c3"},

     

       85
       85
       +
         {76, 5, "6005d2"},

     

       86
       86
       +
         {68, 3, "20f4c1"},

     

       87
       87
       +
         {76, 3, "4aa812"},

     

       88
       88
       +
         {68, 3, "8163b1"},

     

       89
       89
       +
         {76, 4, "80ac22"},

     

       90
       90
       +
         {68, 4, "5e64c1"},

     

       91
       91
       +
         {76, 7, "cb5430"},

     

       92
       92
       +
         {68, 5, "7ac2d1"},

     

       93
       93
       +
         {82, 7, "920132"},

     

       94
       94
       +
         {68, 6, "a44371"},

     

       95
       95
       +
         {76, 6, "944582"},

     

       96
       96
       +
         {85, 3, "bc3423"},

     

       97
       97
       +
         {76, 5, "71c1b2"},

     

       98
       98
       +
         {85, 4, "88e6f3"},

     

       99
       99
       +
         {76, 4, "0e35f2"},

     

       100
       100
       +
         {85, 5, "11fa31"},

     

       101
       101
       +
         {76, 8, "6ab312"},

     

       102
       102
       +
         {85, 5, "5c3df1"},

     

       103
       103
       +
         {82, 8, "40be22"},

     

       104
       104
       +
         {85, 3, "5c3df3"},

     

       105
       105
       +
         {82, 9, "42e412"},

     

       106
       106
       +
         {85, 6, "11fa33"},

     

       107
       107
       +
         {82, 5, "178f02"},

     

       108
       108
       +
         {85, 10, "88e6f1"},

     

       109
       109
       +
         {76, 2, "cff5f2"},

     

       110
       110
       +
         {85, 6, "41fb73"},

     

       111
       111
       +
         {76, 5, "247782"},

     

       112
       112
       +
         {85, 4, ...},

     

       113
       113
       +
         {76, ...},

     

       114
       114
       +
         {...},

     

       115
       115
       +
         ...

     

       116
       116
       +
       ]

     

       117
       117
       +
       ```

     

       118
       118
       +
       

     

       119
       119
       +
       ## Part 1

     

       120
       120
       +
       

     

       121
       121
       +
       ```elixir

     

       122
       122
       +
       dirs = %{

     

       123
       123
       +
         ?U => {0, -1},

     

       124
       124
       +
         ?D => {0, 1},

     

       125
       125
       +
         ?L => {-1, 0},

     

       126
       126
       +
         ?R => {1, 0}

     

       127
       127
       +
       }

     

       128
       128
       +
       

     

       129
       129
       +
       {points, {_, circ}} =

     

       130
       130
       +
         Enum.map_reduce(commands, {{0, 0}, 0}, fn

     

       131
       131
       +
           {dir, d, _}, {{x, y}, l} ->

     

       132
       132
       +
             {dx, dy} = dirs[dir]

     

       133
       133
       +
             {{x, y}, {{x + dx * d, y + dy * d}, l + d}}

     

       134
       134
       +
         end)

     

       135
       135
       +
       ```

     

       136
       136
       +
       

     

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

     

       138
       138
       +
       

     

       139
       139
       +
       ```

     

       140
       140
       +
       {[

     

       141
       141
       +
          {0, 0},

     

       142
       142
       +
          {-5, 0},

     

       143
       143
       +
          {-5, -4},

     

       144
       144
       +
          {-8, -4},

     

       145
       145
       +
          {-8, 0},

     

       146
       146
       +
          {-14, 0},

     

       147
       147
       +
          {-14, -6},

     

       148
       148
       +
          {-18, -6},

     

       149
       149
       +
          {-18, -14},

     

       150
       150
       +
          {-25, -14},

     

       151
       151
       +
          {-25, -21},

     

       152
       152
       +
          {-28, -21},

     

       153
       153
       +
          {-28, -26},

     

       154
       154
       +
          {-31, -26},

     

       155
       155
       +
          {-31, -30},

     

       156
       156
       +
          {-33, -30},

     

       157
       157
       +
          {-33, -35},

     

       158
       158
       +
          {-37, -35},

     

       159
       159
       +
          {-37, -39},

     

       160
       160
       +
          {-42, -39},

     

       161
       161
       +
          {-42, -47},

     

       162
       162
       +
          {-47, -47},

     

       163
       163
       +
          {-47, -44},

     

       164
       164
       +
          {-50, -44},

     

       165
       165
       +
          {-50, -41},

     

       166
       166
       +
          {-54, -41},

     

       167
       167
       +
          {-54, -37},

     

       168
       168
       +
          {-61, -37},

     

       169
       169
       +
          {-61, -32},

     

       170
       170
       +
          {-54, -32},

     

       171
       171
       +
          {-54, -26},

     

       172
       172
       +
          {-60, -26},

     

       173
       173
       +
          {-60, -29},

     

       174
       174
       +
          {-65, -29},

     

       175
       175
       +
          {-65, -33},

     

       176
       176
       +
          {-69, -33},

     

       177
       177
       +
          {-69, -38},

     

       178
       178
       +
          {-77, -38},

     

       179
       179
       +
          {-77, -43},

     

       180
       180
       +
          {-69, -43},

     

       181
       181
       +
          {-69, -46},

     

       182
       182
       +
          {-60, -46},

     

       183
       183
       +
          {-60, -52},

     

       184
       184
       +
          {-55, -52},

     

       185
       185
       +
          {-55, -62},

     

       186
       186
       +
          {-57, -62},

     

       187
       187
       +
          {-57, -68},

     

       188
       188
       +
          {-62, ...},

     

       189
       189
       +
          {...},

     

       190
       190
       +
          ...

     

       191
       191
       +
        ], {{0, 0}, 3518}}

     

       192
       192
       +
       ```

     

       193
       193
       +
       

     

       194
       194
       +
       ```elixir

     

       195
       195
       +
       area =

     

       196
       196
       +
         points

     

       197
       197
       +
         |> Enum.chunk_every(2, 1, [{0, 0}])

     

       198
       198
       +
         |> Enum.map(fn [{x1, y1}, {x2, y2}] ->

     

       199
       199
       +
           x1 * y2 - x2 * y1

     

       200
       200
       +
         end)

     

       201
       201
       +
         |> Enum.sum()

     

       202
       202
       +
         |> abs()

     

       203
       203
       +
         |> div(2)

     

       204
       204
       +
       

     

       205
       205
       +
       area + div(circ, 2) + 1

     

       206
       206
       +
       ```

     

       207
       207
       +
       

     

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

     

       209
       209
       +
       

     

       210
       210
       +
       ```

     

       211
       211
       +
       49897

     

       212
       212
       +
       ```

     

       213
       213
       +
       

     

       214
       214
       +
       ## Part 2

     

       215
       215
       +
       

     

       216
       216
       +
       ```elixir

     

       217
       217
       +
       dirs = %{

     

       218
       218
       +
         ?3 => {0, -1},

     

       219
       219
       +
         ?1 => {0, 1},

     

       220
       220
       +
         ?2 => {-1, 0},

     

       221
       221
       +
         ?0 => {1, 0}

     

       222
       222
       +
       }

     

       223
       223
       +
       

     

       224
       224
       +
       {points, {_, circ}} =

     

       225
       225
       +
         Enum.map_reduce(commands, {{0, 0}, 0}, fn

     

       226
       226
       +
           {_, _, <<d::binary-5, dir>>}, {{x, y}, l} ->

     

       227
       227
       +
             {dx, dy} = dirs[dir]

     

       228
       228
       +
             d = String.to_integer(d, 16)

     

       229
       229
       +
             {{x, y}, {{x + dx * d, y + dy * d}, l + d}}

     

       230
       230
       +
         end)

     

       231
       231
       +
       ```

     

       232
       232
       +
       

     

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

     

       234
       234
       +
       

     

       235
       235
       +
       ```

     

       236
       236
       +
       {[

     

       237
       237
       +
          {0, 0},

     

       238
       238
       +
          {-30219, 0},

     

       239
       239
       +
          {-30219, -22709},

     

       240
       240
       +
          {-883628, -22709},

     

       241
       241
       +
          {-883628, 0},

     

       242
       242
       +
          {-961172, 0},

     

       243
       243
       +
          {-961172, -408640},

     

       244
       244
       +
          {-987189, -408640},

     

       245
       245
       +
          {-987189, -1081463},

     

       246
       246
       +
          {-1468497, -1081463},

     

       247
       247
       +
          {-1468497, -1291619},

     

       248
       248
       +
          {-1689290, -1291619},

     

       249
       249
       +
          {-1689290, -1322745},

     

       250
       250
       +
          {-1594191, -1322745},

     

       251
       251
       +
          {-1594191, -1493363},

     

       252
       252
       +
          {-2054383, -1493363},

     

       253
       253
       +
          {-2054383, -1957521},

     

       254
       254
       +
          {-1594191, -1957521},

     

       255
       255
       +
          {-1594191, -2235883},

     

       256
       256
       +
          {-1689290, -2235883},

     

       257
       257
       +
          {-1689290, -2635895},

     

       258
       258
       +
          {-2082599, -2635895},

     

       259
       259
       +
          {-2082599, -2500907},

     

       260
       260
       +
          {-2388392, -2500907},

     

       261
       261
       +
          {-2388392, -1970928},

     

       262
       262
       +
          {-2915434, -1970928},

     

       263
       263
       +
          {-2915434, -1584292},

     

       264
       264
       +
          {-2082599, -1584292},

     

       265
       265
       +
          {-2082599, -1081463},

     

       266
       266
       +
          {-2680634, -1081463},

     

       267
       267
       +
          {-2680634, -408640},

     

       268
       268
       +
          {-3287954, -408640},

     

       269
       269
       +
          {-3287954, -1179522},

     

       270
       270
       +
          {-3753901, -1179522},

     

       271
       271
       +
          {-3753901, -1740273},

     

       272
       272
       +
          {-3812108, -1740273},

     

       273
       273
       +
          {-3812108, -1666638},

     

       274
       274
       +
          {-4249149, -1666638},

     

       275
       275
       +
          {-4249149, -1288815},

     

       276
       276
       +
          {-4514335, -1288815},

     

       277
       277
       +
          {-4514335, -1666638},

     

       278
       278
       +
          {-4788320, -1666638},

     

       279
       279
       +
          {-4788320, -1740273},

     

       280
       280
       +
          {-4884816, -1740273},

     

       281
       281
       +
          {-4884816, -1179522},

     

       282
       282
       +
          {-5736623, -1179522},

     

       283
       283
       +
          {-5736623, -1449785},

     

       284
       284
       +
          {-5885991, ...},

     

       285
       285
       +
          {...},

     

       286
       286
       +
          ...

     

       287
       287
       +
        ], {{0, 0}, 237488828}}

     

       288
       288
       +
       ```

     

       289
       289
       +
       

     

       290
       290
       +
       ```elixir

     

       291
       291
       +
       area =

     

       292
       292
       +
         points

     

       293
       293
       +
         |> Enum.chunk_every(2, 1, [{0, 0}])

     

       294
       294
       +
         |> Enum.map(fn [{x1, y1}, {x2, y2}] ->

     

       295
       295
       +
           x1 * y2 - x2 * y1

     

       296
       296
       +
         end)

     

       297
       297
       +
         |> Enum.sum()

     

       298
       298
       +
         |> abs()

     

       299
       299
       +
         |> div(2)

     

       300
       300
       +
       

     

       301
       301
       +
       area + div(circ, 2) + 1

     

       302
       302
       +
       ```

     

       303
       303
       +
       

     

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

     

       305
       305
       +
       

     

       306
       306
       +
       ```

     

       307
       307
       +
       194033958221830

     

       308
       308
       +
       ```

     

       309
       309
       +
       

     

       310
       310
       +
       <!-- livebook:{"offset":9828,"stamp":{"token":"XCP.PxtVRuGOoJbRBg9li_V5edaJPAIM1giG8b7fnblLM45DtgF15Jzd6NlUMPxbzksg6acUzlzFjYTBEN2LSqNSG1-GyFTIi-SNpma9KQLCo3vK0DZWQEcIQo44tSdMuxRx5A","version":2}} -->

+167

2023/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":{"assign_to":"puzzle_input","day":"19","session_secret":"ADVENT_OF_CODE_SESSION","year":"2023"},"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("2023", "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
       +
        "xn{x>3251:R,x>2998:R,kxq}\nfzx{a<1013:A,a>1206:A,s<3847:A,R}\nxjm{a<406:R,A}\nmzl{m<755:R,a>679:R,A}\nfnv{x>2143:sxm,m<2895:A,gh}\nhx{x<2183:A,s>3619:A,A}\nkvr{s>3669:A,a>584:R,m>2806:R,R}\nngd{s<3561:R,a<2595:R,a>3464:kch,hx}\nqvh{s<1945:R,fng}\nsr{s<3808:A,R}\nrbs{m>562:A,a<333:A,A}\npsg{a>561:shp,s>2745:vk,jtr}\ndl{s<2761:hvq,fbg}\nzfh{m<2326:szm,m<2485:A,R}\npt{a<2937:R,s<3935:A,x>3021:R,A}\nrk{x<476:ljz,a<1937:jvg,R}\nps{m<3555:R,s>3909:zrm,R}\nrv{s>795:R,s>480:A,R}\nlnh{a>2617:gz,fm}\nsqb{x>3735:gfv,a<1477:msq,zv}\nmd{x<1096:A,x<1619:A,s<217:R,R}\nztr{x>767:R,R}\nsq{m>1364:A,s>244:A,a<3577:A,R}\nrpc{m<420:A,R}\nhs{x<554:R,R}\nvdl{s<3309:A,a>1384:R,R}\njl{x<1879:mt,A}\nzbc{m>1502:dl,rf}\nljr{a<3187:R,A}\nbvv{x>2910:bpz,s>3676:qzt,x>2015:R,A}\nzfd{m<3356:vgj,a>3007:zzt,gfm}\nzq{a>2708:A,R}\nfh{a>2705:R,jqg}\nmhv{m<813:R,R}\nkq{a>2126:R,A}\nvk{x>2866:A,jxl}\npbs{a<3509:R,sq}\npkx{x>2891:A,A}\ndv{x>326:A,R}\nlgv{m<3070:fh,s<1467:mgh,a<2929:pj,nft}\nhhb{m>3097:qmt,a>2942:bfr,dkx}\npxc{x<3132:R,m<1265:R,R}\ncd{m>3540:A,R}\ncq{s>211:A,s<106:A,A}\nvqv{a>1867:R,x>3706:A,R}\nnb{x>2068:fk,x>1696:svc,R}\nth{x<3593:R,s<2701:cf,vjk}\nsfs{m<252:gfq,a<618:R,m<353:hkq,cvz}\nfzz{a>637:jvq,x<1757:A,x<2008:gxn,nr}\ncxd{x<1726:A,x>1873:A,a>2383:A,R}\ngtz{m>3441:R,A}\nnh{s>2751:A,s<2708:R,s>2735:A,R}\nlq{a>1765:R,R}\nrzv{a<1448:cjn,gg}\ncf{s<2626:R,x<3812:R,A}\nmbf{a>2789:A,a>2651:R,m<1004:R,A}\ncb{m<1452:R,m<3092:R,s<3880:A,R}\npd{x>2406:A,a<2484:R,m>3832:R,A}\nqzt{x>2426:A,a<2554:R,A}\nvf{a>1506:mgn,m<2895:cj,a>506:ps,dtx}\ndzz{m>3559:A,R}\nmr{s<2133:A,s<2292:R,a<2700:A,A}\nrn{s>901:A,m>3204:bb,spv}\ntnf{x>2142:A,x>1748:R,s>3539:A,R}\ncs{s<2710:A,a<3268:R,R}\nqc{x>1358:ftl,a>2473:kk,x>799:xsf,xht}\nqdm{s>341:A,A}\nglr{x<686:dfr,x>1172:vl,R}\ncn{m<3652:cxd,A}\ncm{m<151:R,s>3876:R,s<3842:A,A}\ngfm{x>1439:cn,m<3716:tks,m<3855:jn,jcr}\nbf{m<963:A,A}\nvlh{m<3510:A,x>2910:R,A}\nlpv{s<3981:A,a<1739:R,A}\nvjd{m>3232:A,m>3185:A,R}\ncbx{m>1016:A,R}\nxnc{a>3100:A,R}\nqkg{a>1138:R,x>1239:A,m<725:A,R}\nstl{m>947:bm,s<3931:A,s<3956:A,pkx}\nrf{s>2880:kcz,x>644:xk,zh}\nxpd{x>3710:A,s<3512:R,R}\ndt{x<3732:R,a<2881:A,a<3307:R,A}\njqg{s<1267:A,x>2703:R,R}\nstr{x<2942:vzf,x<3428:gl,a<2665:sqb,vt}\nnl{m>3788:A,s>1087:A,s>683:R,A}\nfc{s<3884:R,x>2689:R,R}\ngxt{m>426:ll,m>178:R,x<1350:tmf,st}\nzvg{a>3345:R,A}\nrkr{a>1171:R,A}\nvjv{s>2771:tv,dtz}\nfvp{a<1356:sfs,s>928:ss,rsf}\nnbf{s<611:R,a<1809:R,A}\njn{a>2068:A,nl}\nfzm{a>2076:bpk,x>876:kdd,m<400:jf,tsv}\nqvv{a<773:A,m>764:A,A}\nhhq{x<921:pks,x>988:cl,qr}\nin{s<2529:ntc,xz}\ndh{s<3515:R,R}\ndc{s>2919:A,R}\nmgh{m<3466:rv,a<2753:R,R}\nnm{m<3214:A,m<3302:qlm,x>3194:A,A}\nspq{m>3854:zvg,x>1467:tfn,s>1060:A,R}\nxh{s>2565:A,s>2547:mm,m>597:xkx,qq}\ncv{s>2058:R,A}\nlfp{m<3165:gdt,xnf}\njv{x>403:R,A}\nbqh{m>2771:A,A}\npb{a<1100:A,A}\njcr{s<1408:A,m>3905:cng,x>1043:A,hns}\nccd{s>790:R,kd}\ndtx{s<3858:sr,x>3627:R,R}\njfn{m<1123:A,s>3574:R,m>1296:R,A}\nrrc{x>2142:R,x>1904:R,R}\njdp{x<3059:R,a>2402:R,A}\npks{s>1682:zpz,R}\nppj{x>304:R,a>1076:A,s<2714:A,R}\njf{x>487:ptd,zvr}\nll{m<826:R,a<714:R,m>1017:A,A}\nlvd{m<1464:R,a<2106:tr,a<2987:fzc,js}\nkk{a>3251:mbb,pp}\nsg{m>2670:R,A}\nssj{m<515:R,x>660:R,A}\nzxr{a<1482:tlg,x>1965:gsl,x>841:zfd,qdl}\nqvl{m<3128:A,m<3608:A,a>1356:A,R}\nbdc{s>3857:R,R}\nvxf{s>3540:xtp,bvr}\nzfk{m>2828:R,R}\nrr{a<901:A,qvl}\nvgj{x>1312:bpj,x>1146:lkq,x>1035:sz,rgc}\nkb{m>2576:lsc,A}\nthg{a>248:hm,s<3241:R,R}\ndj{s<3857:A,R}\nzc{s<1965:ht,x>1083:fzz,s>2211:dmb,gd}\ncng{s<2122:A,m<3953:R,m<3974:A,R}\npg{s>878:R,R}\ngp{a>1793:R,x<2223:R,s>3362:R,A}\nkxq{x<2775:R,x>2923:A,A}\nhsg{s<3226:A,s<3330:A,R}\nqlj{a<1311:mv,A}\npr{x>494:mxk,a<2936:kmm,bht}\ngpv{x<1269:R,x>1381:R,m>2765:R,R}\nvt{m<2555:qst,xtv}\nhfl{x<2629:A,a>3143:A,m<290:R,A}\nzb{s<1697:A,A}\nxrq{s<2864:A,a>2201:A,a>1934:R,A}\nfm{m>3529:A,R}\nxb{s<2818:A,a<3522:A,m>2849:A,dlx}\nbx{a>2926:R,a<2074:R,A}\nqmt{s>2887:ls,x>2904:th,dzz}\nvp{x>2532:A,a>2417:R,R}\nmxk{x<1016:ztr,a<2922:tf,nt}\nvg{a>707:fbh,ndl}\nmf{a<2235:A,a>3265:fc,vm}\nghh{m<945:A,x<2100:R,R}\nmt{x>1602:R,a<2587:A,A}\ndlz{s<2689:A,s<2755:rxh,x>3417:nhr,fv}\nmbb{s>1105:zb,s>554:pg,a<3688:pbs,bn}\nkch{m>2412:R,R}\nrc{a<1071:A,m>1532:A,R}\nhvq{s<2609:zs,A}\ntfn{x>1675:R,R}\nshp{a>885:R,A}\njtr{s>2671:jft,R}\nkdd{a>1297:jzz,x>1193:gxt,fph}\nq" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       defmodule Day19 do

     

       27
       27
       +
         def always, do: fn _ -> true end

     

       28
       28
       +
       

     

       29
       29
       +
         def match(<<field::binary-1, cmp>> <> value) do

     

       30
       30
       +
           value = String.to_integer(value)

     

       31
       31
       +
       

     

       32
       32
       +
           case cmp do

     

       33
       33
       +
             ?> -> fn map -> map[field] > value end

     

       34
       34
       +
             ?< -> fn map -> map[field] < value end

     

       35
       35
       +
           end

     

       36
       36
       +
         end

     

       37
       37
       +
       

     

       38
       38
       +
         def walk("A", value, _), do: value |> Map.values() |> Enum.sum()

     

       39
       39
       +
         def walk("R", _, _), do: 0

     

       40
       40
       +
       

     

       41
       41
       +
         def walk(curr, value, ruleset) do

     

       42
       42
       +
           rules = ruleset[curr]

     

       43
       43
       +
       

     

       44
       44
       +
           Enum.find_value(rules, fn {f, next} ->

     

       45
       45
       +
             if f.(value), do: next

     

       46
       46
       +
           end)

     

       47
       47
       +
           |> walk(value, ruleset)

     

       48
       48
       +
         end

     

       49
       49
       +
       end

     

       50
       50
       +
       ```

     

       51
       51
       +
       

     

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

     

       53
       53
       +
       

     

       54
       54
       +
       ```

     

       55
       55
       +
       {:module, Day19, <<70, 79, 82, 49, 0, 0, 13, ...>>, {:walk, 3}}

     

       56
       56
       +
       ```

     

       57
       57
       +
       

     

       58
       58
       +
       ```elixir

     

       59
       59
       +
       [rules, inputs] = String.split(puzzle_input, "\n\n")

     

       60
       60
       +
       

     

       61
       61
       +
       ruleset =

     

       62
       62
       +
         rules

     

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

     

       64
       64
       +
         |> Map.new(fn line ->

     

       65
       65
       +
           [name, rest] = String.split(line, "{")

     

       66
       66
       +
       

     

       67
       67
       +
           rules =

     

       68
       68
       +
             rest

     

       69
       69
       +
             |> String.trim_trailing("}")

     

       70
       70
       +
             |> String.split(",")

     

       71
       71
       +
             |> Enum.map(fn rule ->

     

       72
       72
       +
               case String.split(rule, ":") do

     

       73
       73
       +
                 [next] -> {Day19.always(), next}

     

       74
       74
       +
                 [rule, next] -> {Day19.match(rule), next}

     

       75
       75
       +
               end

     

       76
       76
       +
             end)

     

       77
       77
       +
       

     

       78
       78
       +
           {name, rules}

     

       79
       79
       +
         end)

     

       80
       80
       +
       

     

       81
       81
       +
       inputs =

     

       82
       82
       +
         inputs

     

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

     

       84
       84
       +
         |> Enum.map(fn "{" <> data ->

     

       85
       85
       +
           data = String.trim_trailing(data, "}")

     

       86
       86
       +
       

     

       87
       87
       +
           data

     

       88
       88
       +
           |> String.split(",")

     

       89
       89
       +
           |> Map.new(fn <<field::binary-1>> <> "=" <> value ->

     

       90
       90
       +
             {field, String.to_integer(value)}

     

       91
       91
       +
           end)

     

       92
       92
       +
         end)

     

       93
       93
       +
       ```

     

       94
       94
       +
       

     

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

     

       96
       96
       +
       

     

       97
       97
       +
       ```

     

       98
       98
       +
       [

     

       99
       99
       +
         %{"a" => 2402, "m" => 2238, "s" => 929, "x" => 1},

     

       100
       100
       +
         %{"a" => 205, "m" => 654, "s" => 508, "x" => 1167},

     

       101
       101
       +
         %{"a" => 35, "m" => 2051, "s" => 1791, "x" => 1057},

     

       102
       102
       +
         %{"a" => 2726, "m" => 502, "s" => 178, "x" => 633},

     

       103
       103
       +
         %{"a" => 845, "m" => 2315, "s" => 2005, "x" => 3343},

     

       104
       104
       +
         %{"a" => 111, "m" => 2081, "s" => 499, "x" => 987},

     

       105
       105
       +
         %{"a" => 799, "m" => 1999, "s" => 1982, "x" => 464},

     

       106
       106
       +
         %{"a" => 518, "m" => 3195, "s" => 1247, "x" => 801},

     

       107
       107
       +
         %{"a" => 285, "m" => 2075, "s" => 1, "x" => 1506},

     

       108
       108
       +
         %{"a" => 384, "m" => 1366, "s" => 697, "x" => 1075},

     

       109
       109
       +
         %{"a" => 371, "m" => 1008, "s" => 1901, "x" => 33},

     

       110
       110
       +
         %{"a" => 115, "m" => 43, "s" => 14, "x" => 426},

     

       111
       111
       +
         %{"a" => 979, "m" => 2121, "s" => 2493, "x" => 595},

     

       112
       112
       +
         %{"a" => 3003, "m" => 3576, "s" => 3096, "x" => 557},

     

       113
       113
       +
         %{"a" => 921, "m" => 1269, "s" => 1983, "x" => 837},

     

       114
       114
       +
         %{"a" => 3300, "m" => 230, "s" => 909, "x" => 1367},

     

       115
       115
       +
         %{"a" => 130, "m" => 1878, "s" => 508, "x" => 1713},

     

       116
       116
       +
         %{"a" => 675, "m" => 1098, "s" => 886, "x" => 531},

     

       117
       117
       +
         %{"a" => 2121, "m" => 2018, "s" => 1761, "x" => 508},

     

       118
       118
       +
         %{"a" => 19, "m" => 399, "s" => 226, "x" => 1579},

     

       119
       119
       +
         %{"a" => 243, "m" => 35, "s" => 1169, "x" => 163},

     

       120
       120
       +
         %{"a" => 309, "m" => 221, "s" => 1305, "x" => 913},

     

       121
       121
       +
         %{"a" => 1685, "m" => 164, "s" => 239, "x" => 1780},

     

       122
       122
       +
         %{"a" => 2727, "m" => 208, "s" => 132, "x" => 86},

     

       123
       123
       +
         %{"a" => 2300, "m" => 2703, "s" => 386, "x" => 842},

     

       124
       124
       +
         %{"a" => 57, "m" => 454, "s" => 2120, "x" => 556},

     

       125
       125
       +
         %{"a" => 875, "m" => 1273, "s" => 1067, "x" => 1711},

     

       126
       126
       +
         %{"a" => 434, "m" => 939, "s" => 3341, "x" => 862},

     

       127
       127
       +
         %{"a" => 1666, "m" => 417, "s" => 203, "x" => 842},

     

       128
       128
       +
         %{"a" => 213, "m" => 1955, "s" => 2849, "x" => 93},

     

       129
       129
       +
         %{"a" => 62, "m" => 103, "s" => 104, "x" => 636},

     

       130
       130
       +
         %{"a" => 1917, "m" => 2014, "s" => 3128, "x" => 3715},

     

       131
       131
       +
         %{"a" => 225, "m" => 477, "s" => 579, "x" => 225},

     

       132
       132
       +
         %{"a" => 1176, "m" => 2243, "s" => 420, "x" => 556},

     

       133
       133
       +
         %{"a" => 62, "m" => 1556, "s" => 275, "x" => 10},

     

       134
       134
       +
         %{"a" => 368, "m" => 2498, "s" => 305, "x" => 1649},

     

       135
       135
       +
         %{"a" => 1488, "m" => 1148, "s" => 2419, "x" => 437},

     

       136
       136
       +
         %{"a" => 2488, "m" => 540, "s" => 174, "x" => 2918},

     

       137
       137
       +
         %{"a" => 1089, "m" => 3207, "s" => 2740, "x" => 3431},

     

       138
       138
       +
         %{"a" => 441, "m" => 560, "s" => 439, "x" => 661},

     

       139
       139
       +
         %{"a" => 310, "m" => 59, "s" => 109, "x" => 292},

     

       140
       140
       +
         %{"a" => 691, "m" => 452, "s" => 2012, "x" => 497},

     

       141
       141
       +
         %{"a" => 1182, "m" => 1424, "s" => 1228, "x" => 227},

     

       142
       142
       +
         %{"a" => 159, "m" => 418, "s" => 64, "x" => 225},

     

       143
       143
       +
         %{"a" => 38, "m" => 216, "s" => 1582, "x" => 1490},

     

       144
       144
       +
         %{"a" => 840, "m" => 2919, "s" => 973, "x" => 483},

     

       145
       145
       +
         %{"a" => 183, "m" => 1362, "s" => 589, ...},

     

       146
       146
       +
         %{"a" => 2028, "m" => 455, ...},

     

       147
       147
       +
         %{"a" => 2024, ...},

     

       148
       148
       +
         %{...},

     

       149
       149
       +
         ...

     

       150
       150
       +
       ]

     

       151
       151
       +
       ```

     

       152
       152
       +
       

     

       153
       153
       +
       ## Part 1

     

       154
       154
       +
       

     

       155
       155
       +
       ```elixir

     

       156
       156
       +
       inputs

     

       157
       157
       +
       |> Enum.map(&Day19.walk("in", &1, ruleset))

     

       158
       158
       +
       |> Enum.sum()

     

       159
       159
       +
       ```

     

       160
       160
       +
       

     

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

     

       162
       162
       +
       

     

       163
       163
       +
       ```

     

       164
       164
       +
       575412

     

       165
       165
       +
       ```

     

       166
       166
       +
       

     

       167
       167
       +
       <!-- livebook:{"offset":8997,"stamp":{"token":"XCP.3mLPPPAFmjyMyS1G8kuPg81u2xWiHEqMWIEJie5Cub-RqAtUePx4xByO_bbzZmbk0fucCfAAzGCebPJTo1sxtCCZWiS2f_1WHfwLTeKQ-A3TtNs0-62JkPMIEOcsxBwvcw","version":2}} -->

+135

2023/day21.livemd

···

       1
       1
       +
       # Day 21

     

       2
       2
       +
       

     

       3
       3
       +
       ```elixir

     

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

     

       5
       5
       +
       ```

     

       6
       6
       +
       

     

       7
       7
       +
       ## Section

     

       8
       8
       +
       

     

       9
       9
       +
       <!-- livebook:{"attrs":{"assign_to":"puzzle_input","day":"21","session_secret":"ADVENT_OF_CODE_SESSION","year":"2023"},"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("2023", "21", System.fetch_env!("LB_ADVENT_OF_CODE_SESSION"))

     

       14
       14
       +
       ```

     

       15
       15
       +
       

     

       16
       16
       +
       ```elixir

     

       17
       17
       +
       # puzzle_input =

     

       18
       18
       +
       """

     

       19
       19
       +
       ...........

     

       20
       20
       +
       .....###.#.

     

       21
       21
       +
       .###.##..#.

     

       22
       22
       +
       ..#.#...#..

     

       23
       23
       +
       ....#.#....

     

       24
       24
       +
       .##..S####.

     

       25
       25
       +
       .##..#...#.

     

       26
       26
       +
       .......##..

     

       27
       27
       +
       .##.#.####.

     

       28
       28
       +
       .##..##.##.

     

       29
       29
       +
       ...........

     

       30
       30
       +
       """

     

       31
       31
       +
       ```

     

       32
       32
       +
       

     

       33
       33
       +
       ```elixir

     

       34
       34
       +
       lines =

     

       35
       35
       +
         puzzle_input

     

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

     

       37
       37
       +
       

     

       38
       38
       +
       map =

     

       39
       39
       +
         for {line, y} <- Enum.with_index(lines),

     

       40
       40
       +
             {char, x} <- Enum.with_index(to_charlist(line)),

     

       41
       41
       +
             char != ?.,

     

       42
       42
       +
             do: {char, {x, y}}

     

       43
       43
       +
       

     

       44
       44
       +
       %{?# => obstacles, ?S => [start]} = Enum.group_by(map, &elem(&1, 0), &elem(&1, 1))

     

       45
       45
       +
       

     

       46
       46
       +
       height = length(lines)

     

       47
       47
       +
       width = byte_size(hd(lines))

     

       48
       48
       +
       

     

       49
       49
       +
       obstacles = MapSet.new(obstacles)

     

       50
       50
       +
       {sx, sy} = start

     

       51
       51
       +
       ```

     

       52
       52
       +
       

     

       53
       53
       +
       ```elixir

     

       54
       54
       +
       defmodule Day21 do

     

       55
       55
       +
         def build_distance_map(width, height, start, obstacles) do

     

       56
       56
       +
           distances =

     

       57
       57
       +
             for x <- 0..width,

     

       58
       58
       +
                 y <- 0..height,

     

       59
       59
       +
                 {x, y} not in obstacles,

     

       60
       60
       +
                 into: %{},

     

       61
       61
       +
                 do: {{x, y}, nil}

     

       62
       62
       +
       

     

       63
       63
       +
           do_build(Map.put(distances, start, 0), neighbours(start, width, height), width, height)

     

       64
       64
       +
         end

     

       65
       65
       +
       

     

       66
       66
       +
         defp do_build(distances, [], _w, _h), do: distances

     

       67
       67
       +
       

     

       68
       68
       +
         defp do_build(distances, [{x, y} | rest], w, h)

     

       69
       69
       +
              when is_nil(:erlang.map_get({x, y}, distances)) do

     

       70
       70
       +
           {min, next} =

     

       71
       71
       +
             Enum.reduce(neighbours({x, y}, w, h), {nil, []}, fn

     

       72
       72
       +
               {nx, ny}, {min, acc} ->

     

       73
       73
       +
                 case Map.fetch(distances, {nx, ny}) do

     

       74
       74
       +
                   {:ok, nil} -> {min, [{nx, ny} | acc]}

     

       75
       75
       +
                   {:ok, val} -> {min(min, val), acc}

     

       76
       76
       +
                   :error -> {min, acc}

     

       77
       77
       +
                 end

     

       78
       78
       +
             end)

     

       79
       79
       +
       

     

       80
       80
       +
           distances

     

       81
       81
       +
           |> Map.put({x, y}, min + 1)

     

       82
       82
       +
           |> do_build(rest ++ next, w, h)

     

       83
       83
       +
         end

     

       84
       84
       +
       

     

       85
       85
       +
         defp do_build(distances, [_ | rest], w, h), do: do_build(distances, rest, w, h)

     

       86
       86
       +
       

     

       87
       87
       +
         defp neighbours({x, y}, w, h),

     

       88
       88
       +
           do:

     

       89
       89
       +
             Enum.filter(

     

       90
       90
       +
               [

     

       91
       91
       +
                 {x + 1, y},

     

       92
       92
       +
                 {x - 1, y},

     

       93
       93
       +
                 {x, y + 1},

     

       94
       94
       +
                 {x, y - 1}

     

       95
       95
       +
               ],

     

       96
       96
       +
               &in_map?(&1, w, h)

     

       97
       97
       +
             )

     

       98
       98
       +
       

     

       99
       99
       +
         def in_map?({x, y}, w, h), do: x in 0..w and y in 0..h

     

       100
       100
       +
       end

     

       101
       101
       +
       ```

     

       102
       102
       +
       

     

       103
       103
       +
       ```elixir

     

       104
       104
       +
       dist = Day21.build_distance_map(width, height, start, obstacles)

     

       105
       105
       +
       ```

     

       106
       106
       +
       

     

       107
       107
       +
       ## Part 1

     

       108
       108
       +
       

     

       109
       109
       +
       ```elixir

     

       110
       110
       +
       radius = 64

     

       111
       111
       +
       

     

       112
       112
       +
       potential_positions =

     

       113
       113
       +
         for dx <- -radius..radius,

     

       114
       114
       +
             dy <- -radius..radius,

     

       115
       115
       +
             rem(dx + dy, 2) == 0,

     

       116
       116
       +
             p = {sx + dx, sy + dy},

     

       117
       117
       +
             dist[p] <= radius,

     

       118
       118
       +
             do: {sx + dx, sy + dy}

     

       119
       119
       +
       ```

     

       120
       120
       +
       

     

       121
       121
       +
       ```elixir

     

       122
       122
       +
       length(potential_positions)

     

       123
       123
       +
       ```

     

       124
       124
       +
       

     

       125
       125
       +
       ## Part 2

     

       126
       126
       +
       

     

       127
       127
       +
       ```elixir

     

       128
       128
       +
       {width, height}

     

       129
       129
       +
       ```

     

       130
       130
       +
       

     

       131
       131
       +
       ```elixir

     

       132
       132
       +
       radius = 26_501_365

     

       133
       133
       +
       ```

     

       134
       134
       +
       

     

       135
       135
       +
       <!-- livebook:{"offset":2664,"stamp":{"token":"XCP.IMvv8hCgLT5Uhw7XM98joJcCpiLODkv-dad_ZINIVpWiR15rOQ16JvnrIbZyWUgwLtcUNcu0O_o0fM9c_SHVKVz5kQtylMQU9zFIW02WoyY4Mif4i-dzdI_vkWqFZENooA","version":2}} -->

+83

2024/day01.livemd

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 01

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

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

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIxIiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjQifQ","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", "1", 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
       +
        "28186   35627\n51854   34597\n19211   51032\n79370   53096\n68126   40302\n43284   25771\n80565   99650\n83151   70796\n91092   74579\n70740   98650\n45166   53096\n24309   45165\n62950   26641\n23291   91017\n56683   53851\n22308   81625\n83150   34155\n87443   91017\n56834   91784\n35159   67595\n10722   83450\n92257   23419\n15995   96671\n89901   39216\n25104   76669\n37075   56652\n15874   66083\n33493   35627\n87420   31838\n11269   91386\n92604   83450\n34888   99650\n49759   40926\n38211   27379\n93866   22096\n88205   66217\n55772   60776\n83556   78255\n22292   50829\n22487   78358\n27260   79702\n74570   90319\n27532   14353\n40720   67595\n99885   65688\n25733   53752\n12466   14411\n88402   40165\n63328   13804\n45165   62461\n24913   94225\n32251   76669\n91004   40165\n48939   45165\n98082   34561\n74569   42932\n99641   54600\n42748   22021\n23376   54490\n38706   69865\n64985   87783\n14431   78715\n37671   94814\n27425   60776\n21801   76669\n96975   33493\n56680   31838\n41265   71129\n99081   32487\n53077   82615\n54490   55624\n22649   60776\n82601   25943\n93133   96412\n77182   78358\n67827   76838\n45976   89107\n20352   89034\n28891   23800\n87739   76669\n47802   99650\n18060   28437\n65882   93980\n53343   13764\n84301   93604\n62547   93479\n79067   45165\n70139   54490\n28158   76669\n71631   39775\n36521   57540\n78928   37888\n75943   39076\n28462   60107\n95828   94225\n49768   73181\n40545   97945\n18963   74260\n17934   63046\n73054   13454\n43170   60924\n90257   28180\n99765   33493\n41380   50296\n24225   62945\n66579   73961\n73361   54622\n26339   91017\n84080   62041\n89322   54600\n84610   18344\n58420   87051\n12253   83450\n25631   91017\n71764   63533\n52908   40165\n56578   46636\n99876   61946\n43934   64469\n78242   11111\n97629   28916\n21477   91017\n97639   64456\n90978   53077\n94412   73836\n49249   96113\n92750   14411\n12961   13764\n84319   22230\n83435   78146\n48951   86109\n40258   13764\n54600   65577\n51432   53096\n11527   20394\n68196   94225\n14939   91017\n13158   39216\n62120   93587\n20939   71764\n58436   28038\n37198   31838\n59152   17554\n52958   44145\n64236   18285\n63763   56578\n40304   99650\n86564   78910\n45684   52760\n43139   61946\n99974   76669\n44698   86004\n19940   22021\n29106   78358\n60431   91386\n50880   76451\n96595   42193\n40966   73961\n64515   61946\n31081   39834\n87614   70892\n82663   54622\n73537   62994\n14125   56652\n51361   35627\n26084   35817\n82915   20069\n72409   22021\n22834   20071\n93476   83787\n63719   53096\n41505   48056\n56055   20404\n37255   99650\n33468   60776\n70472   22598\n66290   53077\n91071   67595\n30888   33173\n60826   29871\n12334   78358\n62744   69424\n85449   79500\n22333   16295\n67621   18455\n12605   90059\n32490   25835\n96639   75870\n82412   39747\n76964   60153\n60776   60776\n68837   39216\n35635   67595\n85239   14964\n15278   83450\n63581   35178\n77006   18285\n88570   80424\n61499   81689\n57466   47392\n78524   84304\n11821   53989\n62425   28916\n36264   50872\n38567   13061\n16357   45165\n17202   94451\n64290   31838\n76075   55071\n87325   40165\n93961   99650\n49866   65601\n91725   14411\n44721   18285\n44065   33493\n22521   56578\n28070   54600\n45621   54600\n54677   26913\n79647   24298\n89613   31415\n86493   13764\n16243   64218\n12832   21187\n43847   35189\n75859   54600\n69276   75826\n43251   14411\n96012   41446\n35482   35817\n45380   82383\n66801   31838\n79199   92341\n33087   70511\n40619   28916\n67655   80670\n22431   60776\n62731   54622\n29873   25771\n99354   63481\n36415   61946\n29742   94919\n64872   53077\n93028   55635\n32784   18285\n87488   68734\n56652   18285\n49968   80712\n82653   53096\n30377   24784\n40120   45165\n88404   70120\n69179   45165\n99645   67595\n44883   45165\n76320   43595\n29057   90019\n28502   61946\n73459   84304\n96354   54622\n77589   14301\n51381   54490\n40490   95808\n36023   27135\n13434   63807\n27250   35627\n13764   32845\n28229   34954\n56430   76669\n98593   63811\n11192   60776\n81601   72265\n86908   77116\n25484   82383\n31115   42206\n75124   70148\n96785   53096\n59814   85995\n17024   57255\n81701   41971\n43938   33493\n91646   33599\n96616   81828\n73270   87775\n75876   35817\n53007   83450\n39527   33975\n35936   17039\n95194   23302\n96876   80147\n68136   91386\n31253   19760\n98767   " <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       {left, right} =

     

       27
       27
       +
       puzzle_input

     

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

     

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

     

       30
       30
       +
         line

     

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

     

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

     

       33
       33
       +
         |> List.to_tuple()

     

       34
       34
       +
       end)

     

       35
       35
       +
       |> Enum.unzip()

     

       36
       36
       +
       ```

     

       37
       37
       +
       

     

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

     

       39
       39
       +
       

     

       40
       40
       +
       ```

     

       41
       41
       +
       {[28186, 51854, 19211, 79370, 68126, 43284, 80565, 83151, 91092, 70740, 45166, 24309, 62950, 23291,

     

       42
       42
       +
         56683, 22308, 83150, 87443, 56834, 35159, 10722, 92257, 15995, 89901, 25104, 37075, 15874, 33493,

     

       43
       43
       +
         87420, 11269, 92604, 34888, 49759, 38211, 93866, 88205, 55772, 83556, 22292, 22487, 27260, 74570,

     

       44
       44
       +
         27532, 40720, 99885, 25733, 12466, 88402, 63328, ...],

     

       45
       45
       +
        [35627, 34597, 51032, 53096, 40302, 25771, 99650, 70796, 74579, 98650, 53096, 45165, 26641, 91017,

     

       46
       46
       +
         53851, 81625, 34155, 91017, 91784, 67595, 83450, 23419, 96671, 39216, 76669, 56652, 66083, 35627,

     

       47
       47
       +
         31838, 91386, 83450, 99650, 40926, 27379, 22096, 66217, 60776, 78255, 50829, 78358, 79702, 90319,

     

       48
       48
       +
         14353, 67595, 65688, 53752, 14411, 40165, ...]}

     

       49
       49
       +
       ```

     

       50
       50
       +
       

     

       51
       51
       +
       ## Part 1

     

       52
       52
       +
       

     

       53
       53
       +
       ```elixir

     

       54
       54
       +
       left

     

       55
       55
       +
       |> Enum.sort()

     

       56
       56
       +
       |> Enum.zip_with(Enum.sort(right), &abs(&1 - &2))

     

       57
       57
       +
       |> Enum.sum()

     

       58
       58
       +
       ```

     

       59
       59
       +
       

     

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

     

       61
       61
       +
       

     

       62
       62
       +
       ```

     

       63
       63
       +
       1603498

     

       64
       64
       +
       ```

     

       65
       65
       +
       

     

       66
       66
       +
       ## Part 2

     

       67
       67
       +
       

     

       68
       68
       +
       ```elixir

     

       69
       69
       +
       freq_left = Enum.frequencies(left)

     

       70
       70
       +
       freq_right = Enum.frequencies(right)

     

       71
       71
       +
       

     

       72
       72
       +
       freq_left

     

       73
       73
       +
       |> Enum.map(fn {id, n} -> id * n * Map.get(freq_right, id, 0) end)

     

       74
       74
       +
       |> Enum.sum()

     

       75
       75
       +
       ```

     

       76
       76
       +
       

     

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

     

       78
       78
       +
       

     

       79
       79
       +
       ```

     

       80
       80
       +
       25574739

     

       81
       81
       +
       ```

     

       82
       82
       +
       

     

       83
       83
       +
       <!-- livebook:{"offset":6294,"stamp":{"token":"XCP.Sz2iSQavADDpvtEa1kPPKXU2FJX4whRA8o-9s7dVkXuAtZgcWAfkz84tbAfwi7Uwo2ZHGidQtTuQgV-kqNBK-CR04hZZSMuvCDJWvO3n-0VLRe9_gxnirhNs2i3h2ydu0JE","version":2}} -->

+141

2024/day02.livemd

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 02

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

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

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIyIiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjQifQ","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", "2", 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
       +
        "75 76 77 80 82 85 84\n49 52 53 55 58 59 61 61\n54 57 60 62 66\n4 6 8 10 11 14 19\n82 85 86 83 85 87 89\n85 86 87 86 89 88\n69 72 73 76 77 74 75 75\n4 6 4 5 8 11 15\n6 9 10 12 15 16 15 20\n41 43 43 45 48 51\n48 51 53 53 56 58 59 58\n67 69 71 74 74 77 77\n82 83 85 85 89\n21 24 26 26 29 31 36\n4 7 10 11 15 18 20 21\n56 58 60 63 65 69 70 68\n24 26 30 32 33 35 35\n12 13 15 17 20 24 25 29\n52 53 54 57 58 59 63 68\n43 46 48 55 58 59\n15 16 23 26 27 28 26\n49 50 53 56 59 64 64\n56 58 59 65 69\n3 5 6 8 13 18\n45 44 46 47 50 52 54\n37 35 36 37 34\n53 50 51 53 54 56 56\n80 78 79 80 81 83 86 90\n32 31 34 37 40 45\n76 75 77 79 77 80\n26 25 22 24 23\n27 26 23 24 25 25\n96 93 96 93 97\n37 34 35 36 39 36 38 45\n68 65 66 67 67 70 72\n41 39 42 42 43 40\n88 86 89 90 90 91 93 93\n24 23 25 26 26 28 32\n79 77 77 80 83 88\n50 48 50 52 55 58 62 63\n39 38 39 41 45 47 48 45\n40 38 41 42 44 45 49 49\n50 49 53 56 60\n74 73 77 80 86\n40 37 38 39 42 48 49 50\n12 11 17 20 22 23 25 23\n74 71 73 75 80 83 83\n20 17 23 25 29\n32 30 37 39 42 48\n80 80 83 86 87\n73 73 76 78 80 83 85 82\n19 19 22 25 28 30 32 32\n43 43 46 49 53\n69 69 72 75 80\n24 24 25 22 25 27\n60 60 58 61 64 65 62\n52 52 50 51 53 55 55\n56 56 59 56 60\n37 37 38 36 38 45\n7 7 9 12 12 13 14 16\n52 52 55 57 57 56\n89 89 89 91 91\n7 7 7 10 13 15 17 21\n43 43 44 47 50 50 52 58\n4 4 5 9 10 11 14 17\n11 11 13 17 15\n7 7 11 14 14\n55 55 58 62 64 66 70\n75 75 78 79 81 85 88 94\n56 56 63 64 67\n5 5 7 10 12 13 18 16\n32 32 38 41 43 44 47 47\n36 36 43 44 48\n9 9 12 17 22\n11 15 16 18 20 21 23 26\n50 54 55 57 60 62 64 61\n86 90 92 94 95 95\n84 88 90 93 97\n3 7 9 12 15 21\n36 40 41 44 47 46 47 50\n39 43 45 43 46 47 50 47\n84 88 90 87 90 90\n2 6 7 4 6 10\n31 35 34 35 36 39 45\n11 15 15 16 18\n1 5 7 9 11 14 14 13\n54 58 60 60 63 63\n52 56 58 60 60 64\n61 65 65 66 71\n48 52 55 56 60 61\n77 81 84 88 89 86\n58 62 63 66 67 71 74 74\n71 75 78 81 82 84 88 92\n82 86 87 91 98\n41 45 48 50 55 58 61\n70 74 77 78 83 86 88 85\n71 75 82 84 84\n19 23 30 31 35\n59 63 70 72 77\n45 51 53 55 56\n8 14 16 19 17\n46 52 55 58 58\n71 77 79 82 84 87 88 92\n68 75 77 80 87\n29 35 38 35 36 38 39\n34 39 38 41 43 45 42\n26 33 35 34 36 39 41 41\n85 92 95 92 96\n33 38 40 39 40 41 48\n83 89 92 93 93 94 95 96\n85 92 95 95 97 96\n54 59 59 60 61 62 64 64\n27 34 35 37 37 41\n69 75 77 79 81 81 86\n25 30 31 32 36 38\n51 58 62 63 64 63\n54 61 62 65 69 72 74 74\n59 66 68 69 73 76 79 83\n14 19 20 24 30\n33 40 42 48 51 52\n28 33 36 37 42 45 43\n44 50 55 58 58\n14 21 22 29 30 34\n35 40 43 49 52 53 59\n63 61 58 56 54 51 53\n52 49 46 45 45\n74 72 69 68 67 63\n80 77 74 73 72 67\n77 74 76 73 70 68 67\n20 17 16 15 17 19\n45 42 41 38 36 35 38 38\n55 54 56 53 49\n20 18 17 15 14 16 10\n17 14 14 12 10 8 6\n72 71 69 68 66 66 63 65\n31 30 30 27 26 25 24 24\n51 49 48 48 47 43\n26 24 24 21 20 14\n19 18 14 13 10 8\n84 81 80 76 78\n47 45 41 38 35 35\n68 67 64 60 56\n74 71 68 66 62 60 54\n43 41 38 36 33 27 26\n63 60 53 51 54\n29 28 23 20 17 16 14 14\n46 45 42 39 34 31 30 26\n23 21 19 13 11 5\n27 29 26 24 23 22 19\n86 88 86 83 81 79 81\n57 59 57 54 52 50 47 47\n21 24 21 18 14\n61 63 62 61 59 57 50\n96 99 97 98 96 95 92\n66 69 71 69 71\n41 43 42 39 37 40 37 37\n79 82 85 84 80\n77 79 77 78 73\n22 24 24 22 20\n63 66 64 64 66\n19 22 22 21 18 18\n95 97 97 95 93 91 87\n32 33 31 29 29 28 25 18\n42 44 43 39 38 36 34 31\n27 29 27 24 22 18 20\n20 22 18 15 15\n68 69 65 63 59\n79 81 77 76 73 72 67\n68 70 69 63 62 60 59 56\n42 44 39 36 33 36\n88 90 87 82 81 79 79\n66 69 66 59 58 54\n70 71 70 68 66 60 54\n77 77 76 74 72 71 69 66\n43 43 40 37 34 33 36\n21 21 20 18 18\n34 34 32 29 27 25 22 18\n79 79 78 76 73 66\n89 89 92 90 88\n77 77 75 73 72 73 76\n84 84 83 85 85\n30 30 28 26 23 22 25 21\n22 22 25 23 21 20 15\n66 66 66 64 63 62 60 57\n75 75 73 70 67 67 68\n33 33 33 30 27 25 22 22\n55 55 52 50 50 46\n40 40 38 38 37 32\n63 63 62 58 55\n95 95 94 90 92\n87 87 85 82 78 78\n88 88 84 83 79\n85 85 83 79 73\n53 53 51 44 42\n12 12 7 5 4 6\n53 53 48 47 44 44\n35 35 32 25 22 18\n46 46 39 36 34 27\n26 22 21 19 18 15\n91 87 86 85 83 85\n24 20 17 15 14 14\n66 62 60 57 54 50\n67 63 62 60 59 57 51\n41 37 35 38 37 36 33 31\n18 14 15 12 9 8 5 8\n37 33 32 30 29 30 30\n70 66 64 63 60 61 58 54\n34 30 28 26 23 26 24 18\n28 24 22 19 16 16 15\n54 50 50 48 47 44 41 43\n82 78 75 75 75\n38 34 34 33 30 29 25\n52 48" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       inputs =

     

       27
       27
       +
         puzzle_input

     

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

     

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

     

       30
       30
       +
           row

     

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

     

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

     

       33
       33
       +
         end)

     

       34
       34
       +
       ```

     

       35
       35
       +
       

     

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

     

       37
       37
       +
       

     

       38
       38
       +
       ```

     

       39
       39
       +
       [

     

       40
       40
       +
         ~c"KLMPRUT",

     

       41
       41
       +
         ~c"1457:;==",

     

       42
       42
       +
         ~c"69<>B",

     

       43
       43
       +
         [4, 6, 8, 10, 11, 14, 19],

     

       44
       44
       +
         ~c"RUVSUWY",

     

       45
       45
       +
         ~c"UVWVYX",

     

       46
       46
       +
         ~c"EHILMJKK",

     

       47
       47
       +
         [4, 6, 4, 5, 8, 11, 15],

     

       48
       48
       +
         [6, 9, 10, 12, 15, 16, 15, 20],

     

       49
       49
       +
         ~c")++-03",

     

       50
       50
       +
         ~c"03558:;:",

     

       51
       51
       +
         ~c"CEGJJMM",

     

       52
       52
       +
         ~c"RSUUY",

     

       53
       53
       +
         [21, 24, 26, 26, 29, 31, 36],

     

       54
       54
       +
         [4, 7, 10, 11, 15, 18, 20, 21],

     

       55
       55
       +
         ~c"8:<?AEFD",

     

       56
       56
       +
         [24, 26, 30, 32, 33, 35, 35],

     

       57
       57
       +
         [12, 13, 15, 17, 20, 24, 25, 29],

     

       58
       58
       +
         ~c"4569:;?D",

     

       59
       59
       +
         ~c"+.07:;",

     

       60
       60
       +
         [15, 16, 23, 26, 27, 28, 26],

     

       61
       61
       +
         ~c"1258;@@",

     

       62
       62
       +
         ~c"8:;AE",

     

       63
       63
       +
         [3, 5, 6, 8, 13, 18],

     

       64
       64
       +
         ~c"-,./246",

     

       65
       65
       +
         ~c"%#$%\"",

     

       66
       66
       +
         ~c"5235688",

     

       67
       67
       +
         ~c"PNOPQSVZ",

     

       68
       68
       +
         [32, 31, 34, 37, 40, 45],

     

       69
       69
       +
         ~c"LKMOMP",

     

       70
       70
       +
         [26, 25, 22, 24, 23],

     

       71
       71
       +
         [27, 26, 23, 24, 25, 25],

     

       72
       72
       +
         ~c"`]`]a",

     

       73
       73
       +
         ~c"%\"#$'$&-",

     

       74
       74
       +
         ~c"DABCCFH",

     

       75
       75
       +
         ~c")'**+(",

     

       76
       76
       +
         ~c"XVYZZ[]]",

     

       77
       77
       +
         [24, 23, 25, 26, 26, 28, 32],

     

       78
       78
       +
         ~c"OMMPSX",

     

       79
       79
       +
         ~c"20247:>?",

     

       80
       80
       +
         ~c"'&')-/0-",

     

       81
       81
       +
         ~c"(&)*,-11",

     

       82
       82
       +
         ~c"2158<",

     

       83
       83
       +
         ~c"JIMPV",

     

       84
       84
       +
         ~c"(%&'*012",

     

       85
       85
       +
         [12, 11, 17, 20, ...],

     

       86
       86
       +
         ~c"JGIKPSS",

     

       87
       87
       +
         [20, 17, ...],

     

       88
       88
       +
         [32, ...],

     

       89
       89
       +
         ~c"PPSVW",

     

       90
       90
       +
         ...

     

       91
       91
       +
       ]

     

       92
       92
       +
       ```

     

       93
       93
       +
       

     

       94
       94
       +
       ```elixir

     

       95
       95
       +
       defmodule Day02 do

     

       96
       96
       +
         def correct?([a, b | _] = input) do

     

       97
       97
       +
           cmp = if a > b, do: &>/2, else: &</2

     

       98
       98
       +
           valid? = fn [c, d] -> abs(c - d) in 1..3 and cmp.(c, d) end

     

       99
       99
       +
       

     

       100
       100
       +
           input

     

       101
       101
       +
           |> Enum.chunk_every(2, 1, :discard)

     

       102
       102
       +
           |> Enum.all?(valid?)

     

       103
       103
       +
         end

     

       104
       104
       +
       end

     

       105
       105
       +
       ```

     

       106
       106
       +
       

     

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

     

       108
       108
       +
       

     

       109
       109
       +
       ```

     

       110
       110
       +
       {:module, Day02, <<70, 79, 82, 49, 0, 0, 9, ...>>, {:correct?, 1}}

     

       111
       111
       +
       ```

     

       112
       112
       +
       

     

       113
       113
       +
       ## Part 1

     

       114
       114
       +
       

     

       115
       115
       +
       ```elixir

     

       116
       116
       +
       Enum.count(inputs, &Day02.correct?/1)

     

       117
       117
       +
       ```

     

       118
       118
       +
       

     

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

     

       120
       120
       +
       

     

       121
       121
       +
       ```

     

       122
       122
       +
       479

     

       123
       123
       +
       ```

     

       124
       124
       +
       

     

       125
       125
       +
       ## Part 2

     

       126
       126
       +
       

     

       127
       127
       +
       ```elixir

     

       128
       128
       +
       Enum.count(inputs, fn row ->

     

       129
       129
       +
         Enum.any?(0..length(row), fn idx ->

     

       130
       130
       +
           row |> List.delete_at(idx) |> Day02.correct?()

     

       131
       131
       +
         end)

     

       132
       132
       +
       end)

     

       133
       133
       +
       ```

     

       134
       134
       +
       

     

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

     

       136
       136
       +
       

     

       137
       137
       +
       ```

     

       138
       138
       +
       531

     

       139
       139
       +
       ```

     

       140
       140
       +
       

     

       141
       141
       +
       <!-- livebook:{"offset":6719,"stamp":{"token":"XCP.G9JOBFd6jltWt-jkW37gzAIiay7brKZPFEBwgZCNOwBJpPmDyHp2GNGrNOADiSuyHghh61GSONlBGBUhRAPkPyonpwEHNjQtjnNbJGdA9f5v976Ir8CzhrtsvgWjFZ82wsQ","version":2}} -->

+59

2024/day03.livemd

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 03

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

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

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiIzIiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjQifQ","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", "3", 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
       +
        "(%%from() when()mul(73,623)when()mul(793,458)'~where()how()?how(569,237)/[mul(709,198)mul(395,622)$!what()select()^@/what()+mul(970,343)mul(75,7)^))mul(61,40)select()~why())'>where()%+mul(892,307),!(mul(412,807):*&what()+^why()<^why()mul(706,931)'{who())why()^?mul(953,62)(mul(461,410)when()don't()>^@<%who()'mul(365,15)(<^<# (where()mul(802,710)why()*[(  where()where()mul(684,352)&)&what()^<[>mul(246,913)+select()?how(489,271)when() }why(627,30);don't()+&<@where()when()mul(636,990)]/mul(767,759):mul(328,474)([^,-select()?(mul(825,353)select()where()*where()what()*-@mul(765,991)where(786,744)'--where()mul(990,947) mul(547,706)from()?mul(229,193)where(617,453)+@&where()]@%}/mul(128,550)<%mul(3,636)don't()^(+#>+mul(66,503) select()#when()%from()mul(59,150)how(),when()^:mul(614,438)where()*<[where();(mul(434,344) /how()$ (%?~when()mul(659,534)mul(809,367) where(42,397),);? ++select()mul(858,771)<*mul(106,962)^>@;# @?,*mul(208,462)'',)mul(762,748)+[?}>][^mul(126,384))@]): /(('mul(966,704)who()what()~%*]from()mul(825,633)~$)+ &mul(634,698)(how()<@why(102,647)mul(661,112)]&<(%&mul(25,649)who()select();mul(267,405)why(356,766)why()(where(),select()^)mul(552,557){!from()^&>>+mul(493,578)select(742,239):how(){^mul(836,239)who()/)-mul(259,726)how()-;where()[#@from()~mul(495,301);>[;mul(478,953)$#[*why(),{mul(774,653)how()^mul(469,614)!what();-->>;mul(369,74)$who()who()mul(311,382)< ![>?$mul(909,70)!+$how(257,485)<mul(278,404)] where()':mul(824,974)when(),;&@-?~>mul(377,363)where()&why()-/:(mul(285,466)where()(what()why()[where()&who()mul(701,477)(where(),-why(){mul(624,21)where()[,why()-!?+mul(937,219) mul(604,90)how()(')]why()/mul(627,697)*;what()/$select()do()~<from()%-^mul(605,52)>@%!&select()>['mul(597,962)why()where()mul(903,469); &,do()when(937,722)((~why();^mul(588,272);}?[mul(295,621)from(645,893)>]>#mul(900,24)>,;mul(574,932):}(-do()from()-+<'$how()mul(694where())select()){how()how() (mul(350,308)/{)}why()what(987,719)}!#don't();<how()[from()/-'mul(438,672)}!@who() }?)mul(952,413#>:}-: 'when()select()mul(547,749)$#mul(869,866)@{mul(334,736';'select(330,146)[~ :>mul(511,40)(mul(11,3 mul(547,132)[!>select();who()mul(424,102)*!~mul(725,298)~:{^?%*mul(514,355%'],,: -)mul(116,719)select()?/@;when()<who();!mul(352,211)+#$;{$>]mul(820,414)&when(),!?[:?don't()when()?>}+#how()mul(159$$},:]why()-mul(689,30)@^mul(310,593)where(800,717)^(/*/! from()<mul(7,727)select()&mul(259,310)where()^select()#@how(49,595)what(){>]mul(429,841)(-+#[mul(579,668)>what()&+,mul(850,283)don't()#?mul(758,673)^;)select(856,890)%:how(550,676)<,)mul(667,314)>:[;+mul(760,374)select();}*select()#how()$*mul(347,822)who()how(){mul(497,700):where(){what()mul(851,789)^:}when()why()where()(:mul(991,536)-mul(711,63)',(  who()]mul(798,573)>mul(190,153)$]from()!mul(592,256)-$-]mul(734?mul(482,742)#;mul(939,69)how()([how()<what()$$who()why()mul(149,831))/'when()mul(152,123)+* ','$where()mul(774,252) ;@?,;don't()how()>(mul(933,652)}mul(882,656),?how()#%}do()!select()>}>mul(981,750)mul(927,646)!what()$mul(380why()$]/[*?+)mul(67,435)>select()@-mul(819,795)?/? how())mul(215,234){,#/>how(513,708)'~>do()#}^^mul#how()how()how()+when():mul(992,63)mul(526,962)where()}who()who()+&'<,mul(730,728)}/,select()what()*who())[mul(687,974)-<:mul(259,420)\nwho()(&?>'+:?mul(483,827)*!what()[!/*mul(368,168)!&;^)?mul(629,217)]^{what()!,who()mul(83,255)^)mul(500,689)!-mul(592,556)%select()}from()-+mul(946*who()?,from()%/'~from(619,712){mul(747,249)/@+%when())mul(762,891)what(),when()?,#<:[mul(873,69)+ :what()+how()&[}who()mul(591,81){when()mul(151,432)@<what()-@]do()/mul(233,269)%&![+where()what()-why()mul(402,497):@from()where()':(how()mul(520,79)!]^$<select()when(478,105)mul(340,948),(mul(410,461)select()from()]-(@who()who())]mul(511,538)!who(6,403)do()<(where()what()mul(443,727)when()where()?&where()~mul(302,402)&mul(599,23))[how()[+!{mul(823,16)#%#]+~who(942,742))how()mul(502,890)^;<where()from()!~;+;mul*$<;mul(25,421)/:where() {^who()mul(652,45)#?from()^~; ,<mul(783,401)?who()what()mul(828,237)!]^when(126,561)mul(724,536){<*?don't()])why()/mul(974,752)%]$})mul(688,4)!'#:'@$mul(115,891)['w" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ## Part 1

     

       26
       26
       +
       

     

       27
       27
       +
       ```elixir

     

       28
       28
       +
       Regex.scan(~r/mul\((\d{1,3}),(\d{1,3})\)/, puzzle_input)

     

       29
       29
       +
       |> Enum.reduce(0, fn [_, a, b], acc ->

     

       30
       30
       +
         acc + String.to_integer(a) * String.to_integer(b)

     

       31
       31
       +
       end)

     

       32
       32
       +
       ```

     

       33
       33
       +
       

     

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

     

       35
       35
       +
       

     

       36
       36
       +
       ```

     

       37
       37
       +
       175615763

     

       38
       38
       +
       ```

     

       39
       39
       +
       

     

       40
       40
       +
       ## Part 2

     

       41
       41
       +
       

     

       42
       42
       +
       ```elixir

     

       43
       43
       +
       Regex.scan(~r/do(n't)?\(\)|mul\((\d{1,3}),(\d{1,3})\)/, puzzle_input)

     

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

     

       45
       45
       +
         ["do()" | _], {_, sum} -> {true, sum}

     

       46
       46
       +
         ["don't()" | _], {_, sum} -> {false, sum}

     

       47
       47
       +
         [_, _, a, b], {true, sum} -> {true, sum + String.to_integer(a) * String.to_integer(b)}

     

       48
       48
       +
         _, {false, sum} -> {false, sum}

     

       49
       49
       +
       end)

     

       50
       50
       +
       |> elem(1)

     

       51
       51
       +
       ```

     

       52
       52
       +
       

     

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

     

       54
       54
       +
       

     

       55
       55
       +
       ```

     

       56
       56
       +
       74361272

     

       57
       57
       +
       ```

     

       58
       58
       +
       

     

       59
       59
       +
       <!-- livebook:{"offset":5260,"stamp":{"token":"XCP.aQCtuOA8woZ8_dCh-CI-OBSmlZ8-Kijxv-o6-KCS1J1zV2Ss2XT0dAkjFQeBxaoOH4bK9wrXdti0oBVzJ_CMqYHK_tz9j2KoN0reYeRd-HZeaNGz06-DbmfbvmwyNem79PU","version":2}} -->

+204

2024/day04.livemd

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 04

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

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

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiI0Iiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjQifQ","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", "4", 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
       +
        "MASAMXMSSXXMAMXXMXMASXMASXMMSMSMMMAXMASASMMSSMSXAXMASMMSMMMSSMSASMSSSSMSMSMXXMXMAXAMXMSMSSXSAMXMSSXSXSXMASXMSASXMMXSXMSSSSSXSAMMAMXSXXMAAXSA\nMASMMXMASAXASMSMMMSAMXSMSAMXAAAAAXAMXASXAMAAAAMMSMMMMMASXAAAAMMAMAMMASAAAAXMXMSSSSSSMMSAMAXAXXSMAMSAMXASAXXASAMXASAMAXXMASAAAMAMAXXMASXSXSXS\nMMXAXMMMSXMAMAAXAAXAAAXXSMMSMSMSMXAXMXSMMMMSSMXAMXAAXMAMMMMSSMMAMAMMAMMMMMXSAAXAAMMAXXSAMXMSMAXMAMSMSSXMASMMMSXSXMAXMMSMMMMMMSASMSXMAMAXXSAM\nSXSAMASASMSXMSMSMSSMMMMMMXAMXMMXMASMMMMAXXAAAMMMSSSSSMASXXAAXASMSXXMXSXSXSASMSMMSMSAMMMAMXAAMASXMMSXMXMMMXASAXMSAASAMXSAAMXSXMASAXMMXSMSMMAM\nAAAXXXMASASXMXMAXXMMASAASMXSASASXAAAAMSSMMMSXMAAMMMMMXAXMMMMSAMXAMASAMXSAMASXXAXAAMAMXSAMXSXSMMASAMSMASAAMSMMSSXMAXASASMMSAMASAMAMSMAAXMASXM\nMSMMXXMMMAMAMMMMMMXSAXXAMMMMXSAXMMXXAMXAAMMXMASXMAAASMMXAAMXAXAMMMAMAMAMAMXMASXMMXMAAXMAXMAMXMSAMASXMAXMSXMAMXXXMASAMAMAXMMMAAXXAAAMXSXMMMAS\nMXAXAMXXMMMMSAMAASMMMSMMASASAMAMAXMSXMSMMXAMXAXMMSSXSASXSSSMAMSMXMXSAMSSSMAMXMXAMAXXMMSAXAXMMXMASMMMMSSMMASAMMAMSMMAMAXSMXXMSSSSSSMXAXMSSMMM\nASXMMXSAMXAASXXMXSAAAXASAMMMASMSSSMAAMMXMMSSMASAMAMMMAMMAXMAXMASXMAXMSAAASASAMXSSMXSAAXSSMXAAXXAXMAMXMAMSMMAXMAAAAMXMAMXASXAMAMXMXMMAXAAXAXS\nMAASMAMMSSMMSMSSXSMMXSMMASMSXMAAASMMMMAAMAMAMXAXAASMSSMMMMXSMSXSMXSXMXMXMSXMASAMAAAMMMMMMXXXSXMASMXMXMMMSXMSAMASMSMAXMASAAMXMMSSMASXXMXMAXMA\nSAMXMXSAXAMASMXAASXSMMAXXMASAMMMMMMXXXSXMASAMXMASXSAAMXXXMMXMXAXMAMAMXXAAMAXAMASMMMSMMXSMMMXMAAMXXAXSXSASASXSMAMAAXMMSMMXMAXSAAAMXSASMSSXSAS\nMMXSSXMXSAMASXXMXMAXAXXMSMMMXSAMXXMSXMMASXSXSXXAXMMMMMXMAXAMXMMMMASAMXSMSSSMSMMMMMAXXMAXAAAAXXSXXSASXAMAXXMAXMAMSMMSASXMAXMXMMSXSAMXMAAXASAM\nASAMXAMXSXMAMMMXAMSSSMSAXXXMSXASASXXAASAMXMAMAMSXXAXASASASXXSAAAMASAMAXXAAAMXASXSMXXAMASMMSMSAMAMXXXMMMSMXMMMXMXAAAMXSASXSSSXAAAMMAMMMMMAMAM\nMMMSSXMXMAMXMSMXMSAAAAMMMXMSMSMMAAMSSMXAMMMAMXMXXSXSMSAMXSMAMSXSXAXAMSMMMSMMSAMAXAMXXAXXXAAAMXXMMSMMMSAMXXSASASXSMMXMSAMAAAAMMSXMAAMAMAMXMAM\nXXAXMASMSAMAAAAASMMMMXMASMMAAAXMAMAAMMMSAMSAMSAXMAAMMMAMXMMMMAXXAMXSMMSMAXXXXAMSMMSASMMMMSMXMSMMAAAAAMMMXMMAMASAMAAAXMSMMMMMXXMASXSSSSXSASAS\nSASAMXMAMMSASMSMXASMMASXSASMSSXSAMMXAAAASASAMXMXAXMSASASMXAAMMSMMSAMXAAMASMMSMMXAXMXXAAXXAAASAAMSSSMSXMXSAMAMAMASMSMSAMXMMASMMXMMAAAAXASMSSM\nXAMASXSXSASAXMXMSXMASAXASMSAAXXMAMSSSMSAXMMMSAMXMSASASAMAMMMSAAMAMASMSXSAXAMAMXMXMASXSMMSXSXMAXMAAXAMASXMAMXSXMXMXAXMAMAMAAAXMSXMMMMMMXMXXXM\nMMMASMAAMMMAMASASAMXMASMMAMMMMMXMMXAMAMXMAAXMAXXXMAMXMMMSSMAMMXMXSXMAXMMMSSSXSMSAMXSAXMASMMMASXMXSXXXAMAXAMMSASMSSSMSASASMXSAMAMXXAASXMMSASX\nAXMAXXMXMXSAMMMAMAMXMXAMXSMSXASASMMAMXMSSXMSXSAMXMXMMXSXAAXMASXMXAMSXSAAXXAXXXAAXAAMMMXXMAMMAMAAAMMSMSSMMSSMSAMAAAAASASASAMXXAXMMSAXSAAXMASX\nSXMASXXXMAXASMMMMMSXMMASXAAXSXSXSASMMASMSAXMAXAMXXMAMASMSSMMAXAAASASASMMAAMMXMSMSMXSAMXMXSXMASMMMSAXMMAXSMAMMXMMMSMMMAMAMXMAMXMAMAMMSXMXMXMX\nMAMMAMXAMXSSMMXAAXAMASAMXMMASXSXSAMMSMSAXMASASAMMMAAMAXAMXXMMSMMAASMAMMXMMXSAAAAXMASASMMAMXXMAAAXMXSSMXMAXAMXAMSMMMSMSMSMAMMSAXMASAAXMMASAAX\nSAXSAXSXSXMMASMSSMXMMMASXXAAMMMAMAMAAMMMMAMMMMAMAASXMSSSXMAXMAXAXMXMSMAXXAASMMMSMXMSAMXMASMSSSSMMSAXMASAMSMSXMMAAAAAXAAXSAMMMMXXXMMXSMSASMSM\nMAMAXMMMXAASAMAMMMMMSSMSXSMXSAMSMMMSXSASAAXAAMAMSMMAMAAMAMXMSASXSXXXXAMXMMXSMSMXMAMMAMXSASAAXAAAXMAMSAMAXAMSASMSSMSSSMMMSMSAAXSSSXSMXAMXSXMX\nMSMSMMXSMSMMAXMASAMSAMXMASAAMXSAAXAMXSMSSSSSXSAXXXXAMMSMXXSXMASAXXMASAMXMSXXAAAASAXMAMMMMMMMMSAMMAMXMMXSMXMSAMAAAAXXMAXMXMSMMSAMAAMXSAMXXASM\nAMAMAXAMXXXSXMXAXMXMASAMXMMMSMSXSMMSAMXXAXAAXAXMASMSMSMXXXAMMMMMMSMXSMMSAMXMSMSMSMSSMMMASXSSMMXSMAXMASAMXXXMMMMMMXMMSMMSAMXASMAMMSMMAAXXMASM\nXMAMMMXSAMASMAMXSXXSAMAMSMMAAASMXXMAAASMXMMMMMXXXAAAMAMMMXMAAMAMAMXASAAAAMAAAAAMXMMASXSXMAMAAMAMXSXSAMXMAMXSXAMSMSAMAXAXAMAMMSSMXMXAXXMSAMXM\nSMXSAAAMAMAMMSMAXAMMXSAMAAXSMXXASXSMSMAMXAAXMXMMMMSMMAMSAAXSXSAMAMXXSMMSASXSMSMSAMSAMMSAMXMSAMXSAXMMXMAXAMAAMAMAAAXSASMSSMXSAAXMASASAMXSAASM\nAAAAMMSSXMASAAMSXSAMXSXSXSMXMASASAMXMAASASXMXAAXAXAASAXASXMMASXSASMMMXAXXMAAMXXXMMMXMAMAMXMXAMXSAXAXSXMXAMMXSAMMSMMMMSMAMXMMMSSMXAAXAAAMXMXM\nMMMSAAXMMMSMMSSMAMMMMMMMMXAXSXSAMXMAXXXSXAAMSSSXMXSXMXSMMSAMAMAMXSAAAMXMAMMMMMSMSXSMMMXMMAXSAMAMASMXMASXSMMASXSAMXSAMXMAMAXASXXMMMMMMMXMMSSM\nSAMAMMSMSMXAMMXMAMMSASASASAMMAMMMMMXMSAMXMXMAAMASMMXSMAXAXMMMMSMMMXSMSSSSSMAAAMMSAMMAMASXSMSAMXSASAXMAMAMAMMSAMXSASASXSMSMSXSXAMAAAAXSASAAXX\nSMSMXXA" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       # puzzle_input

     

       27
       27
       +
       search_box =

     

       28
       28
       +
         puzzle_input

     

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

     

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

     

       31
       31
       +
       ```

     

       32
       32
       +
       

     

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

     

       34
       34
       +
       

     

       35
       35
       +
       ```

     

       36
       36
       +
       [~c"MASAMXMSSXXMAMXXMXMASXMASXMMSMSMMMAXMASASMMSSMSXAXMASMMSMMMSSMSASMSSSSMSMSMXXMXMAXAMXMSMSSXSAMXMSSXSXSXMASXMSASXMMXSXMSSSSSXSAMMAMXSXXMAAXSA",

     

       37
       37
       +
        ~c"MASMMXMASAXASMSMMMSAMXSMSAMXAAAAAXAMXASXAMAAAAMMSMMMMMASXAAAAMMAMAMMASAAAAXMXMSSSSSSMMSAMAXAXXSMAMSAMXASAXXASAMXASAMAXXMASAAAMAMAXXMASXSXSXS",

     

       38
       38
       +
        ~c"MMXAXMMMSXMAMAAXAAXAAAXXSMMSMSMSMXAXMXSMMMMSSMXAMXAAXMAMMMMSSMMAMAMMAMMMMMXSAAXAAMMAXXSAMXMSMAXMAMSMSSXMASMMMSXSXMAXMMSMMMMMMSASMSXMAMAXXSAM",

     

       39
       39
       +
        ~c"SXSAMASASMSXMSMSMSSMMMMMMXAMXMMXMASMMMMAXXAAAMMMSSSSSMASXXAAXASMSXXMXSXSXSASMSMMSMSAMMMAMXAAMASXMMSXMXMMMXASAXMSAASAMXSAAMXSXMASAXMMXSMSMMAM",

     

       40
       40
       +
        ~c"AAAXXXMASASXMXMAXXMMASAASMXSASASXAAAAMSSMMMSXMAAMMMMMXAXMMMMSAMXAMASAMXSAMASXXAXAAMAMXSAMXSXSMMASAMSMASAAMSMMSSXMAXASASMMSAMASAMAMSMAAXMASXM",

     

       41
       41
       +
        ~c"MSMMXXMMMAMAMMMMMMXSAXXAMMMMXSAXMMXXAMXAAMMXMASXMAAASMMXAAMXAXAMMMAMAMAMAMXMASXMMXMAAXMAXMAMXMSAMASXMAXMSXMAMXXXMASAMAMAXMMMAAXXAAAMXSXMMMAS",

     

       42
       42
       +
        ~c"MXAXAMXXMMMMSAMAASMMMSMMASASAMAMAXMSXMSMMXAMXAXMMSSXSASXSSSMAMSMXMXSAMSSSMAMXMXAMAXXMMSAXAXMMXMASMMMMSSMMASAMMAMSMMAMAXSMXXMSSSSSSMXAXMSSMMM",

     

       43
       43
       +
        ~c"ASXMMXSAMXAASXXMXSAAAXASAMMMASMSSSMAAMMXMMSSMASAMAMMMAMMAXMAXMASXMAXMSAAASASAMXSSMXSAAXSSMXAAXXAXMAMXMAMSMMAXMAAAAMXMAMXASXAMAMXMXMMAXAAXAXS",

     

       44
       44
       +
        ~c"MAASMAMMSSMMSMSSXSMMXSMMASMSXMAAASMMMMAAMAMAMXAXAASMSSMMMMXSMSXSMXSXMXMXMSXMASAMAAAMMMMMMXXXSXMASMXMXMMMSXMSAMASMSMAXMASAAMXMMSSMASXXMXMAXMA",

     

       45
       45
       +
        ~c"SAMXMXSAXAMASMXAASXSMMAXXMASAMMMMMMXXXSXMASAMXMASXSAAMXXXMMXMXAXMAMAMXXAAMAXAMASMMMSMMXSMMMXMAAMXXAXSXSASASXSMAMAAXMMSMMXMAXSAAAMXSASMSSXSAS",

     

       46
       46
       +
        ~c"MMXSSXMXSAMASXXMXMAXAXXMSMMMXSAMXXMSXMMASXSXSXXAXMMMMMXMAXAMXMMMMASAMXSMSSSMSMMMMMAXXMAXAAAAXXSXXSASXAMAXXMAXMAMSMMSASXMAXMXMMSXSAMXMAAXASAM",

     

       47
       47
       +
        ~c"ASAMXAMXSXMAMMMXAMSSSMSAXXXMSXASASXXAASAMXMAMAMSXXAXASASASXXSAAAMASAMAXXAAAMXASXSMXXAMASMMSMSAMAMXXXMMMSMXMMMXMXAAAMXSASXSSSXAAAMMAMMMMMAMAM",

     

       48
       48
       +
        ~c"MMMSSXMXMAMXMSMXMSAAAAMMMXMSMSMMAAMSSMXAMMMAMXMXXSXSMSAMXSMAMSXSXAXAMSMMMSMMSAMAXAMXXAXXXAAAMXXMMSMMMSAMXXSASASXSMMXMSAMAAAAMMSXMAAMAMAMXMAM",

     

       49
       49
       +
        ~c"XXAXMASMSAMAAAAASMMMMXMASMMAAAXMAMAAMMMSAMSAMSAXMAAMMMAMXMMMMAXXAMXSMMSMAXXXXAMSMMSASMMMMSMXMSMMAAAAAMMMXMMAMASAMAAAXMSMMMMMXXMASXSSSSXSASAS",

     

       50
       50
       +
        ~c"SASAMXMAMMSASMSMXASMMASXSASMSSXSAMMXAAAASASAMXMXAXMSASASMXAAMMSMMSAMXAAMASMMSMMXAXMXXAAXXAAASAAMSSSMSXMXSAMAMAMASMSMSAMXMMASMMXMMAAAAXASMSSM",

     

       51
       51
       +
        ~c"XAMASXSXSASAXMXMSXMASAXASMSAAXXMAMSSSMSAXMMMSAMXMSASASAMAMMMSAAMAMASMSXSAXAMAMXMXMASXSMMSXSXMAXMAAXAMASXMAMXSXMXMXAXMAMAMAAAXMSXMMMMMMXMXXXM",

     

       52
       52
       +
        ~c"MMMASMAAMMMAMASASAMXMASMMAMMMMMXMMXAMAMXMAAXMAXXXMAMXMMMSSMAMMXMXSXMAXMMMSSSXSMSAMXSAXMASMMMASXMXSXXXAMAXAMMSASMSSSMSASASMXSAMAMXXAASXMMSASX",

     

       53
       53
       +
        ~c"AXMAXXMXMXSAMMMAMAMXMXAMXSMSXASASMMAMXMSSXMSXSAMXMXMMXSXAAXMASXMXAMSXSAAXXAXXXAAXAAMMMXXMAMMAMAAAMMSMSSMMSSMSAMAAAAASASASAMXXAXMMSAXSAAXMASX",

     

       54
       54
       +
        ~c"SXMASXXXMAXASMMMMMSXMMASXAAXSXSXSASMMASMSAXMAXAMXXMAMASMSSMMAXAAASASASMMAAMMXMSMSMXSAMXMXSXMASMMMSAXMMAXSMAMMXMMMSMMMAMAMXMAMXMAMAMMSXMXMXMX",

     

       55
       55
       +
        ~c"MAMMAMXAMXSSMMXAAXAMASAMXMMASXSXSAMMSMSAXMASASAMMMAAMAXAMXXMMSMMAASMAMMXMMXSAAAAXMASASMMAMXXMAAAXMXSSMXMAXAMXAMSMMMSMSMSMAMMSAXMASAAXMMASAAX",

     

       56
       56
       +
        ~c"SAXSAXSXSXMMASMSSMXMMMASXXAAMMMAMAMAAMMMMAMMMMAMAASXMSSSXMAXMAXAXMXMSMAXXAASMMMSMXMSAMXMASMSSSSMMSAXMASAMSMSXMMAAAAAXAAXSAMMMMXXXMMXSMSASMSM",

     

       57
       57
       +
        ~c"MAMAXMMMXAASAMAMMMMMSSMSXSMXSAMSMMMSXSASAAXAAMAMSMMAMAAMAMXMSASXSXXXXAMXMMXSMSMXMAMMAMXSASAAXAAAXMAMSAMAXAMSASMSSMSSSMMMSMSAAXSSSXSMXAMXSXMX",

     

       58
       58
       +
        ~c"MSMSMMXSMSMMAXMASAMSAMXMASAAMXSAAXAMXSMSSSSSXSAXXXXAMMSMXXSXMASAXXMASAMXMSXXAAAASAXMAMMMMMMMMSAMMAMXMMXSMXMSAMAAAAXXMAXMXMSMMSAMAAMXSAMXXASM",

     

       59
       59
       +
        ~c"AMAMAXAMXXXSXMXAXMXMASAMXMMMSMSXSMMSAMXXAXAAXAXMASMSMSMXXXAMMMMMMSMXSMMSAMXMSMSMSMSSMMMASXSSMMXSMAXMASAMXXXMMMMMMXMMSMMSAMXASMAMMSMMAAXXMASM",

     

       60
       60
       +
        ~c"XMAMMMXSAMASMAMXSXXSAMAMSMMAAASMXXMAAASMXMMMMMXXXAAAMAMMMXMAAMAMAMXASAAAAMAAAAAMXMMASXSXMAMAAMAMXSXSAMXMAMXSXAMSMSAMAXAXAMAMMSSMXMXAXXMSAMXM",

     

       61
       61
       +
        ~c"SMXSAAAMAMAMMSMAXAMMXSAMAAXSMXXASXSMSMAMXAAXMXMMMMSMMAMSAAXSXSAMAMXXSMMSASXSMSMSAMSAMMSAMXMSAMXSAXMMXMAXAMAAMAMAAAXSASMSSMXSAAXMASASAMXSAASM",

     

       62
       62
       +
        ~c"AAAAMMSSXMASAAMSXSAMXSXSXSMXMASASAMXMAASASXMXAAXAXAASAXASXMMASXSASMMMXAXXMAAMXXXMMMXMAMAMXMXAMXSAXAXSXMXAMMXSAMMSMMMMSMAMXMMMSSMXAAXAAAMXMXM",

     

       63
       63
       +
        ~c"MMMSAAXMMMSMMSSMAMMMMMMMMXAXSXSAMXMAXXXSXAAMSSSXMXSXMXSMMSAMAMAMXSAAAMXMAMMMMMSMSXSMMMXMMAXSAMAMASMXMASXSMMASXSAMXSAMXMAMAXASXXMMMMMMMXMMSSM",

     

       64
       64
       +
        ~c"SAMAMMSMSMXAMMXMAMMSASASASAMMAMMMMMXMSAMXMXMAAMASMMXSMAXAXMMMMSMMMXSMSSSSSMAAAMMSAMMAMASXSMSAMXSASAXMAMAMAMMSAMXSASASXSMSMSXSXAMAAAAXSASAAXX",

     

       65
       65
       +
        ~c"SMSMXXAAAAMMMMASASASASXMASAMXMAXAXSXMAAXMSXMAMXAMAMAMXSMMSXSXAAMXSMXXAAMAAMSMMSAMXMMASMSAMXSAMXMASXMMMSASAMAMXMAMASAMMSMAAXMMMSSSSSSSMAMMMMX",

     

       66
       66
       +
        ~c"XAAXASMSMSMAAXXXAXMMMMAMAMAMXXSSMXXMAMXMAMASXSMMMAMAMMXXAAAXMSXSAMAAMMSMSSMMMAMXSAMSASAMXMASXMAMMMMAXMAXXMSAMXMAMXMAMAMMMXMSXAAMAAAXAMXMSASA",

     

       67
       67
       +
        ~c"MXMXAMXAXMMSXSMMSMSSSSMMSSXMXXXAMXXSSSSMXSAMAMAAXSMMMAAMSMXXMAMMASASMAXMAAAAMMSASAXMSMXMXMASMXXXAAXMAMMAXMSXSASXSXSAMSSMSMASMMMSAMMMSXMXXASA",

     

       68
       68
       +
        ~c"SASXSSSXMSXMAAAAXAAAXMASXMAAXXMSAMMAAAXAAMASAMMMAMASMSXAXXAXMSSSXMAXMXSMSSMMSMAXMMMXAMXXMXAXMASMSMXSAASMXAXXSAMSAASXMAAAXMAXXAASMAMAXAXXMMMM",

     

       69
       69
       +
        ~c"SASAXAMXASAXSSSMMMMMMXMSASXMXMAXAXMMMMMMMMXAXXAMXXAMAMXSAMAMSAAXMMMMSXSAAXMASMMMMMXMMAMMAMSSMAXAAAASAMAAMSMXMSMMMMMMASMMXMMSMXMSSSMASMMAAAAA",

     

       70
       70
       +
        ~c"MSMXMAMSSMMMXAAAXXMASMXSAMSAMXSMSMMASAAXMXAAMMXXSMSSXMXXASAMXMSMSAMXMAMMMMMMMMAAAAAAXMMAXXMMMMMSMMMSAXMMMMAXAXXAAAXXAXAMXAAAXMMMMMMAMMSXSMSS",

     

       71
       71
       +
        ~c"SAMXSMMXXAAAMMMSAMXSMAAMAMMMXMXXAAMASXSXMSXSXSXASAMXAMXSXMAMMXMASASXMMMSXXSMMSSSSSSSSMSSSMXSAXXMAXAXXMXSAXMMMXSSSXMMSXMMSMSSSXSAAAMMXMXMMMXM",

     

       72
       72
       +
        ~c"XAMMASMSSMMSMAAXXAXMXMMSMMASASXASXMASAMXXSAMAAMMMAMSAMAXMASXMAMMMAMXAMSMSXAAMXAAAAMAAAAAAAAMXXMXMMSSMSASMMXAXAXMAXSAMAMXSAMAAMASXMXMAMMSAXAM",

     

       73
       73
       +
        ~c"SSMMSAMXAASMXMMSMMMSAMXXXSASASAXAAMAMAMMMMAMMXSASAMMAMXXXAXAMMSMSSSMSMSAXSSMMMMMMXMMMMMSMMMXMMAASAMAAMASAASXMMXMXXMAMXMMSAMMMMXASXSSXSASASMS",

     

       74
       74
       +
        ~c"XAXSMMSSSMMXAMAAAAXMMSSMAXXMXMXSSXMXMAMAAMXMXASASASMSMXSAMXMMSAMMAAAXAMXMMMSMXSAMXSAAXXAMXSAASMMSAMMMMMMMMAAMAMSASMSMASASAMSMXSAMXAAAAXMAMAA",

     

       75
       75
       +
        ~c"MXMXAAXMMMMSSMSSSSSMASAMSSMXXSAXAMMSSXSSSMSMMXMAMAMMXSAMXSAMXSASMSMMMSMMXMXAMXSAMXSSMMAMXAMMMMSASXMASMXSSMSSMASMASAXSMMASXMXMMAASMMMMMMMAMAM",

     

       76
       76
       +
        ~c"MXXMMMSMXSAAAAAXAXAMMXAMAAAAMXXSAAAAXXMAMAXXMXMMMSMMXMXSASASASAMXXXAAXAMASAXMASXMMMMSMAXMMSXXAMMMMSAXSAMXAMXMMSMMMMXAXMAMXMASASMMAXSXSAMAXAX",

     

       77
       77
       +
        ~c"MSMXAXXAAMMSMMMMSMSMMSMMXSMSXSMSXMMSMSMAMSMSMXMXMMAAMMXMASMMASAMXXSMXSXMAXAASASASXAAXXXMASAMMSMXMXMXSMXMMAMMMMXXXXXSMMMMSSXXAMMASMXAAMAMSMMS",

     

       78
       78
       +
        ~c"AAASXMMMMSMAXXXAAMAAXSXSMXAMAAASAXMAXAAXMXAMXAXAMMXMAXAMMMMMAXAXMMXMXSAMASXXMASAMSMMAXMAMXASAMMSMAXMMMSASAMAAAAMXMXAXXXSAMMMMASAMXSMSMSMMAMX",

     

       79
       79
       +
        ~c"SAXMSAAAAAMMMSMSSSMSMMAMAMAMXMSSMMMXASAMXMAMSMSXSSMSXMAXAAXMSSMMXMMSASMMMXXAMAMAMXMAXMASMSAMASASXSXSAAMXSAMSAMXAAAMMSMXMASAXSMMAMXAAMAXAMAMX",

     

       80
       80
       +
        ~c"AMMASXMMSSSMASAMAAXXAMAMMSMMXXXXAAMXMMXXXMMMMAAAXMAXMASMSXSXAAXMAXSMAXXAXMSMMMSXMSMXMAXAMMMMAMXMAMAMMMSASMMXAXMSMSAMAMMSAMMXSAMAMXMSMMMSSSMM",

     

       81
       81
       +
        ~c"SSMAMAMAMAAMAMAMXMMSAMXMXAAMAMMSSMSMXSXXMAXAMMMSMMSMXXMAXMSMSSMSXXAMSMSMSAMASAMXAAMSSSMSMAXAAXAMSMSMSXMASASMSMMAAXAMAMAMAMXMSAMXMMAMXXAAAAXX",

     

       82
       82
       +
        ~c"MAMXSXMAMSMMXSXMASAMSMASMSSSMXAAXSAMAXMSSXSAMAAAAMMMSAMXMAXAXAMAXMXMXAMASXSAMASXMXSAAXAXSASMMSXSXAMAMXMXMXMAMMSASXSMSASMSMSXSMMAMMSMMMSSSMAA",

     

       83
       83
       +
        ~c"SMMXMASAXMXMASASMSXSASMSAAAAMMMMSMMMMSMMAXAMSSSSXMAASXXMMAASMMMAXSAMMXMAMMMMSAMXMMMMSMMMMMSAASMMMSMAMSASMAMSMASAMAMAMAMAXXAAMXMSMMXAXMAAAXXM",

     

       84
       84
       +
        ~c"XAMXXXASAMAMXSAMASMAMMXMXMMMMASXMMXSAAAMMAMMAXMMMSMAXMAXASMXAMMAXSASMSMASXSASAMMAAXAMMXAXASMMMAAAXXAMXAXMAMAMXMSMXMXMAMSMMMSMMMXAASAMAMSMMMM",

     

       85
       85
       +
        ~c"SSMMSMAXXSXSAMAMAMAAXMAMXSMMSASMSMAMSSSMXMXMMSXAAXXAASMMMMASMMMXMSAMAAMXSXSAMAMXAMSASASASAMSXSSMSSSMMMAMSSSXSAAXMMMMSXMASXAXXXASMMMAAMXXXAAM",

     

       86
       86
       +
        ...]

     

       87
       87
       +
       ```

     

       88
       88
       +
       

     

       89
       89
       +
       ## Part 1

     

       90
       90
       +
       

     

       91
       91
       +
       ```elixir

     

       92
       92
       +
       defmodule CeresSearch do

     

       93
       93
       +
         def rows(rows), do: rows |> Enum.map(&count(&1, 0)) |> Enum.sum()

     

       94
       94
       +
       

     

       95
       95
       +
         def count([], acc), do: acc

     

       96
       96
       +
         def count(~c"XMAS" ++ rest, acc), do: count([?S | rest], acc + 1)

     

       97
       97
       +
         def count(~c"SAMX" ++ rest, acc), do: count([?X | rest], acc + 1)

     

       98
       98
       +
         def count([_ | rest], acc), do: count(rest, acc)

     

       99
       99
       +
       

     

       100
       100
       +
         def cols(rows) do

     

       101
       101
       +
           rows

     

       102
       102
       +
           |> Enum.zip()

     

       103
       103
       +
           |> Enum.map(&Tuple.to_list/1)

     

       104
       104
       +
           |> rows()

     

       105
       105
       +
           |> dbg()

     

       106
       106
       +
         end

     

       107
       107
       +
       

     

       108
       108
       +
         def diagonals(rows) do

     

       109
       109
       +
           map =

     

       110
       110
       +
             for {row, x} <- Enum.with_index(rows),

     

       111
       111
       +
                 {val, y} <- Enum.with_index(row),

     

       112
       112
       +
                 into: %{},

     

       113
       113
       +
                 do: {{y, x}, val}

     

       114
       114
       +
       

     

       115
       115
       +
           {w, h} = Enum.max(Map.keys(map))

     

       116
       116
       +
       

     

       117
       117
       +
           0..max(w, h)

     

       118
       118
       +
           |> gen_diagonals()

     

       119
       119
       +
           |> then(fn diags ->

     

       120
       120
       +
             Enum.map(diags, &extract(map, &1))

     

       121
       121
       +
           end)

     

       122
       122
       +
           |> rows()

     

       123
       123
       +
         end

     

       124
       124
       +
       

     

       125
       125
       +
         def gen_diagonals(_..max//_ = range) do

     

       126
       126
       +
           d1 =

     

       127
       127
       +
             for n <- range do

     

       128
       128
       +
               for(

     

       129
       129
       +
                 y <- 0..n,

     

       130
       130
       +
                 x = n - y,

     

       131
       131
       +
                 do: {y, x}

     

       132
       132
       +
               )

     

       133
       133
       +
             end

     

       134
       134
       +
       

     

       135
       135
       +
           d2 =

     

       136
       136
       +
             for n <- range do

     

       137
       137
       +
               for(

     

       138
       138
       +
                 y <- 0..n,

     

       139
       139
       +
                 x = max - n + y,

     

       140
       140
       +
                 do: {y, x}

     

       141
       141
       +
               )

     

       142
       142
       +
             end

     

       143
       143
       +
       

     

       144
       144
       +
           diag1 = d1 ++ d2

     

       145
       145
       +
       

     

       146
       146
       +
           diag2 =

     

       147
       147
       +
             Enum.map(diag1, fn d ->

     

       148
       148
       +
               Enum.map(d, fn {y, x} -> {max - y, x} end)

     

       149
       149
       +
             end)

     

       150
       150
       +
       

     

       151
       151
       +
           Enum.uniq_by(diag1 ++ diag2, &Enum.sort/1)

     

       152
       152
       +
         end

     

       153
       153
       +
       

     

       154
       154
       +
         def extract(map, keys) do

     

       155
       155
       +
           for key <- keys, val = map[key], do: val

     

       156
       156
       +
         end

     

       157
       157
       +
       

     

       158
       158
       +
         def search_all(box) do

     

       159
       159
       +
           cols(box) + rows(box) + diagonals(box)

     

       160
       160
       +
         end

     

       161
       161
       +
       end

     

       162
       162
       +
       ```

     

       163
       163
       +
       

     

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

     

       165
       165
       +
       

     

       166
       166
       +
       ```

     

       167
       167
       +
       {:module, CeresSearch, <<70, 79, 82, 49, 0, 0, 31, ...>>, {:search_all, 1}}

     

       168
       168
       +
       ```

     

       169
       169
       +
       

     

       170
       170
       +
       ```elixir

     

       171
       171
       +
       CeresSearch.search_all(search_box)

     

       172
       172
       +
       ```

     

       173
       173
       +
       

     

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

     

       175
       175
       +
       

     

       176
       176
       +
       ```

     

       177
       177
       +
       2401

     

       178
       178
       +
       ```

     

       179
       179
       +
       

     

       180
       180
       +
       ## Part 2

     

       181
       181
       +
       

     

       182
       182
       +
       ```elixir

     

       183
       183
       +
       map =

     

       184
       184
       +
         for {row, x} <- Enum.with_index(search_box),

     

       185
       185
       +
             {val, y} <- Enum.with_index(row),

     

       186
       186
       +
             into: %{},

     

       187
       187
       +
             do: {{y, x}, val}

     

       188
       188
       +
       

     

       189
       189
       +
       Enum.count(map, fn

     

       190
       190
       +
         {{y, x}, ?A} ->

     

       191
       191
       +
           [map[{y + 1, x + 1}], map[{y - 1, x - 1}]] in [~c"MS", ~c"SM"] and 

     

       192
       192
       +
             [map[{y - 1, x + 1}], map[{y + 1, x - 1}]] in [~c"MS", ~c"SM"]

     

       193
       193
       +
         _ ->

     

       194
       194
       +
           false

     

       195
       195
       +
       end)

     

       196
       196
       +
       ```

     

       197
       197
       +
       

     

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

     

       199
       199
       +
       

     

       200
       200
       +
       ```

     

       201
       201
       +
       1822

     

       202
       202
       +
       ```

     

       203
       203
       +
       

     

       204
       204
       +
       <!-- livebook:{"offset":14266,"stamp":{"token":"XCP.T-RaxkkrFX_OdT79HvWI46TqX7It60uksnJ1LTiQVcPcCTg_ZZN1SjjXIgHd4F397ANKRpGPP5xOXl4FWp7rCtZ86gir5tQaVrJ8BqeDCy_3leOOuggQbLw1uB3x5qEdZBg","version":2}} -->

+373

2024/day05.livemd

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       # Day 05

     

       4
       4
       +
       

     

       5
       5
       +
       ```elixir

     

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

     

       7
       7
       +
       ```

     

       8
       8
       +
       

     

       9
       9
       +
       ## Section

     

       10
       10
       +
       

     

       11
       11
       +
       <!-- livebook:{"attrs":"eyJhc3NpZ25fdG8iOiJwdXp6bGVfaW5wdXQiLCJkYXkiOiI1Iiwic2Vzc2lvbl9zZWNyZXQiOiJBRFZFTlRfT0ZfQ09ERV9TRVNTSU9OIiwieWVhciI6IjIwMjQifQ","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", "5", 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
       +
        "75|21\n28|29\n28|73\n95|48\n95|19\n95|16\n81|51\n81|95\n81|16\n81|56\n48|59\n48|83\n48|64\n48|57\n48|86\n15|43\n15|82\n15|49\n15|31\n15|35\n15|48\n83|68\n83|26\n83|56\n83|63\n83|64\n83|69\n83|84\n47|83\n47|29\n47|23\n47|18\n47|87\n47|53\n47|79\n47|59\n35|43\n35|34\n35|85\n35|28\n35|64\n35|94\n35|48\n35|79\n35|78\n34|65\n34|88\n34|87\n34|82\n34|45\n34|76\n34|47\n34|39\n34|49\n34|85\n92|15\n92|35\n92|59\n92|69\n92|34\n92|67\n92|26\n92|18\n92|73\n92|84\n92|19\n94|47\n94|83\n94|82\n94|85\n94|57\n94|48\n94|64\n94|28\n94|43\n94|76\n94|49\n94|88\n29|59\n29|51\n29|15\n29|73\n29|89\n29|66\n29|76\n29|75\n29|63\n29|53\n29|18\n29|62\n29|95\n69|94\n69|56\n69|66\n69|43\n69|85\n69|63\n69|82\n69|57\n69|78\n69|15\n69|34\n69|31\n69|35\n69|16\n63|78\n63|65\n63|43\n63|27\n63|66\n63|23\n63|62\n63|35\n63|34\n63|48\n63|56\n63|19\n63|94\n63|85\n63|57\n31|92\n31|28\n31|53\n31|49\n31|64\n31|59\n31|26\n31|47\n31|23\n31|76\n31|89\n31|79\n31|81\n31|83\n31|86\n31|45\n56|86\n56|43\n56|65\n56|57\n56|82\n56|47\n56|85\n56|48\n56|62\n56|31\n56|78\n56|35\n56|16\n56|87\n56|23\n56|95\n56|34\n23|76\n23|29\n23|39\n23|53\n23|45\n23|26\n23|27\n23|28\n23|79\n23|21\n23|84\n23|83\n23|73\n23|86\n23|81\n23|59\n23|68\n23|89\n65|53\n65|48\n65|87\n65|88\n65|27\n65|28\n65|49\n65|45\n65|82\n65|43\n65|29\n65|39\n65|76\n65|85\n65|64\n65|23\n65|31\n65|79\n65|92\n45|68\n45|59\n45|69\n45|73\n45|53\n45|21\n45|81\n45|62\n45|56\n45|15\n45|95\n45|35\n45|63\n45|51\n45|26\n45|19\n45|92\n45|66\n45|89\n45|78\n76|73\n76|51\n76|18\n76|75\n76|95\n76|66\n76|56\n76|69\n76|81\n76|21\n76|67\n76|26\n76|53\n76|92\n76|89\n76|35\n76|63\n76|19\n76|62\n76|59\n76|45\n53|92\n53|21\n53|18\n53|94\n53|67\n53|68\n53|69\n53|63\n53|66\n53|84\n53|34\n53|59\n53|89\n53|73\n53|78\n53|81\n53|19\n53|35\n53|26\n53|56\n53|15\n53|51\n51|47\n51|15\n51|69\n51|65\n51|94\n51|66\n51|31\n51|95\n51|43\n51|35\n51|78\n51|82\n51|85\n51|48\n51|23\n51|63\n51|34\n51|16\n51|88\n51|67\n51|62\n51|19\n51|56\n79|84\n79|28\n79|69\n79|45\n79|92\n79|83\n79|29\n79|53\n79|64\n79|76\n79|89\n79|51\n79|68\n79|39\n79|26\n79|81\n79|21\n79|63\n79|62\n79|59\n79|75\n79|56\n79|73\n79|18\n19|35\n19|48\n19|82\n19|94\n19|57\n19|78\n19|43\n19|79\n19|83\n19|31\n19|64\n19|23\n19|47\n19|67\n19|28\n19|85\n19|27\n19|86\n19|34\n19|65\n19|87\n19|88\n19|16\n19|49\n82|27\n82|68\n82|83\n82|39\n82|28\n82|73\n82|92\n82|49\n82|75\n82|89\n82|31\n82|45\n82|47\n82|18\n82|87\n82|53\n82|79\n82|23\n82|86\n82|81\n82|29\n82|59\n82|64\n82|76\n21|34\n21|19\n21|78\n21|57\n21|82\n21|51\n21|66\n21|35\n21|95\n21|62\n21|48\n21|84\n21|65\n21|69\n21|31\n21|56\n21|15\n21|67\n21|85\n21|16\n21|88\n21|94\n21|63\n21|43\n88|27\n88|29\n88|64\n88|75\n88|31\n88|59\n88|76\n88|39\n88|47\n88|28\n88|87\n88|23\n88|83\n88|81\n88|53\n88|86\n88|45\n88|18\n88|92\n88|79\n88|49\n88|57\n88|82\n88|89\n86|18\n86|28\n86|73\n86|75\n86|59\n86|26\n86|21\n86|69\n86|76\n86|79\n86|51\n86|92\n86|45\n86|83\n86|64\n86|49\n86|81\n86|68\n86|39\n86|53\n86|29\n86|84\n86|63\n86|89\n43|59\n43|64\n43|87\n43|47\n43|49\n43|57\n43|31\n43|86\n43|39\n43|27\n43|53\n43|88\n43|83\n43|89\n43|81\n43|79\n43|75\n43|82\n43|23\n43|76\n43|29\n43|28\n43|92\n43|45\n26|15\n26|82\n26|78\n26|67\n26|57\n26|88\n26|35\n26|43\n26|85\n26|21\n26|48\n26|84\n26|69\n26|62\n26|34\n26|19\n26|66\n26|65\n26|51\n26|16\n26|95\n26|94\n26|63\n26|56\n68|85\n68|65\n68|95\n68|35\n68|78\n68|67\n68|57\n68|51\n68|62\n68|56\n68|34\n68|21\n68|63\n68|88\n68|15\n68|48\n68|43\n68|26\n68|66\n68|84\n68|94\n68|19\n68|69\n68|16\n85|64\n85|27\n85|82\n85|43\n85|53\n85|48\n85|57\n85|86\n85|88\n85|29\n85|47\n85|87\n85|83\n85|75\n85|76\n85|28\n85|81\n85|49\n85|45\n85|39\n85|92\n85|31\n85|23\n85|79\n39|84\n39|76\n39|59\n39|67\n39|62\n39|92\n39|81\n39|69\n39|66\n39|26\n39|15\n39|75\n39|95\n39|63\n39|21\n39|73\n39|45\n39|51\n39|89\n39|53\n39|56\n39|68\n39|19\n39|18\n78|48\n78|87\n78|34\n78|29\n78|28\n78|79\n78|76\n78|43\n78|39\n78|85\n78|88\n78|49\n78|27\n78|86\n78|94\n78|64\n78|31\n78|83\n78|82\n78|16\n78|23\n78|47\n78|65\n78|57\n87|83\n87|26\n87|51\n87|29\n87|79\n87|45\n87|68\n87|75\n87|73\n87|21\n87|53\n87|81\n87|84\n87|39\n87|89\n87|92\n87|76\n87|59\n87|18\n87|86\n87|69\n87|49\n87|64\n87|28\n18|69\n18|95\n18|73\n18|16\n18|48\n18|21\n18|68\n18|85\n18|62\n18|34\n18|19\n18|65\n18|15\n18|94\n18|63\n18|51\n18|66\n18|84\n18|67\n18|43\n18|35\n18|26\n18|56\n18|78\n84|95\n84|62\n84|48\n84|35\n84|57\n84|31\n84|16\n84|78\n84|65\n84|88\n84|67\n84|34\n84|19\n84|43\n84|69\n84|15\n84|94\n84|63\n84|51\n84|66\n84|47\n84|56\n84|85\n84|82\n59|34\n59|69\n59|89\n59|19\n59|62\n59|84\n59|68\n59|73\n59|26\n59|66\n59|94\n59|67\n59|21\n59|85\n59|18\n59|95\n59|16\n59|15\n59|63\n59|56\n59|35\n59|51\n59|78\n59|65\n67|88\n67|27\n67|16\n67|28\n67|79\n67|64\n67|65\n67|29\n67|47\n67|83\n67|34\n67|48\n67|49\n67|43\n67|94\n67|23\n67|85\n67|35\n67|31\n67|82\n67|57\n67|87\n67|8" <> ...}

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       ```elixir

     

       26
       26
       +
       [orderings, jobs] = String.split(puzzle_input, "\n\n", parts: 2)

     

       27
       27
       +
       ```

     

       28
       28
       +
       

     

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

     

       30
       30
       +
       

     

       31
       31
       +
       ```

     

       32
       32
       +
       ["75|21\n28|29\n28|73\n95|48\n95|19\n95|16\n81|51\n81|95\n81|16\n81|56\n48|59\n48|83\n48|64\n48|57\n48|86\n15|43\n15|82\n15|49\n15|31\n15|35\n15|48\n83|68\n83|26\n83|56\n83|63\n83|64\n83|69\n83|84\n47|83\n47|29\n47|23\n47|18\n47|87\n47|53\n47|79\n47|59\n35|43\n35|34\n35|85\n35|28\n35|64\n35|94\n35|48\n35|79\n35|78\n34|65\n34|88\n34|87\n34|82\n34|45\n34|76\n34|47\n34|39\n34|49\n34|85\n92|15\n92|35\n92|59\n92|69\n92|34\n92|67\n92|26\n92|18\n92|73\n92|84\n92|19\n94|47\n94|83\n94|82\n94|85\n94|57\n94|48\n94|64\n94|28\n94|43\n94|76\n94|49\n94|88\n29|59\n29|51\n29|15\n29|73\n29|89\n29|66\n29|76\n29|75\n29|63\n29|53\n29|18\n29|62\n29|95\n69|94\n69|56\n69|66\n69|43\n69|85\n69|63\n69|82\n69|57\n69|78\n69|15\n69|34\n69|31\n69|35\n69|16\n63|78\n63|65\n63|43\n63|27\n63|66\n63|23\n63|62\n63|35\n63|34\n63|48\n63|56\n63|19\n63|94\n63|85\n63|57\n31|92\n31|28\n31|53\n31|49\n31|64\n31|59\n31|26\n31|47\n31|23\n31|76\n31|89\n31|79\n31|81\n31|83\n31|86\n31|45\n56|86\n56|43\n56|65\n56|57\n56|82\n56|47\n56|85\n56|48\n56|62\n56|31\n56|78\n56|35\n56|16\n56|87\n56|23\n56|95\n56|34\n23|76\n23|29\n23|39\n23|53\n23|45\n23|26\n23|27\n23|28\n23|79\n23|21\n23|84\n23|83\n23|73\n23|86\n23|81\n23|59\n23|68\n23|89\n65|53\n65|48\n65|87\n65|88\n65|27\n65|28\n65|49\n65|45\n65|82\n65|43\n65|29\n65|39\n65|76\n65|85\n65|64\n65|23\n65|31\n65|79\n65|92\n45|68\n45|59\n45|69\n45|73\n45|53\n45|21\n45|81\n45|62\n45|56\n45|15\n45|95\n45|35\n45|63\n45|51\n45|26\n45|19\n45|92\n45|66\n45|89\n45|78\n76|73\n76|51\n76|18\n76|75\n76|95\n76|66\n76|56\n76|69\n76|81\n76|21\n76|67\n76|26\n76|53\n76|92\n76|89\n76|35\n76|63\n76|19\n76|62\n76|59\n76|45\n53|92\n53|21\n53|18\n53|94\n53|67\n53|68\n53|69\n53|63\n53|66\n53|84\n53|34\n53|59\n53|89\n53|73\n53|78\n53|81\n53|19\n53|35\n53|26\n53|56\n53|15\n53|51\n51|47\n51|15\n51|69\n51|65\n51|94\n51|66\n51|31\n51|95\n51|43\n51|35\n51|78\n51|82\n51|85\n51|48\n51|23\n51|63\n51|34\n51|16\n51|88\n51|67\n51|62\n51|19\n51|56\n79|84\n79|28\n79|69\n79|45\n79|92\n79|83\n79|29\n79|53\n79|64\n79|76\n79|89\n79|51\n79|68\n79|39\n79|26\n79|81\n79|21\n79|63\n79|62\n79|59\n79|75\n79|56\n79|73\n79|18\n19|35\n19|48\n19|82\n19|94\n19|57\n19|78\n19|43\n19|79\n19|83\n19|31\n19|64\n19|23\n19|47\n19|67\n19|28\n19|85\n19|27\n19|86\n19|34\n19|65\n19|87\n19|88\n19|16\n19|49\n82|27\n82|68\n82|83\n82|39\n82|28\n82|73\n82|92\n82|49\n82|75\n82|89\n82|31\n82|45\n82|47\n82|18\n82|87\n82|53\n82|79\n82|23\n82|86\n82|81\n82|29\n82|59\n82|64\n82|76\n21|34\n21|19\n21|78\n21|57\n21|82\n21|51\n21|66\n21|35\n21|95\n21|62\n21|48\n21|84\n21|65\n21|69\n21|31\n21|56\n21|15\n21|67\n21|85\n21|16\n21|88\n21|94\n21|63\n21|43\n88|27\n88|29\n88|64\n88|75\n88|31\n88|59\n88|76\n88|39\n88|47\n88|28\n88|87\n88|23\n88|83\n88|81\n88|53\n88|86\n88|45\n88|18\n88|92\n88|79\n88|49\n88|57\n88|82\n88|89\n86|18\n86|28\n86|73\n86|75\n86|59\n86|26\n86|21\n86|69\n86|76\n86|79\n86|51\n86|92\n86|45\n86|83\n86|64\n86|49\n86|81\n86|68\n86|39\n86|53\n86|29\n86|84\n86|63\n86|89\n43|59\n43|64\n43|87\n43|47\n43|49\n43|57\n43|31\n43|86\n43|39\n43|27\n43|53\n43|88\n43|83\n43|89\n43|81\n43|79\n43|75\n43|82\n43|23\n43|76\n43|29\n43|28\n43|92\n43|45\n26|15\n26|82\n26|78\n26|67\n26|57\n26|88\n26|35\n26|43\n26|85\n26|21\n26|48\n26|84\n26|69\n26|62\n26|34\n26|19\n26|66\n26|65\n26|51\n26|16\n26|95\n26|94\n26|63\n26|56\n68|85\n68|65\n68|95\n68|35\n68|78\n68|67\n68|57\n68|51\n68|62\n68|56\n68|34\n68|21\n68|63\n68|88\n68|15\n68|48\n68|43\n68|26\n68|66\n68|84\n68|94\n68|19\n68|69\n68|16\n85|64\n85|27\n85|82\n85|43\n85|53\n85|48\n85|57\n85|86\n85|88\n85|29\n85|47\n85|87\n85|83\n85|75\n85|76\n85|28\n85|81\n85|49\n85|45\n85|39\n85|92\n85|31\n85|23\n85|79\n39|84\n39|76\n39|59\n39|67\n39|62\n39|92\n39|81\n39|69\n39|66\n39|26\n39|15\n39|75\n39|95\n39|63\n39|21\n39|73\n39|45\n39|51\n39|89\n39|53\n39|56\n39|68\n39|19\n39|18\n78|48\n78|87\n78|34\n78|29\n78|28\n78|79\n78|76\n78|43\n78|39\n78|85\n78|88\n78|49\n78|27\n78|86\n78|94\n78|64\n78|31\n78|83\n78|82\n78|16\n78|23\n78|47\n78|65\n78|57\n87|83\n87|26\n87|51\n87|29\n87|79\n87|45\n87|68\n87|75\n87|73\n87|21\n87|53\n87|81\n87|84\n87|39\n87|89\n87|92\n87|76\n87|59\n87|18\n87|86\n87|69\n87|49\n87|64\n87|28\n18|69\n18|95\n18|73\n18|16\n18|48\n18|21\n18|68\n18|85\n18|62\n18|34\n18|19\n18|65\n18|15\n18|94\n18|63\n18|51\n18|66\n18|84\n18|67\n18|43\n18|35\n18|26\n18|56\n18|78\n84|95\n84|62\n84|48\n84|35\n84|57\n84|31\n84|16\n84|78\n84|65\n84|88\n84|67\n84|34\n84|19\n84|43\n84|69\n84|15\n84|94\n84|63\n84|51\n84|66\n84|47\n84|56\n84|85\n84|82\n59|34\n59|69\n59|89\n59|19\n59|62\n59|84\n59|68\n59|73\n59|26\n59|66\n59|94\n59|67\n59|21\n59|85\n59|18\n59|95\n59|16\n59|15\n59|63\n59|56\n59|35\n59|51\n59|78\n59|65\n67|88\n67|27\n67|16\n67|28\n67|79\n67|64\n67|65\n67|29\n67|47\n67|83\n67|34\n67|48\n67|49\n67|43\n67|94\n67|23\n67|85\n67|35\n67|31\n67|82\n67|57\n67|87\n67|8" <> ...,

     

       33
       33
       +
        "94,68,73,78,15,65,43,66,62\n34,65,85,48,82,47,23,87,49,79,83,28,29\n57,82,27,87,83,28,29,39,76,45,75,53,92,81,18\n29,86,68,39,81,45,75,76,31,53,64,23,92\n31,28,83,49,87,79,82,64,16,48,86\n45,89,73,53,59,68,28,83,86,79,69,76,39\n31,19,88,35,23,43,86,79,48,16,57,82,27,87,67,65,78,34,49,47,66\n31,47,23,27,87,49,79,83,28,64,29,76,45,75,53,81,59,89,18,73,68\n26,95,73,56,81,89,59,34,92,94,21\n16,63,34,19,66,65,47,56,31,82,51,85,57,67,88,62,48,78,95,35,15\n62,15,66,95,19,67,35,78,94,16,65,48,43,88,82,31,47,23,27,87,86\n62,15,66,95,67,35,34,16,65,43,88,82,31,47,86\n28,68,83,31,59,89,29,73,39,75,92,86,76,45,49,64,18,81,87,27,79,23,47\n81,78,26,16,59,62,51,19,21,56,68,94,18,73,69,35,89,84,66\n83,76,75,53,92,81,73,26,63,56,62\n53,27,29,79,28,88,85,31,47\n29,75,43,31,83,57,49,27,48,64,23,87,86,76,79,53,45\n63,27,43,95,78,56,34\n83,59,89,81,18,84,68,76,69,26,62,63,56,75,73,92,64,53,28,51,29\n75,53,92,18,73,68,26,51,69,63,15,19,67,35,78\n48,31,23,27,87,86,28,64,29,76,75\n16,51,62,43,15,68,78,65,88,19,34,85,26,48,95,94,67,56,84,69,66\n65,82,23,87,86,75,48,49,31,16,57,45,43,47,29\n29,76,45,75,81,18,73,21,56,62,95\n18,67,21,15,63,59,84,66,69,26,34,68,35,95,81,92,19\n49,79,39,76,53,92,59,89,18,68,51,69,63\n85,15,43,62,84,88,57,16,31,95,69\n21,51,43,16,94,78,19\n87,86,49,79,83,28,39,76,45,53,92,89,18,68,26,21,51\n51,69,62,35,88,15,16,21,48,57,26,78,65,43,34,95,19\n49,78,16,94,31,23,65\n87,83,29,45,59,73,51\n34,94,16,85,48,43,88,57,82,23,87,86,79,83,28,29,76\n84,51,69,63,56,62,15,66,95,19,67,35,78,34,94,85,43,88,57,82,31\n53,69,49,84,51,89,28,63,29\n83,21,64,68,75,59,87,45,76,23,29,73,18,27,28,81,26,53,86,89,39,92,79\n62,15,67,35,16,43,86\n88,31,23,83,39\n27,87,86,49,83,64,39,76,75,53,89,73,26,21,84\n53,81,21,51,63,15,95,35,34\n95,51,31,84,15,94,43\n92,76,59,63,73,64,84,81,28,75,15,29,68,62,69\n89,18,62,15,94,65,85\n92,68,63,95,67,78,94\n94,68,95,84,16,63,15,35,26,34,62,73,19,51,56,67,18,21,69,65,66,59,78\n35,34,16,65,48,27,86,83,29\n15,66,95,67,34,94,85,48,43,82,23\n69,63,56,66,95,19,67,35,78,34,94,16,65,85,48,43,23\n85,27,66,19,43,62,86\n65,85,48,43,82,31,47,49,79,28,39,76,45,75,53\n86,49,79,64,39,76,45,75,59,89,84,51,69\n92,81,59,89,18,73,26,21,84,51,69,63,56,62,15,66,95,19,67,35,78,34,94\n26,84,69,63,56,62,66,19,67,78,34,94,16,85,43,88,57\n21,89,19,84,94,35,68,65,18,51,16,63,59,67,34,56,73,78,15,69,95,66,26\n83,23,39,27,76,47,49,29,48,86,82,53,88,64,92,75,81,45,31,43,57\n34,94,16,65,48,57,82,31,23,27,83,28,76\n95,51,62,63,16,34,65,66,69,19,57,82,47\n82,57,84,65,78,31,16,67,66\n64,39,92,81,89,69,66\n59,95,18,68,15,34,35,51,19,92,66,56,94,81,73,62,78\n83,28,64,29,39,76,45,75,53,92,81,89,73,68,26,21,51,69,63,56,62\n66,73,39,64,56,76,59\n68,26,69,56,85,43,88\n67,35,78,94,16,65,48,88,57,82,47,23,49,79,83,28,64\n92,81,26,51,69,63,62,15,95,19,78,34,94\n81,59,73,68,26,51,63,56,15,95,35,34,16\n79,83,64,45,53,81,68,26,84,51,69,63,56\n89,53,84,39,62,63,51,75,64,81,26,18,69,83,45,29,56\n82,87,39,88,23,57,48,85,76,83,92,47,43\n48,43,57,27,87,79,83,76,45,75,53,92,81\n82,81,75,39,88\n43,88,57,82,31,47,23,27,87,86,49,79,83,28,64,29,39,76,45,75,53,81,59\n88,87,86,49,79,83,28,39,76,45,92,81,89\n59,76,29,23,89,79,31,73,45,82,87,92,86\n66,95,19,67,35,78,34,94,16,85,48,43,88,57,82,31,47,23,27,87,86,49,79\n23,27,86,79,83,28,64,29,39,76,45,92,59,89,73,68,21\n23,31,39,53,89,64,79,73,59,45,92\n63,85,66,35,65,15,31,62,95\n35,88,31,78,23,87,15,49,95,27,57\n79,83,28,64,29,76,45,75,53,92,81,59,89,68,26,21,51,69,63\n43,16,73,34,19,66,62\n84,51,56,62,95,67,78,34,85,48,57,82,31\n76,45,75,53,92,81,59,18,73,26,21,51,69,63,56,15,66,95,19\n49,79,83,28,64,29,39,45,75,53,92,81,59,89,18,73,68,26,21,84,51,69,63\n63,51,34,19,15,65,31,57,48,95,88,66,56,67,62,16,35,94,78,84,43\n45,48,83,43,65,29,94,82,76,23,39\n83,49,47,45,88,64,85,28,27\n31,19,35,16,49,88,65,43,48,83,94,67,28\n84,65,88,51,85,43,78,19,21,69,48,66,15,35,68\n21,15,66,19,35,78,94,16,65,88,57\n19,67,78,34,94,65,85,48,43,88,57,47,23,27,87,86,49,83,28\n67,82,87,48,23,65,43,19,95,56,66,35,16\n88,82,31,47,23,27,87,86,49,79,83,28,64,29,39,76,45,53,81,59,89\n92,81,59,73,68,26,21,84,51,69,63,56,15,66,95,19,67,35,78,34,94\n79,76,29,21,68,86,83,53,59,26,49,89,27,87,45,28,81\n49,79,83,28,64,29,39,76,45,75,53,92,81,59,8" <> ...]

     

       34
       34
       +
       ```

     

       35
       35
       +
       

     

       36
       36
       +
       ```elixir

     

       37
       37
       +
       orderings =

     

       38
       38
       +
         orderings

     

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

     

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

     

       41
       41
       +
           row

     

       42
       42
       +
           |> String.split("|")

     

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

     

       44
       44
       +
           |> List.to_tuple()

     

       45
       45
       +
         end)

     

       46
       46
       +
       

     

       47
       47
       +
       prev =

     

       48
       48
       +
         orderings

     

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

     

       50
       50
       +
       ```

     

       51
       51
       +
       

     

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

     

       53
       53
       +
       

     

       54
       54
       +
       ```

     

       55
       55
       +
       %{

     

       56
       56
       +
         73 => [28, 92, 29, 23, 45, 76, 53, 79, 82, 86, 39, 87, 18, 59, 57, 64, 89, 49, 27, 75, 81, 83, 47,

     

       57
       57
       +
          31],

     

       58
       58
       +
         23 => [47, 63, 31, 56, 65, 51, 19, 82, 88, 43, 85, 78, 67, 57, 16, 62, 66, 95, 48, 15, 35, 34, 94,

     

       59
       59
       +
          69],

     

       60
       60
       +
         29 => [28, 47, 23, 65, 79, 82, 88, 86, 43, 85, 78, 87, 67, 57, 64, 16, 49, 27, 48, 83, 35, 34, 94,

     

       61
       61
       +
          31],

     

       62
       62
       +
         47 => [34, 94, 31, 56, 51, 19, 82, 88, 43, 85, 78, 84, 67, 57, 16, 62, 66, 95, 48, 15, 35, 69, 63,

     

       63
       63
       +
          65],

     

       64
       64
       +
         89 => [29, 31, 23, 45, 76, 53, 79, 82, 88, 86, 43, 39, 87, 59, 57, 64, 49, 27, 75, 28, 81, 83, 47,

     

       65
       65
       +
          92],

     

       66
       66
       +
         43 => [15, 35, 94, 69, 63, 56, 65, 51, 19, 21, 26, 68, 85, 78, 18, 84, 67, 73, 16, 62, 66, 95, 48,

     

       67
       67
       +
          34],

     

       68
       68
       +
         39 => [34, 23, 65, 79, 82, 88, 86, 43, 85, 78, 87, 57, 64, 16, 49, 27, 28, 48, 83, 47, 35, 94, 29,

     

       69
       69
       +
          31],

     

       70
       70
       +
         45 => [34, 31, 23, 65, 76, 79, 82, 88, 86, 43, 85, 39, 87, 57, 64, 16, 49, 27, 28, 48, 83, 47, 94,

     

       71
       71
       +
          29],

     

       72
       72
       +
         48 => [95, 15, 35, 94, 63, 56, 65, 51, 19, 21, 26, 68, 85, 78, 18, 84, 67, 73, 16, 89, 62, 66, 34,

     

       73
       73
       +
          69],

     

       74
       74
       +
         57 => [48, 94, 69, 63, 56, 19, 21, 88, 43, 26, 68, 85, 78, 84, 67, 16, 62, 66, 95, 15, 35, 34, 65,

     

       75
       75
       +
          51],

     

       76
       76
       +
         26 => [83, 92, 31, 23, 45, 76, 53, 79, 86, 68, 39, 87, 18, 59, 73, 64, 89, 49, 27, 75, 28, 81, 47,

     

       77
       77
       +
          29],

     

       78
       78
       +
         69 => [83, 92, 45, 76, 53, 51, 79, 21, 86, 26, 68, 39, 87, 18, 84, 59, 73, 64, 89, 49, 75, 28, 81,

     

       79
       79
       +
          29],

     

       80
       80
       +
         88 => [34, 94, 65, 51, 19, 21, 43, 26, 68, 85, 78, 84, 67, 73, 16, 62, 66, 95, 48, 15, 35, 69, 63,

     

       81
       81
       +
          56],

     

       82
       82
       +
         63 => [83, 29, 69, 45, 76, 53, 51, 79, 21, 86, 26, 68, 39, 18, 84, 59, 73, 64, 89, 49, 75, 28, 81,

     

       83
       83
       +
          92],

     

       84
       84
       +
         31 => [15, 69, 56, 65, 51, 19, 82, 21, 88, 43, 85, 78, 84, 67, 57, 16, 62, 66, 95, 48, 35, 34, 94,

     

       85
       85
       +
          63],

     

       86
       86
       +
         81 => [31, 23, 45, 76, 53, 79, 82, 88, 86, 43, 85, 39, 87, 57, 64, 49, 27, 75, 28, 48, 83, 47, 92,

     

       87
       87
       +
          29],

     

       88
       88
       +
         76 => [34, 94, 29, 31, 23, 65, 79, 82, 88, 86, 43, 85, 39, 78, 87, 57, 64, 16, 49, 27, 28, 48, 83,

     

       89
       89
       +
          47],

     

       90
       90
       +
         34 => [35, 92, 69, 63, 56, 53, 51, 19, 21, 26, 68, 78, 18, 84, 59, 67, 73, 89, 62, 66, 75, 95, 81,

     

       91
       91
       +
          15],

     

       92
       92
       +
         28 => [35, 94, 31, 23, 65, 79, 19, 82, 88, 86, 43, 85, 78, 87, 67, 57, 16, 49, 27, 95, 48, 83, 47,

     

       93
       93
       +
          34],

     

       94
       94
       +
         85 => [35, 34, 94, 69, 63, 56, 65, 51, 19, 21, 26, 68, 78, 18, 84, 59, 67, 73, 16, 89, 62, 66, 95,

     

       95
       95
       +
          15],

     

       96
       96
       +
         64 => [48, 83, 35, 94, 31, 65, 79, 19, 82, 88, 86, 43, 85, 78, 87, 67, 57, 16, 49, 27, 28, 47, 34,

     

       97
       97
       +
          23],

     

       98
       98
       +
         68 => [83, 23, 45, 53, 79, 82, 86, 39, 87, 18, 59, 73, 64, 89, 49, 27, 75, 28, 81, 47, 92, 29, 31,

     

       99
       99
       +
          76],

     

       100
       100
       +
         86 => [48, 31, 56, 23, 19, 82, 88, 43, 85, 78, 87, 67, 57, 16, 27, 62, 66, 95, 15, 47, 35, 34, 94,

     

       101
       101
       +
          65],

     

       102
       102
       +
         51 => [81, 29, 45, 76, 53, 79, 21, 86, 26, 68, 39, 87, 18, 84, 59, 73, 64, 89, 49, 27, 75, 28, 83,

     

       103
       103
       +
          92],

     

       104
       104
       +
         59 => [48, 47, 92, 29, 31, 23, 45, 76, 53, 79, 82, 88, 86, 43, 39, 87, 57, 64, 49, 27, 75, 28, 81,

     

       105
       105
       +
          83],

     

       106
       106
       +
         95 => [81, 29, 56, 45, 76, 51, 21, 26, 68, 39, 18, 84, 59, 73, 64, 89, 62, 66, 75, 15, 92, 69, 63,

     

       107
       107
       +
          53],

     

       108
       108
       +
         78 => [35, 69, 63, 56, 45, 53, 51, 19, 21, 26, 68, 18, 84, 59, 67, 73, 89, 62, 66, 75, 95, 81, 15,

     

       109
       109
       +
          ...],

     

       110
       110
       +
         15 => [92, 29, 69, 45, 53, 51, 21, 26, 68, 39, 18, 84, 59, 73, 64, 89, 62, 75, 28, 81, 83, 63,

     

       111
       111
       +
          ...],

     

       112
       112
       +
         83 => [48, 47, 94, 31, 23, 79, 19, 82, 88, 86, 43, 85, 78, 87, 67, 57, 16, 49, 27, 66, 95, ...],

     

       113
       113
       +
         75 => [29, 76, 79, 82, 88, 86, 43, 85, 39, 87, 57, 64, 16, 49, 27, 28, 48, 83, 47, 94, ...],

     

       114
       114
       +
         87 => [47, 34, 56, 65, 19, 82, 88, 43, 85, 78, 67, 57, 16, 27, 62, 66, 95, 48, 15, ...],

     

       115
       115
       +
         21 => [75, 23, 45, 76, 53, 79, 86, 26, 68, 39, 87, 18, 59, 73, 64, 89, 49, 27, ...],

     

       116
       116
       +
         82 => [15, 34, 94, 69, 56, 65, 51, 19, 21, 88, 43, 26, 85, 78, 84, 67, 57, ...],

     

       117
       117
       +
         53 => [47, 29, 31, 23, 65, 45, 76, 79, 82, 88, 86, 43, 85, 39, 87, 57, ...],

     

       118
       118
       +
         66 => [29, 69, 63, 45, 76, 53, 51, 21, 26, 68, 39, 18, 84, 59, 73, ...],

     

       119
       119
       +
         35 => [15, 92, 69, 63, 56, 45, 76, 53, 51, 19, 21, 26, 68, 18, ...],

     

       120
       120
       +
         56 => [81, 83, 69, 63, 45, 76, 53, 51, 79, 21, 26, 68, 39, ...],

     

       121
       121
       +
         62 => [29, 63, 56, 45, 76, 51, 79, 21, 26, 68, 39, 18, ...],

     

       122
       122
       +
         49 => [15, 34, 94, 31, 65, 19, 82, 88, 86, 43, 85, ...],

     

       123
       123
       +
         27 => [63, 23, 65, 19, 82, 88, 43, 85, 78, 67, ...],

     

       124
       124
       +
         84 => [83, 92, 23, 53, 79, 21, 86, 26, 68, ...],

     

       125
       125
       +
         94 => [35, 69, 63, 53, 51, 19, 21, 26, ...],

     

       126
       126
       +
         92 => [31, 65, 45, 76, 53, 79, 82, ...],

     

       127
       127
       +
         19 => [95, 92, 63, 45, 76, 53, ...],

     

       128
       128
       +
         67 => [92, 76, 53, 51, 19, ...],

     

       129
       129
       +
         65 => [34, 63, 56, 51, ...],

     

       130
       130
       +
         18 => [47, 92, 29, ...],

     

       131
       131
       +
         79 => [47, 35, ...],

     

       132
       132
       +
         16 => [95, ...]

     

       133
       133
       +
       }

     

       134
       134
       +
       ```

     

       135
       135
       +
       

     

       136
       136
       +
       ```elixir

     

       137
       137
       +
       jobs =

     

       138
       138
       +
         jobs

     

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

     

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

     

       141
       141
       +
           row

     

       142
       142
       +
           |> String.split(",")

     

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

     

       144
       144
       +
         end)

     

       145
       145
       +
       ```

     

       146
       146
       +
       

     

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

     

       148
       148
       +
       

     

       149
       149
       +
       ```

     

       150
       150
       +
       [

     

       151
       151
       +
         [94, 68, 73, 78, 15, 65, 43, 66, 62],

     

       152
       152
       +
         [34, 65, 85, 48, 82, 47, 23, 87, 49, 79, 83, 28, 29],

     

       153
       153
       +
         [57, 82, 27, 87, 83, 28, 29, 39, 76, 45, 75, 53, 92, 81, 18],

     

       154
       154
       +
         [29, 86, 68, 39, 81, 45, 75, 76, 31, 53, 64, 23, 92],

     

       155
       155
       +
         [31, 28, 83, 49, 87, 79, 82, 64, 16, 48, 86],

     

       156
       156
       +
         [45, 89, 73, 53, 59, 68, 28, 83, 86, 79, 69, 76, 39],

     

       157
       157
       +
         [31, 19, 88, 35, 23, 43, 86, 79, 48, 16, 57, 82, 27, 87, 67, 65, 78, 34, 49, 47, 66],

     

       158
       158
       +
         [31, 47, 23, 27, 87, 49, 79, 83, 28, 64, 29, 76, 45, 75, 53, 81, 59, 89, 18, 73, 68],

     

       159
       159
       +
         [26, 95, 73, 56, 81, 89, 59, 34, 92, 94, 21],

     

       160
       160
       +
         [16, 63, 34, 19, 66, 65, 47, 56, 31, 82, 51, 85, 57, 67, 88, 62, 48, 78, 95, 35, 15],

     

       161
       161
       +
         [62, 15, 66, 95, 19, 67, 35, 78, 94, 16, 65, 48, 43, 88, 82, 31, 47, 23, 27, 87, 86],

     

       162
       162
       +
         [62, 15, 66, 95, 67, 35, 34, 16, 65, 43, 88, 82, 31, 47, 86],

     

       163
       163
       +
         [28, 68, 83, 31, 59, 89, 29, 73, 39, 75, 92, 86, 76, 45, 49, 64, 18, 81, 87, 27, 79, 23, 47],

     

       164
       164
       +
         [81, 78, 26, 16, 59, 62, 51, 19, 21, 56, 68, 94, 18, 73, 69, 35, 89, 84, 66],

     

       165
       165
       +
         [83, 76, 75, 53, 92, 81, 73, 26, 63, 56, 62],

     

       166
       166
       +
         [53, 27, 29, 79, 28, 88, 85, 31, 47],

     

       167
       167
       +
         [29, 75, 43, 31, 83, 57, 49, 27, 48, 64, 23, 87, 86, 76, 79, 53, 45],

     

       168
       168
       +
         ~c"?\e+_N8\"",

     

       169
       169
       +
         [83, 59, 89, 81, 18, 84, 68, 76, 69, 26, 62, 63, 56, 75, 73, 92, 64, 53, 28, 51, 29],

     

       170
       170
       +
         [75, 53, 92, 18, 73, 68, 26, 51, 69, 63, 15, 19, 67, 35, 78],

     

       171
       171
       +
         [48, 31, 23, 27, 87, 86, 28, 64, 29, 76, 75],

     

       172
       172
       +
         [16, 51, 62, 43, 15, 68, 78, 65, 88, 19, 34, 85, 26, 48, 95, 94, 67, 56, 84, 69, 66],

     

       173
       173
       +
         [65, 82, 23, 87, 86, 75, 48, 49, 31, 16, 57, 45, 43, 47, 29],

     

       174
       174
       +
         [29, 76, 45, 75, 81, 18, 73, 21, 56, 62, 95],

     

       175
       175
       +
         [18, 67, 21, 15, 63, 59, 84, 66, 69, 26, 34, 68, 35, 95, 81, 92, 19],

     

       176
       176
       +
         [49, 79, 39, 76, 53, 92, 59, 89, 18, 68, 51, 69, 63],

     

       177
       177
       +
         [85, 15, 43, 62, 84, 88, 57, 16, 31, 95, 69],

     

       178
       178
       +
         [21, 51, 43, 16, 94, 78, 19],

     

       179
       179
       +
         [87, 86, 49, 79, 83, 28, 39, 76, 45, 53, 92, 89, 18, 68, 26, 21, 51],

     

       180
       180
       +
         [51, 69, 62, 35, 88, 15, 16, 21, 48, 57, 26, 78, 65, 43, 34, 95, 19],

     

       181
       181
       +
         [49, 78, 16, 94, 31, 23, 65],

     

       182
       182
       +
         [87, 83, 29, 45, 59, 73, 51],

     

       183
       183
       +
         [34, 94, 16, 85, 48, 43, 88, 57, 82, 23, 87, 86, 79, 83, 28, 29, 76],

     

       184
       184
       +
         [84, 51, 69, 63, 56, 62, 15, 66, 95, 19, 67, 35, 78, 34, 94, 85, ...],

     

       185
       185
       +
         [53, 69, 49, 84, 51, 89, 28, 63, 29],

     

       186
       186
       +
         [83, 21, 64, 68, 75, 59, 87, 45, 76, 23, 29, 73, 18, 27, ...],

     

       187
       187
       +
         [62, 15, 67, 35, 16, 43, 86],

     

       188
       188
       +
         [88, 31, 23, 83, 39],

     

       189
       189
       +
         [27, 87, 86, 49, 83, 64, 39, 76, 75, 53, 89, ...],

     

       190
       190
       +
         [53, 81, 21, 51, 63, 15, 95, 35, 34],

     

       191
       191
       +
         [95, 51, 31, 84, 15, 94, 43],

     

       192
       192
       +
         [92, 76, 59, 63, 73, 64, 84, 81, ...],

     

       193
       193
       +
         [89, 18, 62, 15, 94, 65, 85],

     

       194
       194
       +
         ~c"\\D?_CN^",

     

       195
       195
       +
         [94, 68, 95, 84, 16, ...],

     

       196
       196
       +
         [35, 34, 16, 65, ...],

     

       197
       197
       +
         [15, 66, 95, ...],

     

       198
       198
       +
         [69, 63, ...],

     

       199
       199
       +
         [85, ...],

     

       200
       200
       +
         [...],

     

       201
       201
       +
         ...

     

       202
       202
       +
       ]

     

       203
       203
       +
       ```

     

       204
       204
       +
       

     

       205
       205
       +
       ```elixir

     

       206
       206
       +
       defmodule PrintQueue do

     

       207
       207
       +
         def valid?(input, prev), do: do_valid?([], input, prev)

     

       208
       208
       +
       

     

       209
       209
       +
         defp do_valid?(_, [], _prev), do: true

     

       210
       210
       +
         defp do_valid?(visited, [a | rest], prev) do

     

       211
       211
       +
           if Enum.any?(prev[a], & &1 in rest) do

     

       212
       212
       +
             false

     

       213
       213
       +
           else

     

       214
       214
       +
             do_valid?([a | visited], rest, prev)

     

       215
       215
       +
           end

     

       216
       216
       +
         end

     

       217
       217
       +
       

     

       218
       218
       +
         def middle(list) do

     

       219
       219
       +
           Enum.at(list, div(length(list), 2))

     

       220
       220
       +
         end

     

       221
       221
       +
       end

     

       222
       222
       +
       ```

     

       223
       223
       +
       

     

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

     

       225
       225
       +
       

     

       226
       226
       +
       ```

     

       227
       227
       +
       {:module, PrintQueue, <<70, 79, 82, 49, 0, 0, 10, ...>>, {:middle, 1}}

     

       228
       228
       +
       ```

     

       229
       229
       +
       

     

       230
       230
       +
       ```elixir

     

       231
       231
       +
       {valid, invalid} = Enum.split_with(jobs, &PrintQueue.valid?(&1, prev))

     

       232
       232
       +
       ```

     

       233
       233
       +
       

     

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

     

       235
       235
       +
       

     

       236
       236
       +
       ```

     

       237
       237
       +
       {[

     

       238
       238
       +
          [34, 65, 85, 48, 82, 47, 23, 87, 49, 79, 83, 28, 29],

     

       239
       239
       +
          [57, 82, 27, 87, 83, 28, 29, 39, 76, 45, 75, 53, 92, 81, 18],

     

       240
       240
       +
          [31, 47, 23, 27, 87, 49, 79, 83, 28, 64, 29, 76, 45, 75, 53, 81, 59, 89, 18, 73, 68],

     

       241
       241
       +
          [62, 15, 66, 95, 19, 67, 35, 78, 94, 16, 65, 48, 43, 88, 82, 31, 47, 23, 27, 87, 86],

     

       242
       242
       +
          [62, 15, 66, 95, 67, 35, 34, 16, 65, 43, 88, 82, 31, 47, 86],

     

       243
       243
       +
          [83, 76, 75, 53, 92, 81, 73, 26, 63, 56, 62],

     

       244
       244
       +
          [75, 53, 92, 18, 73, 68, 26, 51, 69, 63, 15, 19, 67, 35, 78],

     

       245
       245
       +
          [48, 31, 23, 27, 87, 86, 28, 64, 29, 76, 75],

     

       246
       246
       +
          [29, 76, 45, 75, 81, 18, 73, 21, 56, 62, 95],

     

       247
       247
       +
          [49, 79, 39, 76, 53, 92, 59, 89, 18, 68, 51, 69, 63],

     

       248
       248
       +
          [87, 86, 49, 79, 83, 28, 39, 76, 45, 53, 92, 89, 18, 68, 26, 21, 51],

     

       249
       249
       +
          [87, 83, 29, 45, 59, 73, 51],

     

       250
       250
       +
          [34, 94, 16, 85, 48, 43, 88, 57, 82, 23, 87, 86, 79, 83, 28, 29, 76],

     

       251
       251
       +
          [84, 51, 69, 63, 56, 62, 15, 66, 95, 19, 67, 35, 78, 34, 94, 85, 43, 88, 57, 82, 31],

     

       252
       252
       +
          [62, 15, 67, 35, 16, 43, 86],

     

       253
       253
       +
          [88, 31, 23, 83, 39],

     

       254
       254
       +
          [27, 87, 86, 49, 83, 64, 39, 76, 75, 53, 89, 73, 26, 21, 84],

     

       255
       255
       +
          [53, 81, 21, 51, 63, 15, 95, 35, 34],

     

       256
       256
       +
          [89, 18, 62, 15, 94, 65, 85],

     

       257
       257
       +
          ~c"\\D?_CN^",

     

       258
       258
       +
          [35, 34, 16, 65, 48, 27, 86, 83, 29],

     

       259
       259
       +
          [15, 66, 95, 67, 34, 94, 85, 48, 43, 82, 23],

     

       260
       260
       +
          [69, 63, 56, 66, 95, 19, 67, 35, 78, 34, 94, 16, 65, 85, 48, 43, 23],

     

       261
       261
       +
          [65, 85, 48, 43, 82, 31, 47, 49, 79, 28, 39, 76, 45, 75, 53],

     

       262
       262
       +
          ~c"V1O@'L-K;YT3E",

     

       263
       263
       +
          [92, 81, 59, 89, 18, 73, 26, 21, 84, 51, 69, 63, 56, 62, 15, 66, 95, 19, 67, 35, 78, 34, 94],

     

       264
       264
       +
          [26, 84, 69, 63, 56, 62, 66, 19, 67, 78, 34, 94, 16, 85, 43, 88, 57],

     

       265
       265
       +
          [34, 94, 16, 65, 48, 57, 82, 31, 23, 27, 83, 28, 76],

     

       266
       266
       +
          ~c"@'\\QYEB",

     

       267
       267
       +
          [83, 28, 64, 29, 39, 76, 45, 75, 53, 92, 81, 89, 73, 68, 26, 21, 51, 69, 63, ...],

     

       268
       268
       +
          [68, 26, 69, 56, 85, 43, 88],

     

       269
       269
       +
          [67, 35, 78, 94, 16, 65, 48, 88, 57, 82, 47, 23, 49, 79, 83, 28, 64],

     

       270
       270
       +
          [92, 81, 26, 51, 69, 63, 62, 15, 95, 19, 78, 34, 94],

     

       271
       271
       +
          [81, 59, 73, 68, 26, 51, 63, 56, 15, 95, 35, 34, 16],

     

       272
       272
       +
          [79, 83, 64, 45, 53, 81, 68, 26, 84, 51, 69, 63, 56],

     

       273
       273
       +
          ~c"0+9\eWOSL-K5\\Q",

     

       274
       274
       +
          [43, 88, 57, 82, 31, 47, 23, 27, 87, 86, 49, 79, ...],

     

       275
       275
       +
          [88, 87, 86, 49, 79, 83, 28, 39, 76, 45, 92, ...],

     

       276
       276
       +
          [66, 95, 19, 67, 35, 78, 34, 94, 16, 85, ...],

     

       277
       277
       +
          [23, 27, 86, 79, 83, 28, 64, 29, 39, ...],

     

       278
       278
       +
          [79, 83, 28, 64, 29, 76, 45, 75, ...],

     

       279
       279
       +
          [84, 51, 56, 62, 95, 67, 78, ...],

     

       280
       280
       +
          [76, 45, 75, 53, 92, 81, ...],

     

       281
       281
       +
          [49, 79, 83, 28, 64, ...],

     

       282
       282
       +
          [21, 15, 66, 19, ...],

     

       283
       283
       +
          [19, 67, 78, ...],

     

       284
       284
       +
          [88, 82, ...],

     

       285
       285
       +
          [92, ...],

     

       286
       286
       +
          [...],

     

       287
       287
       +
          ...

     

       288
       288
       +
        ],

     

       289
       289
       +
        [

     

       290
       290
       +
          [94, 68, 73, 78, 15, 65, 43, 66, 62],

     

       291
       291
       +
          [29, 86, 68, 39, 81, 45, 75, 76, 31, 53, 64, 23, 92],

     

       292
       292
       +
          [31, 28, 83, 49, 87, 79, 82, 64, 16, 48, 86],

     

       293
       293
       +
          [45, 89, 73, 53, 59, 68, 28, 83, 86, 79, 69, 76, 39],

     

       294
       294
       +
          [31, 19, 88, 35, 23, 43, 86, 79, 48, 16, 57, 82, 27, 87, 67, 65, 78, 34, 49, 47, 66],

     

       295
       295
       +
          [26, 95, 73, 56, 81, 89, 59, 34, 92, 94, 21],

     

       296
       296
       +
          [16, 63, 34, 19, 66, 65, 47, 56, 31, 82, 51, 85, 57, 67, 88, 62, 48, 78, 95, 35, 15],

     

       297
       297
       +
          [28, 68, 83, 31, 59, 89, 29, 73, 39, 75, 92, 86, 76, 45, 49, 64, 18, 81, 87, 27, 79, 23, 47],

     

       298
       298
       +
          [81, 78, 26, 16, 59, 62, 51, 19, 21, 56, 68, 94, 18, 73, 69, 35, 89, 84, 66],

     

       299
       299
       +
          [53, 27, 29, 79, 28, 88, 85, 31, 47],

     

       300
       300
       +
          [29, 75, 43, 31, 83, 57, 49, 27, 48, 64, 23, 87, 86, 76, 79, 53, 45],

     

       301
       301
       +
          ~c"?\e+_N8\"",

     

       302
       302
       +
          [83, 59, 89, 81, 18, 84, 68, 76, 69, 26, 62, 63, 56, 75, 73, 92, 64, 53, 28, 51, 29],

     

       303
       303
       +
          [16, 51, 62, 43, 15, 68, 78, 65, 88, 19, 34, 85, 26, 48, 95, 94, 67, 56, 84, 69, 66],

     

       304
       304
       +
          [65, 82, 23, 87, 86, 75, 48, 49, 31, 16, 57, 45, 43, 47, 29],

     

       305
       305
       +
          [18, 67, 21, 15, 63, 59, 84, 66, 69, 26, 34, 68, 35, 95, 81, 92, 19],

     

       306
       306
       +
          [85, 15, 43, 62, 84, 88, 57, 16, 31, 95, 69],

     

       307
       307
       +
          [21, 51, 43, 16, 94, 78, 19],

     

       308
       308
       +
          [51, 69, 62, 35, 88, 15, 16, 21, 48, 57, 26, 78, 65, 43, 34, 95, 19],

     

       309
       309
       +
          [49, 78, 16, 94, 31, 23, 65],

     

       310
       310
       +
          [53, 69, 49, 84, 51, 89, 28, 63, 29],

     

       311
       311
       +
          [83, 21, 64, 68, 75, 59, 87, 45, 76, 23, 29, 73, 18, 27, 28, 81, 26, 53, 86, 89, 39, 92, 79],

     

       312
       312
       +
          [95, 51, 31, 84, 15, 94, 43],

     

       313
       313
       +
          [92, 76, 59, 63, 73, 64, 84, 81, 28, 75, 15, 29, 68, 62, 69],

     

       314
       314
       +
          [94, 68, 95, 84, 16, 63, 15, 35, 26, 34, 62, 73, 19, 51, 56, 67, 18, 21, 69, 65, 66, 59, 78],

     

       315
       315
       +
          [85, 27, 66, 19, 43, 62, 86],

     

       316
       316
       +
          [21, 89, 19, 84, 94, 35, 68, 65, 18, 51, 16, 63, 59, 67, 34, 56, 73, 78, 15, 69, 95, ...],

     

       317
       317
       +
          [83, 23, 39, 27, 76, 47, 49, 29, 48, 86, 82, 53, 88, 64, 92, 75, 81, 45, 31, 43, ...],

     

       318
       318
       +
          [95, 51, 62, 63, 16, 34, 65, 66, 69, 19, 57, 82, 47],

     

       319
       319
       +
          [82, 57, 84, 65, 78, 31, 16, 67, 66],

     

       320
       320
       +
          [59, 95, 18, 68, 15, 34, 35, 51, 19, 92, 66, 56, 94, 81, 73, 62, 78],

     

       321
       321
       +
          ~c"BI'@8L;",

     

       322
       322
       +
          [89, 53, 84, 39, 62, 63, 51, 75, 64, 81, 26, 18, 69, 83, 45, ...],

     

       323
       323
       +
          [82, 87, 39, 88, 23, 57, 48, 85, 76, 83, 92, 47, 43],

     

       324
       324
       +
          ~c"RQK'X",

     

       325
       325
       +
          [59, 76, 29, 23, 89, 79, 31, 73, 45, 82, 87, 92, ...],

     

       326
       326
       +
          [23, 31, 39, 53, 89, 64, 79, 73, 59, 45, 92],

     

       327
       327
       +
          [63, 85, 66, 35, 65, 15, 31, 62, 95],

     

       328
       328
       +
          [35, 88, 31, 78, 23, 87, 15, 49, 95, ...],

     

       329
       329
       +
          [43, 16, 73, 34, 19, 66, 62],

     

       330
       330
       +
          [63, 51, 34, 19, 15, 65, 31, ...],

     

       331
       331
       +
          [45, 48, 83, 43, 65, 29, ...],

     

       332
       332
       +
          [83, 49, 47, 45, 88, ...],

     

       333
       333
       +
          [31, 19, 35, 16, ...],

     

       334
       334
       +
          [84, 65, 88, ...],

     

       335
       335
       +
          [67, 82, ...],

     

       336
       336
       +
          [79, ...],

     

       337
       337
       +
          [...],

     

       338
       338
       +
          ...

     

       339
       339
       +
        ]}

     

       340
       340
       +
       ```

     

       341
       341
       +
       

     

       342
       342
       +
       ## Part 1

     

       343
       343
       +
       

     

       344
       344
       +
       ```elixir

     

       345
       345
       +
       valid

     

       346
       346
       +
       |> Enum.map(&PrintQueue.middle/1)

     

       347
       347
       +
       |> Enum.sum()

     

       348
       348
       +
       ```

     

       349
       349
       +
       

     

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

     

       351
       351
       +
       

     

       352
       352
       +
       ```

     

       353
       353
       +
       6051

     

       354
       354
       +
       ```

     

       355
       355
       +
       

     

       356
       356
       +
       ## Part 2

     

       357
       357
       +
       

     

       358
       358
       +
       ```elixir

     

       359
       359
       +
       invalid

     

       360
       360
       +
       |> Enum.map(fn job ->

     

       361
       361
       +
         Enum.sort(job, fn a, b -> b in prev[a] end)

     

       362
       362
       +
       end)

     

       363
       363
       +
       |> Enum.map(&PrintQueue.middle/1)

     

       364
       364
       +
       |> Enum.sum()

     

       365
       365
       +
       ```

     

       366
       366
       +
       

     

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

     

       368
       368
       +
       

     

       369
       369
       +
       ```

     

       370
       370
       +
       5093

     

       371
       371
       +
       ```

     

       372
       372
       +
       

     

       373
       373
       +
       <!-- livebook:{"offset":27803,"stamp":{"token":"XCP.89VYFJDxWhhYqFwu165HzJaFBGbiSzyXWCSnD4rBE7dhN7HuS1Im6xp-8VPztVgcmSlMso948ZvV8MkBmy35qbTi8rDfbB5Zr2PQ-9P6LUjHMKF8Wu3IKPm7UjkY_cOiA6k","version":2}} -->

+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