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

+8 -6

2025/day01.livemd

···

       28
       28
        
         end)

     

       29
       29
        
       ```

     

       30
       30
        
       

     

       31
       31
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       32
       32
       +
       

     

       31
       33
        
       ## Part 1

     

       32
       34
        
       

     

       33
       35
        
       ```elixir

     

       34
       34
       -
       Enum.reduce(instructions, {50, 0}, fn {_rot, val}, {curr, sum} ->

     

       35
       35
       -
         next = Integer.mod(curr + val, 100)

     

       36
       36
       -
       

     

       37
       37
       -
         {next, sum + if(next == 0, do: 1, else: 0)}

     

       36
       36
       +
       Enum.scan(instructions, 50, fn {_rot, val}, curr ->

     

       37
       37
       +
         Integer.mod(curr + val, 100)

     

       38
       38
        
       end)

     

       39
       39
       -
       |> elem(1)

     

       39
       39
       +
       |> Enum.count(& &1 == 0)

     

       40
       40
        
       ```

     

       41
       41
       +
       

     

       42
       42
       +
       <!-- livebook:{"branch_parent_index":0} -->

     

       41
       43
        
       

     

       42
       44
        
       ## Part 2

     

       43
       45
        
       

     
···

       62
       64
        
       |> elem(1)

     

       63
       65
        
       ```

     

       64
       66
        
       

     

       65
       65
       -
       <!-- livebook:{"offset":1234,"stamp":{"token":"XCP.CwH20tHaK8kU6dohgq36CnaY2nnD-3NQc7aO6IAmymU5SEl9dLhm1IihwzVAgdcKHOfAxiDSdAIr5aTfqXWdOCvQRqJrJVUwuKBpAhQvvj9HOgnXBEgEvZz0r_CMSDSOvw","version":2}} -->

     

       67
       67
       +
       <!-- livebook:{"offset":1270,"stamp":{"token":"XCP.fAfBqYepop325WQHLC6mJPz_Wpl7bDiz0qRbslvjG31mRJWcHALfstxgj_iOj3nf9_GCzh_WmPiNR4MnzZidF2bz_zMMXHTEo18hp1z3gQDdi5hTSO8UG4YSYnUEtGxO2g","version":2}} -->

+6 -1

2025/day02.livemd

···

       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)

     

       27
       28
        
       ```

     

       28
       29
        
       

     

       29
       30
        
       ## Implementation

     
···

       59
       60
        
       end

     

       60
       61
        
       ```

     

       61
       62
        
       

     

       63
       63
       +
       <!-- livebook:{"branch_parent_index":1} -->

     

       64
       64
       +
       

     

       62
       65
        
       ## Part 1

     

       63
       66
        
       

     

       64
       67
        
       ```elixir

     
···

       68
       71
        
       |> Enum.sum()

     

       69
       72
        
       ```

     

       70
       73
        
       

     

       74
       74
       +
       <!-- livebook:{"branch_parent_index":1} -->

     

       75
       75
       +
       

     

       71
       76
        
       ## Part 2

     

       72
       77
        
       

     

       73
       78
        
       ```elixir

     
···

       77
       82
        
       |> Enum.sum()

     

       78
       83
        
       ```

     

       79
       84
        
       

     

       80
       80
       -
       <!-- livebook:{"offset":1434,"stamp":{"token":"XCP.XGwVuWkI5pveel-Tx5hGUsCOmJKjA6byJZgIevkuBoRsAeaI3iyjR6XNRi9nwICSeuXI_2gJ9nWRKsSPzj30sqjcf8vmy_6FGXhLmap28ImjUKnK7ruHw0EpJansNfksuQ","version":2}} -->

     

       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