commit 7a095842f640881832285eb1d44a59aed7df959e · hauleth.dev/advent-of-code

+102

2021/day10.txt

···

       1
       1
       +
       [<[{<[(([<[[{[()()]}]{<<<>[]>[()[]]>{(<>[]){<>[]}}}]<{(<()<>>{()<>})(<()>)}([{()[]}](<()<>>

     

       2
       2
       +
       <[(<({[<(<<({({}[])[<>]}[<<>{}>[()()]])>>)>]})>{[([({[{{<[[]{}]{{}}><{()[]}[{}]>}}{{[<<>()>((){})

     

       3
       3
       +
       {<({([<([[<<[(<>())({}{})](<()()>{{}})>(([[]{}]<[][]>){<{}>{<>{}}})>]][[((<[<>()]<<>[]>>{{()[]}{[]{}

     

       4
       4
       +
       ([{({<<{<<<{([{}[]]([]())){[(){}]}}{[<{}()>(<>[])]}][({[()<>][<><>]}{{{}[]}})<<<{}()>>>]>([[<[{}<>]

     

       5
       5
       +
       {([{({(<{[<(<(()()){{}()}>[(<><>)<<>[]>])[{{{}()}[(){}]}[<()[]>[{}[])]]>{([{{}{}}{[]}][{{}<>}{<><>}]){[[[]()

     

       6
       6
       +
       [{(([[{([(({(<{}()>({}<>))((()())(<>[]))}{<{{}[]}[{}()]>{{()()})})<{{([]{})[<>[]]}[{<>[]}{

     

       7
       7
       +
       <<([{{({{{[(<[<>()][()<>]>)]}<(<<<<>()><{}()>>><({{}<>}{()[]}){<(){}>}>)>>})<[{[<([[{}{}]{{}()}]

     

       8
       8
       +
       <[{{[<[{(<<([([]{})]<[[]{}]{<>()}>)(<<<>{}>{{}[]]>(<[]()>(()[])))><<[{[][]}{[]}](([])([]))><({{}{}}{[][]})

     

       9
       9
       +
       {{{({{{([<<<{[()]({}{})}((()[])<()<>>)>{{<{}<>><{}()>}}>(<<(())({}())>{{{}}({}())}>{<[{}<>]<{}{}>>[{<>()}

     

       10
       10
       +
       {<({<[{[<<{{[[[][]][<><>]](([]{})<()[]>)}<<((){})><[[][]](<><>)>>}{(<<{}<>><<>>><((){})([]<>)>)<(([]))(

     

       11
       11
       +
       ({{{([({<((<<<()>[[]<>]>(<<><>>(()()))>))>})]){({[<[<<[[{}{}]][([]<>)]><{<{}()><()<>>}(<[][]>[{}()])]>{({{

     

       12
       12
       +
       (<{<<[[[(<{<({<>()}{{}<>})<<()()>(<>[])>>(({{}()}([])))}>([[<({}())({}())]((<>{})<<><>>)][[<(

     

       13
       13
       +
       [([({{{[<([<[(<>[])[{}[]]]<[[]{}][<>]>>])<(((<()<>>(<>{}])({<>{}}[{}<>]))<([()()]{[]<>})({<>()}[{}

     

       14
       14
       +
       <(<<([{{[<((({<><>}<<>>)[[[]<>]({}())]){(<<>()>{[]()})[<()>{[][]}]})>]<[[[{(<>{})<(){}>}[{<>{}}]]]][

     

       15
       15
       +
       {[[[{[(((<{[{([]{})[[][]]}(<{}()><<>[]>)][<[<>{}]>]}>({([(()())<[]{}>](([]{})[<>{}])][[{[]{}}<<>{}>]({{}}[<>

     

       16
       16
       +
       {{{([[<[({<<<({}{})<[]()>>[[<>[]>{<>[]}]>[({<>[]}({}<>))[[[]()][()<>]]]>})]>]<(<<<<[<((){})<{}{}>><{()()}((

     

       17
       17
       +
       [{<<<[((<{{{[<{}{}>[{}{}]]([{}<>]{{}<>})}{{[{}{}][{}]}({[]<>}{<><>})}][([<[]<>><{}<>>][<(){}>(()

     

       18
       18
       +
       [{<(<[{(<(<((((){})<[]<>>)[{()<>}{[]<>}])><(((<>)(<>[]))(<[]<>>))([<<><>>[[]<>]]{<[]()>{()[]}})>){<({{[][

     

       19
       19
       +
       <(<<<[([[<{{(({}[])[<>{}])<(()<>)({}{})>}}>{{([(<>())<()[]>]{{[]<>}})<[[<>()]](<()[]>)>}<{[<{}<>><{}[]>](

     

       20
       20
       +
       {((<[<[<(<[({{{}<>}(()<>)}{(<>{})[[]{}]})(((()[])))]>)[{([([<><>][{}[]])[<()[]>(<>[])]]({[

     

       21
       21
       +
       [({([<([({<(<<(){}><{}<>>>{{<>[]}[()[]]})[[[{}[]](()())]]]({[{(){}}{()}]<{{}()}{{}()}>}[([[][]][()[

     

       22
       22
       +
       ({[[{[[({{[[(<<><>>{()}){[()()]}]<{{<><>}({}())}{{[][]}{()()>}>]<[{<<>[]>[[]<>]}]<[<()[]><(

     

       23
       23
       +
       (<[{[(<{(<{{[{<><>}{[][]}](<(){}><[]()>)}}><{<(<<>()>([]<>))<({}<>){{}()}>>}{([(()[]}[<>[]]])<{{[]{}}

     

       24
       24
       +
       <{{(<([(<<<<[{{}<>}(()[])][<{}[]>[<>[]]]><<{[]()}(()<>)>({()<>}({}[]))>><[(([]{}))[{<><>}([][])]]{{(<>())}(

     

       25
       25
       +
       {<[(<{[[(<<[{<(){}>{<><>}}((()<>){<>()})]<[[{}<>]{{}[]}]{([])([]{})}>><{(<{}[]><()<>>)}<(({}()]{[

     

       26
       26
       +
       [{[([([{{{{([(()[])[()()]])[[(<>{})[{}[]]]]}}}{<({[<()[]><{}()]]}{[[[]()]{()()}]})<<<[{}<>](<>[])>[(()<>)([]

     

       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
       +
       [(<{<([[[<({[{<><>}{<>{}}][{()<>}{<>()}]}<(<()[]><()<>>)>)><<([[{}{}]]([<>[]][[]<>]))(<<<>()>[()<>]>

     

       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
       +
       [<({{[([([<{<[[]]<{}{}>>{([][])[()<>]]}[[<(){}><(){}>]]>((((<>{})[<>{}]){(()[])}){<[<>](()<>)>([[]<

     

       62
       62
       +
       <[[([[[(({{<(({}){[][]})[[<>[]]([]())]><[<{}{}><{}()>]>}<(<{<><>}{()[]}>([{}()]((){})))>}{{([{{}}{<>[

     

       63
       63
       +
       ([[{<<<<(({(<([]{})<{}[]>>)}([[<{}()>)([[]{}]<<>()>)]{{{(){}}}[<()<>>{<><>}]}))<[{{<()()><{}{}>}}][{{<(){}><

     

       64
       64
       +
       {[{{(<{{{<([[{{}()}{{}{}}]]({<[][]>(<>[])}[[[][]]{<>[]}]))>}}}>)}}{<[<{[{[<[({[]}<[]{}>){(<>{})(<><>)

     

       65
       65
       +
       <{{([<{{{{<{{{()[]}{[]()}}{(())((){})}}{{(()[])[{}<>]}(<()<>>([][]))}>}}<[{({<()[]>({}[])}

     

       66
       66
       +
       {(<([(([{{{({[()()]<()>}[([]()}<<><>>])[{[<>[]]<<>>}{{[]<>}(<>())}]}}<{{[[{}[]]]}(<<<>()>>({[]()}<<>[]>)

     

       67
       67
       +
       <[{{{[{(<<(({<<>[]>{[]}}<{{}[]}<{}[]>>)[[([]())(<><>)][[[]()]([]{})]])[<{(()[])<()>}>([{{}{}}]{<(){}>(()())

     

       68
       68
       +
       [(<[({<{[[{<{[{}[]]{[]<>}}[<()<>>[[][]]]>(<[{}<>]({}())><[{}{}]{()()}>)}((<<<>[]>(<>{})>[(<>())[{}{

     

       69
       69
       +
       [[<{{<<[<<<<({{}<>}<{}[]>)((()[])[[]<>])><([<>[]]([]<>)){(<><>)}>>[({{()}{<>[]}}[([][])[{}[]]]){([{}()][<>{

     

       70
       70
       +
       {{{<({[([({<[[{}<>](()())]([<><>]({}[]))>}(({<<>()>[[]]}[<()>{<>{}}])))]<{({{(()())<<>>}}[({[]{}}[

     

       71
       71
       +
       (<<{(({{(<{{[<{}{}><<>()>]{{()[]}<<>{}>}}(<<{}<>><()>>{<()<>>([]{})})}<[{([]<>)<<>[]>}[<{}()><{}>]]>>

     

       72
       72
       +
       {<[[<{[{(<{<<(<>)<{}{}>>>[<<{}()>({}{})>]}<<[({}[]](()[])]{<[]<>>(())}>{<{()<>}({}<>)>{<()

     

       73
       73
       +
       [{((<<{<{[{[([()<>](()())){(<>())}}([[()<>][{}()]][({}[]){[]()}])}([<[()<>]([][])>[[[]{}]{()[

     

       74
       74
       +
       [<[<[<<[([<{[{()<>}({}())]<{{}<>}([]())>}(<<<>{}>[{}{}]>[[[]()]])>]<({({(){}}<[]{}>)([()<>](()))}[({[

     

       75
       75
       +
       [<[<[(((<(({{([][])}}<[[[][]]{(){}}>(<()[]>[[][]])>){([(()<>)<()()>]<[{}()]([]())>)<<{<>()}>([<>[]]{[]

     

       76
       76
       +
       {{<{<[{[{[(<([{}()]{[]<>})({<>})>(({{}{}}([]{}))))<[[({}{})<()[]>][{[]{}}{(){}}]]{([()<>])(<()[]><<>()>)}>]}

     

       77
       77
       +
       ((({([{(<{<[[{{}<>}<{}()>]{([]<>)[{}[]]}]>(<([[]<>])((<>[]))>{<{[][]}(<>())>{{{}()}(()[])}})}>{[

     

       78
       78
       +
       <{(([(<<<(<({{[]<>}{<>[]}}{[[]{}][[]{}]})>[<<[{}<>](()<>)><(()<>)[{}()]>>(<{<>[]]({}[])>{(<>)<[]{}>})]){[<<[(

     

       79
       79
       +
       <{<{{<<<{((<([()()])(<(){}>{<>()})>)<([([]()){{}[]}]{{{}}<{}[]>})(<{()<>)>[<{}()>])>)(<(([()()](

     

       80
       80
       +
       (<[{(<(<[<<[((<>[]){<>[]})<(<>[]]({}{})>][[{[]{}}{()[]}]]>>[<{(<[][]>{{}{}})}<([()[]]<[]<>>)[{<><>}<{}{

     

       81
       81
       +
       ({{<<({<<[<[<(<><>)<()<>>><[()<>]([][])>]>[{{<()<>><()<>>}}(<{{}()}><{{}{}}<{}{}>>)]]([[[{[

     

       82
       82
       +
       ([[<<([[<([{([()[]](<>[]))<<<>[])({}[])>}[{[[][]]}]])[<[[({}{})<{}<>>]]([{{}<>}({}[])](([]())({}{})))>[[

     

       83
       83
       +
       <{<(<{({[({[[[()[]]{{}[]}][[<>[]>{<>[]}]]})]<{[{<[{}[]]{<>()}><([]<>){<>{}}>}{(<(){}>{<>{}})

     

       84
       84
       +
       <<<[<{(<{(({({<><>}{{}<>}){([][])([][])}}[<{(){}}<<>{}>>{([]<>)[()[]]}>)<{{{<><>}{<>{}}}{(

     

       85
       85
       +
       <[<<(({<<[<([<{}()><<><>]])<[[{}<>][<>{}]]<[{}<>](<>{})>>>](<(<[[]<>][(){}]>(<<>()>{<>})){[({}[]

     

       86
       86
       +
       <[[{<[([[[[{([()<>])<[[][]]{[]{}}>}](<[(<><>)]>({{(){}}<[]()>}))]]]{<({{(<<>()><(){}>){<[]<>>}}}[[

     

       87
       87
       +
       <{[[[(({{[{(([{}()][<>()]))[([[]{}]<{}[]>)([<>[]]{{}{}})]}[{[(()[])]((<>{}){()()})}<<{(){}}[[]<>

     

       88
       88
       +
       (<((<[[{((({((()<>)){{{}<>}(<><>)}}<((()[]))>)([{(<>[])([]<>)}[([][])(<>[])]]<<<<>{}>>[([][])[{}<>]>>))([<

     

       89
       89
       +
       [(((<[<{[([{(<<>[]>((){}))[[[]()][<>{}]])]<({<{}>{[][]}}{{{}<>}[<>[]]})<<{{}()}{(){}}>({<>{}}{{}[]

     

       90
       90
       +
       {((<[{[<<<[{<[(){}]({}{})>}<[<[]{}>({}<>)][{(){}}<<>{}>)>][<[[{}]({}[])]>]><[{{{{}[]}}({[]{}}(<>

     

       91
       91
       +
       [[<[(((({[[[({<>{}}{{}()})[<(){}>{<>}]]{(<<>{}>(()<>))([[]<>]<()<>>)}](<([[]{}]<()()>)>{<[()

     

       92
       92
       +
       [<<<[{[<{[(({([][]){<>}}))(<{([]())[{}()]}[[{}[]]{[]<>}]><{(<>())<[][]>}[([][]){{}()}]>)](

     

       93
       93
       +
       <(<{<<[([[<{[[<>()]<{}{}>][[(){}]<<><>>]}>]{(([[<>[]](<>{})>{<()[]><[][]>})[<[(){}]{[][]}><[<>()]([][]

     

       94
       94
       +
       <[([<<[{{[<<<{<>()}[<>()]>[<{}{}>[{}{}]]>[{[(){}]}([[]{}])]>]}}]>>{<([<(({({[][]}){([]()){{}{}}}}

     

       95
       95
       +
       [({{{((<{<{[<<{}{}>><<[]{}><<>{}>>][<{{}()}>]}[(<[[]]<<>[]>>[([]())<<>{}>]){<[{}[]]>((()<>)[[]{}

     

       96
       96
       +
       {[<[[(({([[<[(<>{})<<>{}>]{<()<>><{}[]>}>[[{{}<>}([]<>)][({}())([]())]]]])[[({{[[]<>][<>{}]}[[<>

     

       97
       97
       +
       (((<[[<<{{[[[([]{})<{}<>>]]{{[<>[]]<{}{}>}({<><>}{()()})}][[<<[]()>{<>[]}><(()())<()[]>>]{{([](

     

       98
       98
       +
       [<{<[[[<<{[{<({})([][])>[{[]()}]}<[{{}()}[<><>]]>][((<[]{}><{}()>)(<<>()>))([<<>()>((){})>)]}{[({(<>())<(

     

       99
       99
       +
       {([<[{{{<[{[({<>()}(<>{})}[{()()}[<><>]]]}<{{{<>[]}[{}[]]}({[]()}[{}()])}<({()()}<<><>>){{{}{}}

     

       100
       100
       +
       {{<[[<({([{(([[]<>][{}<>])){{({}{})<<>()>}}}[[{[<><>][{}{}]}<{[][]}([]())>]<<[()[]]{()<>}>{<{}[]}(()())}>]

     

       101
       101
       +
       <({<[([{[[<{<{[]{}}[<>]>}>([(<()[]>[[]<>])<{<>[]}>]{[(()())[{}]][<{}<>><{}>]})]]([{{{([]{})[(){}]}[<

     

       102
       102
       +
       [<<[{[{{[[{[[[()<>][()[]]](({}<>)[()<>])]<<(()[])>([<>[]]{()<>})>}([<[{}{}]>{({}<>){[][]}}][{[<>[]][<>]}])]]}

+10

2021/day11.txt

+22

2021/day12.txt

+266 -42

2021/solutions.livemd

···

       17
       17
        
       ```

     

       18
       18
        
       

     

       19
       19
        
       ```output

     

       20
       20
       -
       * Getting nx (https://github.com/elixir-nx/nx.git)

     

       21
       21
       -
       remote: Enumerating objects: 10786, done.        

     

       22
       22
       -
       remote: Counting objects: 100% (2841/2841), done.        

     

       23
       23
       -
       remote: Compressing objects: 100% (635/635), done.        

     

       24
       24
       -
       remote: Total 10786 (delta 2376), reused 2515 (delta 2195), pack-reused 7945        

     

       25
       25
       -
       origin/HEAD set to main

     

       26
       26
       -
       * Getting kino (https://github.com/livebook-dev/kino.git)

     

       27
       27
       -
       remote: Enumerating objects: 488, done.        

     

       28
       28
       -
       remote: Counting objects: 100% (488/488), done.        

     

       29
       29
       -
       remote: Compressing objects: 100% (351/351), done.        

     

       30
       30
       -
       remote: Total 488 (delta 269), reused 274 (delta 118), pack-reused 0        

     

       31
       31
       -
       origin/HEAD set to main

     

       32
       32
       -
       ==> kino

     

       33
       33
       -
       Compiling 19 files (.ex)

     

       34
       34
       -
       Generated kino app

     

       35
       35
       -
       ==> nx

     

       36
       36
       -
       Compiling 23 files (.ex)

     

       37
       37
       -
       Generated nx app

     

       38
       38
       -
       ```

     

       39
       39
       -
       

     

       40
       40
       -
       ```output

     

       41
       20
        
       :ok

     

       42
       21
        
       ```

     

       43
       22
        
       

     
···

       571
       550
        
       ### Task 1

     

       572
       551
        
       

     

       573
       552
        
       ```elixir

     

       574
       574
       -
       mean = Enum.at(Enum.sort(input), div(length(input), 2))

     

       553
       553
       +
       median = Enum.at(Enum.sort(input), div(length(input), 2))

     

       575
       554
        
       

     

       576
       555
        
       input

     

       577
       577
       -
       |> Enum.map(&abs(&1 - mean))

     

       556
       556
       +
       |> Enum.map(&abs(&1 - median))

     

       578
       557
        
       |> Enum.sum()

     

       579
       558
        
       ```

     

       580
       559
        
       

     
···

       746
       725
        
       ```elixir

     

       747
       726
        
       input =

     

       748
       727
        
         File.read!("day9.txt")

     

       749
       749
       -
         # ~S[110

     

       750
       750
       -
         #   101

     

       751
       751
       -
         #   110]

     

       752
       728
        
         |> String.split("\n", trim: true)

     

       753
       729
        
         |> Enum.map(&String.to_charlist(String.trim(&1)))

     

       754
       730
        
         |> Nx.tensor(names: [:y, :x])

     
···

       765
       741
        
       ### Task 1

     

       766
       742
        
       

     

       767
       743
        
       ```elixir

     

       768
       768
       -
       padded = Nx.pad(input, 99, [{0, 0, 0}, {1, 1, 0}])

     

       744
       744
       +
       minima = fn padded, size, axis ->

     

       745
       745
       +
         shifted = Nx.slice_axis(padded, 0, size, axis)

     

       746
       746
       +
         x1 = Nx.less(input, shifted)

     

       769
       747
        
       

     

       770
       770
       -
       shifted = Nx.slice_axis(padded, 0, height, :x)

     

       748
       748
       +
         shifted = Nx.slice_axis(padded, 2, size, axis)

     

       749
       749
       +
         x2 = Nx.less(input, shifted)

     

       771
       750
        
       

     

       772
       772
       -
       x1 = Nx.less(input, shifted)

     

       751
       751
       +
         Nx.logical_and(x1, x2)

     

       752
       752
       +
       end

     

       773
       753
        
       

     

       774
       774
       -
       shifted = Nx.slice_axis(padded, 2, height, :x)

     

       754
       754
       +
       padded = Nx.pad(input, 99, [{0, 0, 0}, {1, 1, 0}])

     

       775
       755
        
       

     

       776
       776
       -
       x2 = Nx.less(input, shifted)

     

       777
       777
       -
       

     

       778
       778
       -
       x = Nx.logical_and(x1, x2)

     

       756
       756
       +
       x = minima.(padded, width, :x)

     

       779
       757
        
       

     

       780
       758
        
       padded = Nx.pad(input, 99, [{1, 1, 0}, {0, 0, 0}])

     

       781
       759
        
       

     

       782
       782
       -
       shifted = Nx.slice_axis(padded, 0, width, :y)

     

       783
       783
       -
       

     

       784
       784
       -
       y1 = Nx.less(input, shifted)

     

       785
       785
       -
       

     

       786
       786
       -
       shifted = Nx.slice_axis(padded, 2, width, :y)

     

       787
       787
       -
       

     

       788
       788
       -
       y2 = Nx.less(input, shifted)

     

       789
       789
       -
       

     

       790
       790
       -
       y = Nx.logical_and(y1, y2)

     

       760
       760
       +
       y = minima.(padded, height, :y)

     

       791
       761
        
       

     

       792
       762
        
       minimas = Nx.logical_and(x, y)

     

       793
       763
        
       

     
···

       843
       813
        
       ```output

     

       844
       814
        
       1263735

     

       845
       815
        
       ```

     

       816
       816
       +
       

     

       817
       817
       +
       ## Day 10

     

       818
       818
       +
       

     

       819
       819
       +
       ```elixir

     

       820
       820
       +
       input =

     

       821
       821
       +
         File.stream!("day10.txt")

     

       822
       822
       +
         |> Stream.map(&String.trim/1)

     

       823
       823
       +
       

     

       824
       824
       +
       defmodule Day10 do

     

       825
       825
       +
         @parens %{?( => ?), ?[ => ?], ?< => ?>, ?{ => ?}}

     

       826
       826
       +
       

     

       827
       827
       +
         def parse(input), do: parse(input, [])

     

       828
       828
       +
       

     

       829
       829
       +
         defp parse(<<c>> <> rest, stack) when c in '([{<', do: parse(rest, [@parens[c] | stack])

     

       830
       830
       +
         defp parse(<<c>> <> rest, [c | stack]), do: parse(rest, stack)

     

       831
       831
       +
         defp parse(<<>>, []), do: :ok

     

       832
       832
       +
         defp parse(<<>>, rest), do: {:incomplete, rest}

     

       833
       833
       +
         defp parse(<<c>> <> _, _), do: {:unexpected, [c]}

     

       834
       834
       +
       end

     

       835
       835
       +
       ```

     

       836
       836
       +
       

     

       837
       837
       +
       ```output

     

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

     

       839
       839
       +
       ```

     

       840
       840
       +
       

     

       841
       841
       +
       ```elixir

     

       842
       842
       +
       points = %{

     

       843
       843
       +
         ?) => 3,

     

       844
       844
       +
         ?] => 57,

     

       845
       845
       +
         ?} => 1197,

     

       846
       846
       +
         ?> => 25137

     

       847
       847
       +
       }

     

       848
       848
       +
       

     

       849
       849
       +
       input

     

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

     

       851
       851
       +
       |> Enum.map(fn

     

       852
       852
       +
         {:unexpected, [c]} -> points[c]

     

       853
       853
       +
         _ -> 0

     

       854
       854
       +
       end)

     

       855
       855
       +
       |> Enum.sum()

     

       856
       856
       +
       ```

     

       857
       857
       +
       

     

       858
       858
       +
       ```output

     

       859
       859
       +
       288291

     

       860
       860
       +
       ```

     

       861
       861
       +
       

     

       862
       862
       +
       ```elixir

     

       863
       863
       +
       points = %{

     

       864
       864
       +
         ?) => 1,

     

       865
       865
       +
         ?] => 2,

     

       866
       866
       +
         ?} => 3,

     

       867
       867
       +
         ?> => 4

     

       868
       868
       +
       }

     

       869
       869
       +
       

     

       870
       870
       +
       median = fn list ->

     

       871
       871
       +
         sorted = Enum.sort(list)

     

       872
       872
       +
         middle = div(length(list), 2)

     

       873
       873
       +
       

     

       874
       874
       +
         Enum.at(sorted, middle)

     

       875
       875
       +
       end

     

       876
       876
       +
       

     

       877
       877
       +
       input

     

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

     

       879
       879
       +
       |> Enum.flat_map(fn

     

       880
       880
       +
         {:incomplete, rest} ->

     

       881
       881
       +
           [

     

       882
       882
       +
             Enum.reduce(rest, 0, fn c, acc ->

     

       883
       883
       +
               acc * 5 + points[c]

     

       884
       884
       +
             end)

     

       885
       885
       +
           ]

     

       886
       886
       +
       

     

       887
       887
       +
         _ ->

     

       888
       888
       +
           []

     

       889
       889
       +
       end)

     

       890
       890
       +
       |> median.()

     

       891
       891
       +
       ```

     

       892
       892
       +
       

     

       893
       893
       +
       ```output

     

       894
       894
       +
       820045242

     

       895
       895
       +
       ```

     

       896
       896
       +
       

     

       897
       897
       +
       ## Day 11

     

       898
       898
       +
       

     

       899
       899
       +
       ```elixir

     

       900
       900
       +
       input =

     

       901
       901
       +
         File.read!("day11.txt")

     

       902
       902
       +
         |> String.split("\n")

     

       903
       903
       +
         |> Enum.map(&String.trim/1)

     

       904
       904
       +
         |> Enum.map(fn line ->

     

       905
       905
       +
           for <<c <- line>>, do: c - ?0

     

       906
       906
       +
         end)

     

       907
       907
       +
         |> Enum.with_index()

     

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

     

       909
       909
       +
           for {v, x} <- Enum.with_index(row), do: {{x, y}, v}

     

       910
       910
       +
         end)

     

       911
       911
       +
         |> Map.new()

     

       912
       912
       +
       

     

       913
       913
       +
       defmodule Day11 do

     

       914
       914
       +
         def step(map) do

     

       915
       915
       +
           updated = Map.new(map, fn {k, v} -> {k, v + 1} end)

     

       916
       916
       +
       

     

       917
       917
       +
           lightup(updated, 0)

     

       918
       918
       +
         end

     

       919
       919
       +
       

     

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

     

       921
       921
       +
       

     

       922
       922
       +
         IO.inspect(@diffs)

     

       923
       923
       +
       

     

       924
       924
       +
         def lightup(map, n) do

     

       925
       925
       +
           map

     

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

     

       927
       927
       +
             {_, v}, acc when v < 10 ->

     

       928
       928
       +
               acc

     

       929
       929
       +
       

     

       930
       930
       +
             {{x, y} = k, _}, {map, count} ->

     

       931
       931
       +
               new_map =

     

       932
       932
       +
                 @diffs

     

       933
       933
       +
                 |> Enum.reduce(map, fn {dx, dy}, acc ->

     

       934
       934
       +
                   point = {x + dx, y + dy}

     

       935
       935
       +
       

     

       936
       936
       +
                   case Map.fetch(acc, point) do

     

       937
       937
       +
                     {:ok, value} when value != 0 -> %{acc | point => value + 1}

     

       938
       938
       +
                     _ -> acc

     

       939
       939
       +
                   end

     

       940
       940
       +
                 end)

     

       941
       941
       +
                 |> Map.put(k, 0)

     

       942
       942
       +
       

     

       943
       943
       +
               {new_map, count + 1}

     

       944
       944
       +
           end)

     

       945
       945
       +
           |> case do

     

       946
       946
       +
             {map, 0} -> {map, n}

     

       947
       947
       +
             {map, m} -> lightup(map, n + m)

     

       948
       948
       +
           end

     

       949
       949
       +
         end

     

       950
       950
       +
       end

     

       951
       951
       +
       ```

     

       952
       952
       +
       

     

       953
       953
       +
       ```output

     

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

     

       955
       955
       +
       ```

     

       956
       956
       +
       

     

       957
       957
       +
       ```output

     

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

     

       959
       959
       +
       ```

     

       960
       960
       +
       

     

       961
       961
       +
       ```elixir

     

       962
       962
       +
       draw = fn map ->

     

       963
       963
       +
         for x <- 0..9 do

     

       964
       964
       +
           IO.puts(for y <- 0..9, do: ?0 + map[{x, y}])

     

       965
       965
       +
         end

     

       966
       966
       +
       

     

       967
       967
       +
         IO.puts("")

     

       968
       968
       +
       end

     

       969
       969
       +
       

     

       970
       970
       +
       1..100

     

       971
       971
       +
       |> Enum.reduce({input, 0}, fn _, {map, n} ->

     

       972
       972
       +
         {new_map, m} = Day11.step(map)

     

       973
       973
       +
         {new_map, n + m}

     

       974
       974
       +
       end)

     

       975
       975
       +
       |> elem(1)

     

       976
       976
       +
       ```

     

       977
       977
       +
       

     

       978
       978
       +
       ```output

     

       979
       979
       +
       1688

     

       980
       980
       +
       ```

     

       981
       981
       +
       

     

       982
       982
       +
       ```elixir

     

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

     

       984
       984
       +
       |> Enum.reduce_while(input, fn idx, map ->

     

       985
       985
       +
         case Day11.step(map) do

     

       986
       986
       +
           {_, 100} -> {:halt, idx}

     

       987
       987
       +
           {next, _} -> {:cont, next}

     

       988
       988
       +
         end

     

       989
       989
       +
       end)

     

       990
       990
       +
       ```

     

       991
       991
       +
       

     

       992
       992
       +
       ```output

     

       993
       993
       +
       403

     

       994
       994
       +
       ```

     

       995
       995
       +
       

     

       996
       996
       +
       ## Day 12

     

       997
       997
       +
       

     

       998
       998
       +
       ```elixir

     

       999
       999
       +
       input =

     

       1000
       1000
       +
         File.read!("day12.txt")

     

       1001
       1001
       +
         |> String.split("\n")

     

       1002
       1002
       +
         |> Enum.map(&String.split(&1, "-"))

     

       1003
       1003
       +
       

     

       1004
       1004
       +
       graph =

     

       1005
       1005
       +
         Enum.reduce(input, %{}, fn [a, b], acc ->

     

       1006
       1006
       +
           acc

     

       1007
       1007
       +
           |> Map.update(a, [b], &[b | &1])

     

       1008
       1008
       +
           |> Map.update(b, [a], &[a | &1])

     

       1009
       1009
       +
         end)

     

       1010
       1010
       +
       

     

       1011
       1011
       +
       defmodule Day12 do

     

       1012
       1012
       +
         def dfs(graph, start, finish), do: dfs(graph, start, finish, [start])

     

       1013
       1013
       +
       

     

       1014
       1014
       +
         defp dfs(_graph, vertex, vertex, _visited), do: 1

     

       1015
       1015
       +
       

     

       1016
       1016
       +
         defp dfs(graph, vertex, finish, visited) do

     

       1017
       1017
       +
           (graph[vertex] -- visited)

     

       1018
       1018
       +
           |> Enum.reduce(0, fn vertex, acc ->

     

       1019
       1019
       +
             visited = if small?(vertex), do: [vertex | visited], else: visited

     

       1020
       1020
       +
       

     

       1021
       1021
       +
             acc + dfs(graph, vertex, finish, visited)

     

       1022
       1022
       +
           end)

     

       1023
       1023
       +
         end

     

       1024
       1024
       +
       

     

       1025
       1025
       +
         def dfs2(graph, start, finish), do: dfs2(graph, start, finish, %{start => :inf})

     

       1026
       1026
       +
       

     

       1027
       1027
       +
         defp dfs2(_graph, vertex, vertex, _visited), do: 1

     

       1028
       1028
       +
       

     

       1029
       1029
       +
         defp dfs2(graph, vertex, finish, visited) do

     

       1030
       1030
       +
           (graph[vertex] -- keys(visited))

     

       1031
       1031
       +
           |> Enum.reduce(0, fn vertex, acc ->

     

       1032
       1032
       +
             visited = if small?(vertex), do: Map.update(visited, vertex, 1, &(&1 + 1)), else: visited

     

       1033
       1033
       +
       

     

       1034
       1034
       +
             acc + dfs2(graph, vertex, finish, visited)

     

       1035
       1035
       +
           end)

     

       1036
       1036
       +
         end

     

       1037
       1037
       +
       

     

       1038
       1038
       +
         defp keys(map) do

     

       1039
       1039
       +
           if Enum.any?(map, fn {_, v} -> v == 2 end) do

     

       1040
       1040
       +
             # there is already some vertex visited twice

     

       1041
       1041
       +
             Map.keys(map)

     

       1042
       1042
       +
           else

     

       1043
       1043
       +
             for {k, v} <- map, v > 1, do: k

     

       1044
       1044
       +
           end

     

       1045
       1045
       +
         end

     

       1046
       1046
       +
       

     

       1047
       1047
       +
         defp small?(<<c>> <> _), do: c in ?a..?z

     

       1048
       1048
       +
       end

     

       1049
       1049
       +
       ```

     

       1050
       1050
       +
       

     

       1051
       1051
       +
       ```output

     

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

     

       1053
       1053
       +
       ```

     

       1054
       1054
       +
       

     

       1055
       1055
       +
       ```elixir

     

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

     

       1057
       1057
       +
       ```

     

       1058
       1058
       +
       

     

       1059
       1059
       +
       ```output

     

       1060
       1060
       +
       4167

     

       1061
       1061
       +
       ```

     

       1062
       1062
       +
       

     

       1063
       1063
       +
       ```elixir

     

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

     

       1065
       1065
       +
       ```

     

       1066
       1066
       +
       

     

       1067
       1067
       +
       ```output

     

       1068
       1068
       +
       98441

     

       1069
       1069
       +
       ```