commit b4807f1343605b2d34d9e0b5eb73d86b6e57a2e7 · aylac.top/advent_of_code

+57 -53
2025/5/gleam/src/main.gleam
···

       45
       45
        
         |> int.to_string

     

       46
       46
        
         |> io.println

     

       47
       47
        
       

     

       48
       48
       +
         // nicer looking but idc

     

       49
       49
       +
         // |> list.filter(fn(i) {

     

       50
       50
       +
         //   list.any(fresh_ranges, fn(range) { i >= range.0 && i <= range.1 })

     

       51
       51
       +
         // })

     

       52
       52
       +
         // |> list.length

     

       53
       53
       +
       

     

       54
       54
       +
         // this thing crashed my computer btw im stupid

     

       48
       55
        
         // let haha =

     

       49
       56
        
         //   fresh_ranges

     

       50
       57
        
         //   |> list.fold(set.new(), fn(acc, i) {

     
···

       53
       60
        
         // io.println(set.size(haha) |> int.to_string)

     

       54
       61
        
       

     

       55
       62
        
         let base_set: set.Set(#(Int, Int)) = set.new()

     

       56
       56
       -
         let ranges =

     

       57
       57
       -
           fresh_ranges

     

       58
       58
       -
           |> list.fold(base_set, fn(prev_seen_ranges, range) {

     

       59
       59
       -
             let #(range, seen_ranges) =

     

       60
       60
       -
               prev_seen_ranges

     

       61
       61
       -
               |> set.fold(#(range, prev_seen_ranges), fn(acc, seen_range) {

     

       62
       62
       -
                 let #(range, seen_ranges) = acc

     

       63
       63
       -
                 // echo #(

     

       64
       64
       -
                 //   range,

     

       65
       65
       -
                 //   seen_range,

     

       66
       66
       -
                 //   int.compare(range.0, seen_range.0),

     

       67
       67
       -
                 //   int.compare(range.1, seen_range.1),

     

       68
       68
       -
                 //   int.compare(range.0, seen_range.1),

     

       69
       69
       -
                 //   int.compare(range.1, seen_range.0),

     

       70
       70
       -
                 // )

     

       71
       71
       -
                 // btw im refusing to ever do something better than this idc about your sorting and whatever this is the way shut the fuck up i spent three hours on this i will be using it

     

       72
       72
       -
                 case

     

       73
       73
       -
                   int.compare(range.0, seen_range.0),

     

       74
       74
       -
                   int.compare(range.1, seen_range.1),

     

       75
       75
       -
                   int.compare(range.0, seen_range.1),

     

       76
       76
       -
                   int.compare(range.1, seen_range.0)

     

       77
       77
       -
                 {

     

       78
       78
       -
                   // if there's no touching

     

       79
       79
       -
                   Gt, Gt, Gt, Gt | Lt, Lt, Lt, Lt -> #(range, seen_ranges)

     

       80
       80
       -
                   // if it's inside of the other one

     

       81
       81
       -
                   Gt, Lt, _, _ | Eq, Lt, _, _ | Gt, Eq, _, _ | Eq, Eq, _, _ -> #(

     

       82
       82
       -
                     #(0, 0),

     

       83
       83
       -
                     seen_ranges,

     

       84
       84
       -
                   )

     

       85
       85
       -
                   // if the other one is inside it

     

       86
       86
       -
                   Lt, Gt, _, _ | Eq, Gt, _, _ | Lt, Eq, _, _ -> #(

     

       87
       87
       -
                     range,

     

       88
       88
       -
                     set.delete(seen_ranges, seen_range),

     

       89
       89
       -
                   )

     

       90
       90
       -
                   // if it's touching on the left side make them touch

     

       91
       91
       -
                   Lt, Lt, _, _ -> #(

     

       92
       92
       -
                     #(range.0, seen_range.1),

     

       93
       93
       -
                     set.delete(seen_ranges, seen_range),

     

       94
       94
       -
                   )

     

       95
       95
       -
                   // if it's touching on the right size make them touch

     

       96
       96
       -
                   Gt, Gt, _, _ -> #(

     

       97
       97
       -
                     #(seen_range.0, range.1),

     

       98
       98
       -
                     set.delete(seen_ranges, seen_range),

     

       99
       99
       -
                   )

     

       100
       100
       -
                 }

     

       101
       101
       -
               })

     

       63
       63
       +
         fresh_ranges

     

       64
       64
       +
         |> list.fold(base_set, fn(prev_seen_ranges, range) {

     

       65
       65
       +
           let #(range, seen_ranges) =

     

       66
       66
       +
             prev_seen_ranges

     

       67
       67
       +
             |> set.fold(#(range, prev_seen_ranges), fn(acc, seen_range) {

     

       68
       68
       +
               let #(range, seen_ranges) = acc

     

       69
       69
       +
               // echo #(

     

       70
       70
       +
               //   range,

     

       71
       71
       +
               //   seen_range,

     

       72
       72
       +
               //   int.compare(range.0, seen_range.0),

     

       73
       73
       +
               //   int.compare(range.1, seen_range.1),

     

       74
       74
       +
               //   int.compare(range.0, seen_range.1),

     

       75
       75
       +
               //   int.compare(range.1, seen_range.0),

     

       76
       76
       +
               // )

     

       77
       77
       +
               // btw im refusing to ever do something better than this idc about your sorting and whatever this is the way shut the fuck up i spent three hours on this i will be using it

     

       78
       78
       +
               case

     

       79
       79
       +
                 int.compare(range.0, seen_range.0),

     

       80
       80
       +
                 int.compare(range.1, seen_range.1),

     

       81
       81
       +
                 int.compare(range.0, seen_range.1),

     

       82
       82
       +
                 int.compare(range.1, seen_range.0)

     

       83
       83
       +
               {

     

       84
       84
       +
                 // if there's no touching

     

       85
       85
       +
                 Gt, Gt, Gt, Gt | Lt, Lt, Lt, Lt -> #(range, seen_ranges)

     

       86
       86
       +
                 // if it's inside of the other one

     

       87
       87
       +
                 Gt, Lt, _, _ | Eq, Lt, _, _ | Gt, Eq, _, _ | Eq, Eq, _, _ -> #(

     

       88
       88
       +
                   #(0, 0),

     

       89
       89
       +
                   seen_ranges,

     

       90
       90
       +
                 )

     

       91
       91
       +
                 // if the other one is inside it

     

       92
       92
       +
                 Lt, Gt, _, _ | Eq, Gt, _, _ | Lt, Eq, _, _ -> #(

     

       93
       93
       +
                   range,

     

       94
       94
       +
                   set.delete(seen_ranges, seen_range),

     

       95
       95
       +
                 )

     

       96
       96
       +
                 // if it's touching on the left side make them touch

     

       97
       97
       +
                 Lt, Lt, _, _ -> #(

     

       98
       98
       +
                   #(range.0, seen_range.1),

     

       99
       99
       +
                   set.delete(seen_ranges, seen_range),

     

       100
       100
       +
                 )

     

       101
       101
       +
                 // if it's touching on the right size make them touch

     

       102
       102
       +
                 Gt, Gt, _, _ -> #(

     

       103
       103
       +
                   #(seen_range.0, range.1),

     

       104
       104
       +
                   set.delete(seen_ranges, seen_range),

     

       105
       105
       +
                 )

     

       106
       106
       +
               }

     

       107
       107
       +
             })

     

       102
       108
        
       

     

       103
       103
       -
             case range == #(0, 0) {

     

       104
       104
       -
               False -> seen_ranges |> set.insert(range)

     

       105
       105
       -
               True -> seen_ranges

     

       106
       106
       -
             }

     

       107
       107
       -
           })

     

       108
       108
       -
         // echo ranges

     

       109
       109
       -
         ranges

     

       109
       109
       +
           case range == #(0, 0) {

     

       110
       110
       +
             False -> seen_ranges |> set.insert(range)

     

       111
       111
       +
             True -> seen_ranges

     

       112
       112
       +
           }

     

       113
       113
       +
         })

     

       110
       114
        
         |> set.fold(0, fn(acc, range) { acc + range.1 - range.0 + 1 })

     

       111
       115
        
         |> int.to_string

     

       112
       116
        
         |> io.println