commit fbe1239379eea7969c78cec68befddfe177b053c · aylac.top/advent_of_code

+50 -20
2025/7/gleam/src/main.gleam
···

       21
       21
        
               _ -> acc

     

       22
       22
        
             }

     

       23
       23
        
           })

     

       24
       24
       -
         let splitters =

     

       24
       24
       +
         let splitters_map =

     

       25
       25
        
           input

     

       26
       26
        
           |> list.drop(1)

     

       27
       27
        
           |> list.index_map(fn(line, i) {

     
···

       41
       41
        
               }

     

       42
       42
        
             })

     

       43
       43
        
           })

     

       44
       44
       -
         let #(beams, times) =

     

       45
       45
       -
           echo splitters

     

       46
       46
       -
             |> list.fold(#(set.new() |> set.insert(start), 0), fn(acc, splitters) {

     

       44
       44
       +
         let #(_beams, times) =

     

       45
       45
       +
           splitters_map

     

       46
       46
       +
           |> list.fold(#(set.new() |> set.insert(start), 0), fn(acc, splitters) {

     

       47
       47
       +
             let #(beams, times) = acc

     

       48
       48
       +
             beams

     

       49
       49
       +
             |> set.fold(#(beams, times), fn(acc, beam) {

     

       47
       50
        
               let #(beams, times) = acc

     

       48
       48
       -
               beams

     

       49
       49
       -
               |> set.fold(#(beams, times), fn(acc, beam) {

     

       50
       50
       -
                 let #(beams, times) = acc

     

       51
       51
       -
                 case splitters |> set.contains(beam) {

     

       52
       52
       -
                   False -> acc

     

       53
       53
       -
                   True -> {

     

       54
       54
       -
                     #(

     

       55
       55
       -
                       beams

     

       56
       56
       -
                         |> set.delete(beam)

     

       57
       57
       -
                         |> set.insert(beam - 1)

     

       58
       58
       -
                         |> set.insert(beam + 1),

     

       59
       59
       -
                       times + 1,

     

       60
       60
       -
                     )

     

       61
       61
       -
                   }

     

       51
       51
       +
               case splitters |> set.contains(beam) {

     

       52
       52
       +
                 False -> acc

     

       53
       53
       +
                 True -> #(

     

       54
       54
       +
                   beams

     

       55
       55
       +
                     |> set.delete(beam)

     

       56
       56
       +
                     |> set.insert(beam - 1)

     

       57
       57
       +
                     |> set.insert(beam + 1),

     

       58
       58
       +
                   times + 1,

     

       59
       59
       +
                 )

     

       60
       60
       +
               }

     

       61
       61
       +
             })

     

       62
       62
       +
           })

     

       63
       63
       +
       

     

       64
       64
       +
         times

     

       65
       65
       +
         |> int.to_string

     

       66
       66
       +
         |> io.println

     

       67
       67
       +
       

     

       68
       68
       +
         let timelines =

     

       69
       69
       +
           splitters_map

     

       70
       70
       +
           |> list.fold(dict.new() |> dict.insert(0, start), fn(timelines, splitters) {

     

       71
       71
       +
             // echo #(timelines, splitters)

     

       72
       72
       +
             timelines

     

       73
       73
       +
             |> dict.fold(timelines, fn(timelines, timeline, beam) {

     

       74
       74
       +
               case splitters |> set.contains(beam) {

     

       75
       75
       +
                 False -> timelines

     

       76
       76
       +
                 True -> {

     

       77
       77
       +
                   timelines

     

       78
       78
       +
                   |> dict.delete(timeline)

     

       79
       79
       +
                   |> dict.insert(

     

       80
       80
       +
                     int.random(100_000_000_000_000_000_000_000),

     

       81
       81
       +
                     beam - 1,

     

       82
       82
       +
                   )

     

       83
       83
       +
                   |> dict.insert(

     

       84
       84
       +
                     int.random(100_000_000_000_000_000_000_000),

     

       85
       85
       +
                     beam + 1,

     

       86
       86
       +
                   )

     

       62
       87
        
                 }

     

       63
       63
       -
               })

     

       88
       88
       +
               }

     

       64
       89
        
             })

     

       65
       65
       -
         echo set.size(beams)

     

       90
       90
       +
           })

     

       91
       91
       +
         echo timelines

     

       92
       92
       +
         timelines

     

       93
       93
       +
         |> dict.size

     

       94
       94
       +
         |> int.to_string

     

       95
       95
       +
         |> io.println

     

       66
       96
        
       }