comparing 06a183c334afc564d1ba88a3e46094e0ef9c60f6 and main on aylac.top/advent_of_code

+4

.gitattributes

···

       1
       1
       +
       template/** -linguist-detectable

     

       2
       2
       +
       build.zig -linguist-detectable

     

       3
       3
       +
       template/** linguist-vendored

     

       4
       4
       +
       build.zig linguist-vendored

+14

.gitignore

···

       2
       2
        
       build

     

       3
       3
        
       input.txt

     

       4
       4
        
       input.json

     

       5
       5
       +
       input_example.txt

     

       6
       6
       +
       _build

     

       7
       7
       +
       target

     

       8
       8
       +
       zig-out

     

       9
       9
       +
       .zig-cache

     

       10
       10
       +
       out

     

       11
       11
       +
       *.ppm

     

       12
       12
       +
       *.pgm

     

       13
       13
       +
       *.pbm

     

       14
       14
       +
       *.bmp

     

       15
       15
       +
       *.png

     

       16
       16
       +
       *.gif

     

       17
       17
       +
       *.qoi

     

       18
       18
       +
       *.txt

+35

2015/1/elixir/main.exs

···

       1
       1
       +
       defmodule Main do

     

       2
       2
       +
         {_, input} =

     

       3
       3
       +
           File.read("../input.txt")

     

       4
       4
       +
       

     

       5
       5
       +
         input = input |> String.trim() |> String.graphemes()

     

       6
       6
       +
       

     

       7
       7
       +
         input

     

       8
       8
       +
         |> Enum.reduce(0, fn step, floor ->

     

       9
       9
       +
           case step do

     

       10
       10
       +
             "(" -> floor + 1

     

       11
       11
       +
             ")" -> floor - 1

     

       12
       12
       +
           end

     

       13
       13
       +
         end)

     

       14
       14
       +
         |> IO.puts()

     

       15
       15
       +
       

     

       16
       16
       +
         input

     

       17
       17
       +
         |> Enum.reduce_while({0, 0}, fn step, i_floor ->

     

       18
       18
       +
           {i, floor} = i_floor

     

       19
       19
       +
       

     

       20
       20
       +
           i = i + 1

     

       21
       21
       +
       

     

       22
       22
       +
           floor =

     

       23
       23
       +
             case step do

     

       24
       24
       +
               "(" -> 1

     

       25
       25
       +
               ")" -> -1

     

       26
       26
       +
             end + floor

     

       27
       27
       +
       

     

       28
       28
       +
           case floor do

     

       29
       29
       +
             -1 -> {:halt, {i, floor}}

     

       30
       30
       +
             _ -> {:cont, {i, floor}}

     

       31
       31
       +
           end

     

       32
       32
       +
         end)

     

       33
       33
       +
         |> elem(0)

     

       34
       34
       +
         |> IO.puts()

     

       35
       35
       +
       end

+32 -33

2015/1/gleam/src/main.gleam

···

       1
       1
       -
       import gleam/int.{to_string}

     

       2
       2
       -
       import gleam/io.{println}

     

       3
       3
       -
       import gleam/list.{Continue, Stop, fold, fold_until}

     

       4
       4
       -
       import gleam/result.{unwrap}

     

       5
       5
       -
       import gleam/string.{split, trim}

     

       6
       6
       -
       import simplifile.{read}

     

       1
       1
       +
       import gleam/int

     

       2
       2
       +
       import gleam/io

     

       3
       3
       +
       import gleam/list.{Continue, Stop, fold}

     

       4
       4
       +
       import gleam/string

     

       5
       5
       +
       import simplifile as file

     

       7
       6
        
       

     

       8
       7
        
       pub type FloorIndex {

     

       9
       8
        
         FloorIndex(floor: Int, index: Int)

     

       10
       9
        
       }

     

       11
       10
        
       

     

       12
       11
        
       pub fn main() {

     

       13
       13
       -
         let input = read(from: "../input.txt") |> unwrap("") |> trim() |> split("")

     

       12
       12
       +
         let assert Ok(input) = file.read(from: "../input.txt")

     

       13
       13
       +
         let input = input |> string.trim() |> string.split("")

     

       14
       14
       +
       

     

       15
       15
       +
         input

     

       16
       16
       +
         |> fold(0, fn(fl, cur) {

     

       17
       17
       +
           case cur {

     

       18
       18
       +
             "(" -> fl + 1

     

       19
       19
       +
             ")" -> fl - 1

     

       20
       20
       +
             ___ -> 0

     

       21
       21
       +
           }

     

       22
       22
       +
         })

     

       23
       23
       +
         |> int.to_string

     

       24
       24
       +
         |> io.println

     

       14
       25
        
       

     

       15
       15
       -
         // part 1 - get final floor

     

       16
       16
       -
         println(

     

       17
       17
       -
           fold(input, 0, fn(fl, cur) {

     

       18
       18
       -
             case cur {

     

       19
       19
       -
               "(" -> fl + 1

     

       20
       20
       -
               ")" -> fl - 1

     

       26
       26
       +
         // part 2 - get first time in the basement

     

       27
       27
       +
         let FloorIndex(_, index) =

     

       28
       28
       +
           input

     

       29
       29
       +
           |> list.fold_until(FloorIndex(0, 1), fn(fi, cur) {

     

       30
       30
       +
             let new = case cur {

     

       31
       31
       +
               "(" -> fi.floor + 1

     

       32
       32
       +
               ")" -> fi.floor - 1

     

       21
       33
        
               ___ -> 0

     

       22
       34
        
             }

     

       35
       35
       +
             case new < 0 {

     

       36
       36
       +
               True -> Stop(FloorIndex(new, fi.index))

     

       37
       37
       +
               False -> Continue(FloorIndex(new, fi.index + 1))

     

       38
       38
       +
             }

     

       23
       39
        
           })

     

       24
       24
       -
           |> to_string,

     

       25
       25
       -
         )

     

       26
       40
        
       

     

       27
       27
       -
         // part 2 - get first time in the basement

     

       28
       28
       -
         println(

     

       29
       29
       -
           {

     

       30
       30
       -
             input

     

       31
       31
       -
             |> fold_until(FloorIndex(0, 1), fn(fi, cur) {

     

       32
       32
       -
               let new = case cur {

     

       33
       33
       -
                 "(" -> fi.floor + 1

     

       34
       34
       -
                 ")" -> fi.floor - 1

     

       35
       35
       -
                 ___ -> 0

     

       36
       36
       -
               }

     

       37
       37
       -
               case new < 0 {

     

       38
       38
       -
                 True -> Stop(FloorIndex(new, fi.index))

     

       39
       39
       -
                 False -> Continue(FloorIndex(new, fi.index + 1))

     

       40
       40
       -
               }

     

       41
       41
       -
             })

     

       42
       42
       -
           }.index

     

       43
       43
       -
           |> to_string,

     

       44
       44
       -
         )

     

       41
       41
       +
         index

     

       42
       42
       +
         |> int.to_string

     

       43
       43
       +
         |> io.println

     

       45
       44
        
       }

+7

2015/1/rust/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

+6

2015/1/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+34

2015/1/rust/src/main.rs

···

       1
       1
       +
       use std::{fs, ops::ControlFlow};

     

       2
       2
       +
       

     

       3
       3
       +
       fn main() {

     

       4
       4
       +
           let input = fs::read_to_string("../input.txt").expect("invalid input");

     

       5
       5
       +
           let input = input.trim();

     

       6
       6
       +
       

     

       7
       7
       +
           let part1 = input.chars().fold(0, |floor, v| {

     

       8
       8
       +
               (match v {

     

       9
       9
       +
                   '(' => 1,

     

       10
       10
       +
                   ')' => -1,

     

       11
       11
       +
                   _ => 0,

     

       12
       12
       +
               }) + floor

     

       13
       13
       +
           });

     

       14
       14
       +
       

     

       15
       15
       +
           println!("{}", part1);

     

       16
       16
       +
       

     

       17
       17
       +
           let part2 = input.chars().try_fold((0, 1), |(floor, step), v| {

     

       18
       18
       +
               let floor = (match v {

     

       19
       19
       +
                   '(' => 1,

     

       20
       20
       +
                   ')' => -1,

     

       21
       21
       +
                   _ => 0,

     

       22
       22
       +
               }) + floor;

     

       23
       23
       +
               match floor {

     

       24
       24
       +
                   -1 => ControlFlow::Break(step),

     

       25
       25
       +
                   _ => ControlFlow::Continue((floor, step + 1)),

     

       26
       26
       +
               }

     

       27
       27
       +
           });

     

       28
       28
       +
           let part2 = match part2 {

     

       29
       29
       +
               ControlFlow::Break(part2) => part2,

     

       30
       30
       +
               ControlFlow::Continue(_) => panic!("bad input. never reached basement"),

     

       31
       31
       +
           };

     

       32
       32
       +
       

     

       33
       33
       +
           println!("{}", part2);

     

       34
       34
       +
       }

+20

2015/16/gleam/gleam.toml

···

       1
       1
       +
       name = "main"

     

       2
       2
       +
       version = "1.0.0"

     

       3
       3
       +
       

     

       4
       4
       +
       # Fill out these fields if you intend to generate HTML documentation or publish

     

       5
       5
       +
       # your project to the Hex package manager.

     

       6
       6
       +
       #

     

       7
       7
       +
       # description = ""

     

       8
       8
       +
       # licences = ["Apache-2.0"]

     

       9
       9
       +
       # repository = { type = "github", user = "", repo = "" }

     

       10
       10
       +
       # links = [{ title = "Website", href = "" }]

     

       11
       11
       +
       #

     

       12
       12
       +
       # For a full reference of all the available options, you can have a look at

     

       13
       13
       +
       # https://gleam.run/writing-gleam/gleam-toml/.

     

       14
       14
       +
       

     

       15
       15
       +
       [dependencies]

     

       16
       16
       +
       gleam_stdlib = ">= 0.44.0 and < 2.0.0"

     

       17
       17
       +
       simplifile = ">= 2.3.0 and < 3.0.0"

     

       18
       18
       +
       

     

       19
       19
       +
       [dev-dependencies]

     

       20
       20
       +
       gleeunit = ">= 1.0.0 and < 2.0.0"

+14

2015/16/gleam/manifest.toml

···

       1
       1
       +
       # This file was generated by Gleam

     

       2
       2
       +
       # You typically do not need to edit this file

     

       3
       3
       +
       

     

       4
       4
       +
       packages = [

     

       5
       5
       +
         { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },

     

       6
       6
       +
         { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },

     

       7
       7
       +
         { name = "gleeunit", version = "1.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "CD701726CBCE5588B375D157B4391CFD0F2F134CD12D9B6998A395484DE05C58" },

     

       8
       8
       +
         { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },

     

       9
       9
       +
       ]

     

       10
       10
       +
       

     

       11
       11
       +
       [requirements]

     

       12
       12
       +
       gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }

     

       13
       13
       +
       gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

     

       14
       14
       +
       simplifile = { version = ">= 2.3.0 and < 3.0.0" }

+100

2015/16/gleam/src/main.gleam

···

       1
       1
       +
       import gleam/dict

     

       2
       2
       +
       import gleam/int

     

       3
       3
       +
       import gleam/io

     

       4
       4
       +
       import gleam/list

     

       5
       5
       +
       import gleam/result

     

       6
       6
       +
       import gleam/string

     

       7
       7
       +
       import simplifile as file

     

       8
       8
       +
       

     

       9
       9
       +
       pub fn main() {

     

       10
       10
       +
         let assert Ok(right_sue) = file.read(from: "../sue.txt")

     

       11
       11
       +
           as "Sue file not found"

     

       12
       12
       +
         let right_sue =

     

       13
       13
       +
           right_sue

     

       14
       14
       +
           |> string.trim

     

       15
       15
       +
           |> string.split("\n")

     

       16
       16
       +
           |> list.map(fn(i) {

     

       17
       17
       +
             case string.split(i, " ") {

     

       18
       18
       +
               [item, amount] -> #(

     

       19
       19
       +
                 string.drop_end(item, 1),

     

       20
       20
       +
                 int.parse(amount) |> result.unwrap(0),

     

       21
       21
       +
               )

     

       22
       22
       +
               _ -> #("", 0)

     

       23
       23
       +
             }

     

       24
       24
       +
           })

     

       25
       25
       +
           |> dict.from_list

     

       26
       26
       +
       

     

       27
       27
       +
         let assert Ok(input) = file.read(from: "../input.txt")

     

       28
       28
       +
           as "Input file not found"

     

       29
       29
       +
         let input =

     

       30
       30
       +
           input

     

       31
       31
       +
           |> string.trim

     

       32
       32
       +
           |> string.split("\n")

     

       33
       33
       +
           |> list.map(fn(i) {

     

       34
       34
       +
             case string.split(i, " ") {

     

       35
       35
       +
               [_, n, item1, amount1, item2, amount2, item3, amount3] -> #(

     

       36
       36
       +
                 string.drop_end(n, 1) |> int.parse |> result.unwrap(0),

     

       37
       37
       +
                 [

     

       38
       38
       +
                   #(

     

       39
       39
       +
                     string.drop_end(item1, 1),

     

       40
       40
       +
                     string.drop_end(amount1, 1) |> int.parse |> result.unwrap(0),

     

       41
       41
       +
                   ),

     

       42
       42
       +
                   #(

     

       43
       43
       +
                     string.drop_end(item2, 1),

     

       44
       44
       +
                     string.drop_end(amount2, 1) |> int.parse |> result.unwrap(0),

     

       45
       45
       +
                   ),

     

       46
       46
       +
                   #(

     

       47
       47
       +
                     string.drop_end(item3, 1),

     

       48
       48
       +
                     amount3 |> int.parse |> result.unwrap(0),

     

       49
       49
       +
                   ),

     

       50
       50
       +
                 ],

     

       51
       51
       +
               )

     

       52
       52
       +
               _ -> #(0, [#("", 0), #("", 0), #("", 0)])

     

       53
       53
       +
             }

     

       54
       54
       +
           })

     

       55
       55
       +
           |> dict.from_list

     

       56
       56
       +
       

     

       57
       57
       +
         // part 1

     

       58
       58
       +
         input

     

       59
       59
       +
         |> dict.fold(0, fn(right, sue, items) {

     

       60
       60
       +
           let total_right =

     

       61
       61
       +
             items

     

       62
       62
       +
             |> list.fold_until(0, fn(total_right, item) {

     

       63
       63
       +
               case item.1 == dict.get(right_sue, item.0) |> result.unwrap(-10) {

     

       64
       64
       +
                 True -> list.Continue(total_right + 1)

     

       65
       65
       +
                 False -> list.Stop(total_right)

     

       66
       66
       +
               }

     

       67
       67
       +
             })

     

       68
       68
       +
           case total_right {

     

       69
       69
       +
             3 -> sue

     

       70
       70
       +
             _ -> right

     

       71
       71
       +
           }

     

       72
       72
       +
         })

     

       73
       73
       +
         |> int.to_string

     

       74
       74
       +
         |> io.println

     

       75
       75
       +
       

     

       76
       76
       +
         // part 2

     

       77
       77
       +
         input

     

       78
       78
       +
         |> dict.fold(0, fn(right, sue, items) {

     

       79
       79
       +
           let total_right =

     

       80
       80
       +
             items

     

       81
       81
       +
             |> list.fold_until(0, fn(total_right, item) {

     

       82
       82
       +
               let right_value = dict.get(right_sue, item.0) |> result.unwrap(-10)

     

       83
       83
       +
               let comp = case item.0 {

     

       84
       84
       +
                 "cats" | "trees" -> item.1 > right_value

     

       85
       85
       +
                 "pomeranians" | "goldfish" -> item.1 < right_value

     

       86
       86
       +
                 _ -> item.1 == right_value

     

       87
       87
       +
               }

     

       88
       88
       +
               case comp {

     

       89
       89
       +
                 True -> list.Continue(total_right + 1)

     

       90
       90
       +
                 False -> list.Stop(total_right)

     

       91
       91
       +
               }

     

       92
       92
       +
             })

     

       93
       93
       +
           case total_right {

     

       94
       94
       +
             3 -> sue

     

       95
       95
       +
             _ -> right

     

       96
       96
       +
           }

     

       97
       97
       +
         })

     

       98
       98
       +
         |> int.to_string

     

       99
       99
       +
         |> io.println

     

       100
       100
       +
       }

+20

2015/17/gleam/gleam.toml

···

       1
       1
       +
       name = "main"

     

       2
       2
       +
       version = "1.0.0"

     

       3
       3
       +
       

     

       4
       4
       +
       # Fill out these fields if you intend to generate HTML documentation or publish

     

       5
       5
       +
       # your project to the Hex package manager.

     

       6
       6
       +
       #

     

       7
       7
       +
       # description = ""

     

       8
       8
       +
       # licences = ["Apache-2.0"]

     

       9
       9
       +
       # repository = { type = "github", user = "", repo = "" }

     

       10
       10
       +
       # links = [{ title = "Website", href = "" }]

     

       11
       11
       +
       #

     

       12
       12
       +
       # For a full reference of all the available options, you can have a look at

     

       13
       13
       +
       # https://gleam.run/writing-gleam/gleam-toml/.

     

       14
       14
       +
       

     

       15
       15
       +
       [dependencies]

     

       16
       16
       +
       gleam_stdlib = ">= 0.44.0 and < 2.0.0"

     

       17
       17
       +
       simplifile = ">= 2.3.0 and < 3.0.0"

     

       18
       18
       +
       

     

       19
       19
       +
       [dev-dependencies]

     

       20
       20
       +
       gleeunit = ">= 1.0.0 and < 2.0.0"

+14

2015/17/gleam/manifest.toml

···

       1
       1
       +
       # This file was generated by Gleam

     

       2
       2
       +
       # You typically do not need to edit this file

     

       3
       3
       +
       

     

       4
       4
       +
       packages = [

     

       5
       5
       +
         { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },

     

       6
       6
       +
         { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },

     

       7
       7
       +
         { name = "gleeunit", version = "1.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "CD701726CBCE5588B375D157B4391CFD0F2F134CD12D9B6998A395484DE05C58" },

     

       8
       8
       +
         { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },

     

       9
       9
       +
       ]

     

       10
       10
       +
       

     

       11
       11
       +
       [requirements]

     

       12
       12
       +
       gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }

     

       13
       13
       +
       gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

     

       14
       14
       +
       simplifile = { version = ">= 2.3.0 and < 3.0.0" }

+82

2015/17/gleam/src/main.gleam

···

       1
       1
       +
       import gleam/dict

     

       2
       2
       +
       import gleam/int

     

       3
       3
       +
       import gleam/io

     

       4
       4
       +
       import gleam/list

     

       5
       5
       +
       import gleam/result

     

       6
       6
       +
       import gleam/string

     

       7
       7
       +
       import simplifile as file

     

       8
       8
       +
       

     

       9
       9
       +
       fn check_containers_part1(input, remaining, right_options) {

     

       10
       10
       +
         case remaining {

     

       11
       11
       +
           0 -> right_options + 1

     

       12
       12
       +
           r if r < 0 -> right_options

     

       13
       13
       +
           _ -> {

     

       14
       14
       +
             let #(_, right_options) =

     

       15
       15
       +
               input

     

       16
       16
       +
               |> dict.fold(#(input, right_options), fn(acc, cid, cv) {

     

       17
       17
       +
                 let #(input, right_options) = acc

     

       18
       18
       +
                 let input = input |> dict.delete(cid)

     

       19
       19
       +
                 #(input, check_containers_part1(input, remaining - cv, right_options))

     

       20
       20
       +
               })

     

       21
       21
       +
             right_options

     

       22
       22
       +
           }

     

       23
       23
       +
         }

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       fn check_containers_part2(input, remaining, right_options, jars_used) {

     

       27
       27
       +
         case remaining {

     

       28
       28
       +
           0 ->

     

       29
       29
       +
             right_options

     

       30
       30
       +
             |> dict.insert(

     

       31
       31
       +
               jars_used,

     

       32
       32
       +
               { dict.get(right_options, jars_used) |> result.unwrap(0) } + 1,

     

       33
       33
       +
             )

     

       34
       34
       +
           r if r < 0 -> right_options

     

       35
       35
       +
           _ -> {

     

       36
       36
       +
             let #(_, right_options) =

     

       37
       37
       +
               input

     

       38
       38
       +
               |> dict.fold(#(input, right_options), fn(acc, cid, cv) {

     

       39
       39
       +
                 let #(input, right_options) = acc

     

       40
       40
       +
                 let input = input |> dict.delete(cid)

     

       41
       41
       +
                 #(

     

       42
       42
       +
                   input,

     

       43
       43
       +
                   check_containers_part2(

     

       44
       44
       +
                     input,

     

       45
       45
       +
                     remaining - cv,

     

       46
       46
       +
                     right_options,

     

       47
       47
       +
                     jars_used + 1,

     

       48
       48
       +
                   ),

     

       49
       49
       +
                 )

     

       50
       50
       +
               })

     

       51
       51
       +
             right_options

     

       52
       52
       +
           }

     

       53
       53
       +
         }

     

       54
       54
       +
       }

     

       55
       55
       +
       

     

       56
       56
       +
       pub fn main() {

     

       57
       57
       +
         let assert Ok(input) = file.read(from: "../input.txt")

     

       58
       58
       +
           as "Input file not found"

     

       59
       59
       +
         let #(input, _) =

     

       60
       60
       +
           input

     

       61
       61
       +
           |> string.trim

     

       62
       62
       +
           |> string.split("\n")

     

       63
       63
       +
           |> list.fold(#(dict.new(), 1), fn(l, v) {

     

       64
       64
       +
             #(dict.insert(l.0, l.1, int.parse(v) |> result.unwrap(0)), l.1 + 1)

     

       65
       65
       +
           })

     

       66
       66
       +
       

     

       67
       67
       +
         check_containers_part1(input, 150, 0)

     

       68
       68
       +
         |> int.to_string

     

       69
       69
       +
         |> io.println

     

       70
       70
       +
       

     

       71
       71
       +
         let #(_number_of_jars, possibilities) =

     

       72
       72
       +
           check_containers_part2(input, 150, dict.new(), 0)

     

       73
       73
       +
           |> dict.fold(#(999_999, 0), fn(last, number_of_jars, possibilities) {

     

       74
       74
       +
             case last.0 > number_of_jars {

     

       75
       75
       +
               True -> #(number_of_jars, possibilities)

     

       76
       76
       +
               False -> last

     

       77
       77
       +
             }

     

       78
       78
       +
           })

     

       79
       79
       +
         possibilities

     

       80
       80
       +
         |> int.to_string

     

       81
       81
       +
         |> io.println

     

       82
       82
       +
       }

+20

2015/18/gleam/gleam.toml

···

       1
       1
       +
       name = "main"

     

       2
       2
       +
       version = "1.0.0"

     

       3
       3
       +
       

     

       4
       4
       +
       # Fill out these fields if you intend to generate HTML documentation or publish

     

       5
       5
       +
       # your project to the Hex package manager.

     

       6
       6
       +
       #

     

       7
       7
       +
       # description = ""

     

       8
       8
       +
       # licences = ["Apache-2.0"]

     

       9
       9
       +
       # repository = { type = "github", user = "", repo = "" }

     

       10
       10
       +
       # links = [{ title = "Website", href = "" }]

     

       11
       11
       +
       #

     

       12
       12
       +
       # For a full reference of all the available options, you can have a look at

     

       13
       13
       +
       # https://gleam.run/writing-gleam/gleam-toml/.

     

       14
       14
       +
       

     

       15
       15
       +
       [dependencies]

     

       16
       16
       +
       gleam_stdlib = ">= 0.44.0 and < 2.0.0"

     

       17
       17
       +
       simplifile = ">= 2.3.0 and < 3.0.0"

     

       18
       18
       +
       

     

       19
       19
       +
       [dev-dependencies]

     

       20
       20
       +
       gleeunit = ">= 1.0.0 and < 2.0.0"

+14

2015/18/gleam/manifest.toml

···

       1
       1
       +
       # This file was generated by Gleam

     

       2
       2
       +
       # You typically do not need to edit this file

     

       3
       3
       +
       

     

       4
       4
       +
       packages = [

     

       5
       5
       +
         { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },

     

       6
       6
       +
         { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },

     

       7
       7
       +
         { name = "gleeunit", version = "1.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "CD701726CBCE5588B375D157B4391CFD0F2F134CD12D9B6998A395484DE05C58" },

     

       8
       8
       +
         { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },

     

       9
       9
       +
       ]

     

       10
       10
       +
       

     

       11
       11
       +
       [requirements]

     

       12
       12
       +
       gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }

     

       13
       13
       +
       gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

     

       14
       14
       +
       simplifile = { version = ">= 2.3.0 and < 3.0.0" }

+90

2015/18/gleam/src/main.gleam

···

       1
       1
       +
       import gleam/bit_array

     

       2
       2
       +
       import gleam/int

     

       3
       3
       +
       import gleam/io

     

       4
       4
       +
       import gleam/list

     

       5
       5
       +
       import gleam/result

     

       6
       6
       +
       import gleam/string

     

       7
       7
       +
       import simplifile as file

     

       8
       8
       +
       

     

       9
       9
       +
       fn generation(input: BitArray, size: Int, stuck: Bool) {

     

       10
       10
       +
         let get_place = fn(x, y) {

     

       11
       11
       +
           case

     

       12
       12
       +
             case stuck, x, y {

     

       13
       13
       +
               True, 0, 0 -> <<"#">>

     

       14
       14
       +
               True, 0, s | True, s, 0 if s == size - 1 -> <<"#">>

     

       15
       15
       +
               True, s1, s2 if s1 == size - 1 && s1 == s2 -> <<"#">>

     

       16
       16
       +
       

     

       17
       17
       +
               _, _, -1 | _, -1, _ -> <<>>

     

       18
       18
       +
               _, s, _ | _, _, s if s == size -> <<>>

     

       19
       19
       +
       

     

       20
       20
       +
               _, _, _ ->

     

       21
       21
       +
                 bit_array.slice(input, y * size + x, 1) |> result.unwrap(<<>>)

     

       22
       22
       +
             }

     

       23
       23
       +
           {

     

       24
       24
       +
             <<"#">> -> 1

     

       25
       25
       +
             _ -> 0

     

       26
       26
       +
           }

     

       27
       27
       +
         }

     

       28
       28
       +
       

     

       29
       29
       +
         list.range(0, bit_array.byte_size(input) - 1)

     

       30
       30
       +
         |> list.fold(<<>>, fn(res, pos) {

     

       31
       31
       +
           let x = pos % size

     

       32
       32
       +
           let y = pos / size

     

       33
       33
       +
       

     

       34
       34
       +
           let cell = get_place(x, y)

     

       35
       35
       +
       

     

       36
       36
       +
           let neighbours =

     

       37
       37
       +
             get_place(x - 1, y - 1)

     

       38
       38
       +
             + get_place(x, y - 1)

     

       39
       39
       +
             + get_place(x + 1, y - 1)

     

       40
       40
       +
             + get_place(x - 1, y)

     

       41
       41
       +
             + get_place(x + 1, y)

     

       42
       42
       +
             + get_place(x - 1, y + 1)

     

       43
       43
       +
             + get_place(x, y + 1)

     

       44
       44
       +
             + get_place(x + 1, y + 1)

     

       45
       45
       +
       

     

       46
       46
       +
           bit_array.append(res, case stuck, x, y {

     

       47
       47
       +
             True, 0, 0 -> <<"#">>

     

       48
       48
       +
             True, 0, s | True, s, 0 if s == size - 1 -> <<"#">>

     

       49
       49
       +
             True, s1, s2 if s1 == size - 1 && s1 == s2 -> <<"#">>

     

       50
       50
       +
       

     

       51
       51
       +
             _, _, _ ->

     

       52
       52
       +
               case cell, neighbours {

     

       53
       53
       +
                 _, 3 | 1, 2 -> <<"#">>

     

       54
       54
       +
                 _, _ -> <<".">>

     

       55
       55
       +
               }

     

       56
       56
       +
           })

     

       57
       57
       +
         })

     

       58
       58
       +
       }

     

       59
       59
       +
       

     

       60
       60
       +
       fn check_lights_on(input: BitArray) {

     

       61
       61
       +
         list.range(0, bit_array.byte_size(input) - 1)

     

       62
       62
       +
         |> list.fold(0, fn(res, pos) {

     

       63
       63
       +
           let assert Ok(cell) = bit_array.slice(input, pos, 1)

     

       64
       64
       +
           case cell {

     

       65
       65
       +
             <<"#">> -> res + 1

     

       66
       66
       +
             _ -> res

     

       67
       67
       +
           }

     

       68
       68
       +
         })

     

       69
       69
       +
       }

     

       70
       70
       +
       

     

       71
       71
       +
       pub fn main() {

     

       72
       72
       +
         let assert Ok(input) = file.read(from: "../input.txt")

     

       73
       73
       +
           as "Input file not found"

     

       74
       74
       +
         let input =

     

       75
       75
       +
           input |> string.trim |> string.split("\n") |> list.map(fn(v) { <<v:utf8>> })

     

       76
       76
       +
         let size = list.length(input)

     

       77
       77
       +
         let input = input |> list.fold(<<>>, fn(acc, l) { bit_array.append(acc, l) })

     

       78
       78
       +
       

     

       79
       79
       +
         list.range(1, 100)

     

       80
       80
       +
         |> list.fold(input, fn(last, _) { generation(last, size, False) })

     

       81
       81
       +
         |> check_lights_on

     

       82
       82
       +
         |> int.to_string

     

       83
       83
       +
         |> io.println

     

       84
       84
       +
       

     

       85
       85
       +
         list.range(1, 100)

     

       86
       86
       +
         |> list.fold(input, fn(last, _) { generation(last, size, True) })

     

       87
       87
       +
         |> check_lights_on

     

       88
       88
       +
         |> int.to_string

     

       89
       89
       +
         |> io.println

     

       90
       90
       +
       }

+7

2015/18/rust/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

+6

2015/18/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+90

2015/18/rust/src/main.rs

···

       1
       1
       +
       use std::mem::swap;

     

       2
       2
       +
       

     

       3
       3
       +
       fn generations(

     

       4
       4
       +
           times: u32,

     

       5
       5
       +
           mut world: Vec<u8>,

     

       6
       6
       +
           size: usize,

     

       7
       7
       +
           stuck: bool,

     

       8
       8
       +
       ) -> Vec<u8> {

     

       9
       9
       +
           let pos = |x, y| y * (size + 2) + x;

     

       10
       10
       +
       

     

       11
       11
       +
           let sizep = size + 1;

     

       12
       12
       +
       

     

       13
       13
       +
           let mut new_world = vec![0_u8; (size + 2).pow(2)];

     

       14
       14
       +
       

     

       15
       15
       +
           unsafe {

     

       16
       16
       +
               if stuck {

     

       17
       17
       +
                   *world.get_unchecked_mut(pos(1, 1)) = 1;

     

       18
       18
       +
                   *world.get_unchecked_mut(pos(size, 1)) = 1;

     

       19
       19
       +
                   *world.get_unchecked_mut(pos(1, size)) = 1;

     

       20
       20
       +
                   *world.get_unchecked_mut(pos(size, size)) = 1;

     

       21
       21
       +
               }

     

       22
       22
       +
           }

     

       23
       23
       +
       

     

       24
       24
       +
           for _ in 0..times {

     

       25
       25
       +
               for yo in 1..sizep {

     

       26
       26
       +
                   let ym = yo - 1;

     

       27
       27
       +
                   let yp = yo + 1;

     

       28
       28
       +
                   for xo in 1..sizep {

     

       29
       29
       +
                       let xm = xo - 1;

     

       30
       30
       +
                       let xp = xo + 1;

     

       31
       31
       +
       

     

       32
       32
       +
                       unsafe {

     

       33
       33
       +
                           let was = *world.get_unchecked(pos(xo, yo)) == 1_u8;

     

       34
       34
       +
                           let neighbours = world.get_unchecked(pos(xm, ym))

     

       35
       35
       +
                               + world.get_unchecked(pos(xo, ym))

     

       36
       36
       +
                               + world.get_unchecked(pos(xp, ym))

     

       37
       37
       +
                               + world.get_unchecked(pos(xm, yo))

     

       38
       38
       +
                               + world.get_unchecked(pos(xp, yo))

     

       39
       39
       +
                               + world.get_unchecked(pos(xm, yp))

     

       40
       40
       +
                               + world.get_unchecked(pos(xo, yp))

     

       41
       41
       +
                               + world.get_unchecked(pos(xp, yp));

     

       42
       42
       +
                           *new_world.get_unchecked_mut(pos(xo, yo)) =

     

       43
       43
       +
                               (neighbours == 3 || (neighbours == 2 && was)) as u8;

     

       44
       44
       +
                       }

     

       45
       45
       +
                   }

     

       46
       46
       +
               }

     

       47
       47
       +
       

     

       48
       48
       +
               swap(&mut world, &mut new_world);

     

       49
       49
       +
       

     

       50
       50
       +
               // i hate the duplication here :(

     

       51
       51
       +
               unsafe {

     

       52
       52
       +
                   if stuck {

     

       53
       53
       +
                       *world.get_unchecked_mut(pos(1, 1)) = 1;

     

       54
       54
       +
                       *world.get_unchecked_mut(pos(size, 1)) = 1;

     

       55
       55
       +
                       *world.get_unchecked_mut(pos(1, size)) = 1;

     

       56
       56
       +
                       *world.get_unchecked_mut(pos(size, size)) = 1;

     

       57
       57
       +
                   }

     

       58
       58
       +
               }

     

       59
       59
       +
           }

     

       60
       60
       +
           world

     

       61
       61
       +
       }

     

       62
       62
       +
       

     

       63
       63
       +
       fn main() {

     

       64
       64
       +
           let input = include_str!("../../input.txt").trim();

     

       65
       65
       +
           let size = input.split_once("\n").expect("invalid input").0.len();

     

       66
       66
       +
           // reads the input but adds a line of buffer on the sides

     

       67
       67
       +
           let buffer_line = ".".repeat(size);

     

       68
       68
       +
           let input: Vec<u8> = format!("{buffer_line}\n{input}\n{buffer_line}")

     

       69
       69
       +
               .split("\n")

     

       70
       70
       +
               .map(|line| -> Vec<u8> {

     

       71
       71
       +
                   format!(".{}.", line)

     

       72
       72
       +
                       .chars()

     

       73
       73
       +
                       .map(|v| (v == '#') as u8)

     

       74
       74
       +
                       .collect()

     

       75
       75
       +
               })

     

       76
       76
       +
               .flatten()

     

       77
       77
       +
               .collect();

     

       78
       78
       +
       

     

       79
       79
       +
           let part_1 = generations(100, input.clone(), size, false)

     

       80
       80
       +
               .iter()

     

       81
       81
       +
               .filter(|v| **v == 1)

     

       82
       82
       +
               .count();

     

       83
       83
       +
           println!("Part 1: {}", part_1);

     

       84
       84
       +
       

     

       85
       85
       +
           let part_2 = generations(100, input.clone(), size, true)

     

       86
       86
       +
               .iter()

     

       87
       87
       +
               .filter(|v| **v == 1)

     

       88
       88
       +
               .count();

     

       89
       89
       +
           println!("Part 2: {}", part_2);

     

       90
       90
       +
       }

+20

2015/19/gleam/gleam.toml

···

       1
       1
       +
       name = "main"

     

       2
       2
       +
       version = "1.0.0"

     

       3
       3
       +
       

     

       4
       4
       +
       # Fill out these fields if you intend to generate HTML documentation or publish

     

       5
       5
       +
       # your project to the Hex package manager.

     

       6
       6
       +
       #

     

       7
       7
       +
       # description = ""

     

       8
       8
       +
       # licences = ["Apache-2.0"]

     

       9
       9
       +
       # repository = { type = "github", user = "", repo = "" }

     

       10
       10
       +
       # links = [{ title = "Website", href = "" }]

     

       11
       11
       +
       #

     

       12
       12
       +
       # For a full reference of all the available options, you can have a look at

     

       13
       13
       +
       # https://gleam.run/writing-gleam/gleam-toml/.

     

       14
       14
       +
       

     

       15
       15
       +
       [dependencies]

     

       16
       16
       +
       gleam_stdlib = ">= 0.44.0 and < 2.0.0"

     

       17
       17
       +
       simplifile = ">= 2.3.0 and < 3.0.0"

     

       18
       18
       +
       

     

       19
       19
       +
       [dev-dependencies]

     

       20
       20
       +
       gleeunit = ">= 1.0.0 and < 2.0.0"

+14

2015/19/gleam/manifest.toml

···

       1
       1
       +
       # This file was generated by Gleam

     

       2
       2
       +
       # You typically do not need to edit this file

     

       3
       3
       +
       

     

       4
       4
       +
       packages = [

     

       5
       5
       +
         { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },

     

       6
       6
       +
         { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },

     

       7
       7
       +
         { name = "gleeunit", version = "1.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "CD701726CBCE5588B375D157B4391CFD0F2F134CD12D9B6998A395484DE05C58" },

     

       8
       8
       +
         { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },

     

       9
       9
       +
       ]

     

       10
       10
       +
       

     

       11
       11
       +
       [requirements]

     

       12
       12
       +
       gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }

     

       13
       13
       +
       gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

     

       14
       14
       +
       simplifile = { version = ">= 2.3.0 and < 3.0.0" }

+55

2015/19/gleam/src/main.gleam

···

       1
       1
       +
       import gleam/dict.{type Dict}

     

       2
       2
       +
       import gleam/int

     

       3
       3
       +
       import gleam/io

     

       4
       4
       +
       import gleam/list

     

       5
       5
       +
       import gleam/result

     

       6
       6
       +
       import gleam/set.{type Set}

     

       7
       7
       +
       import gleam/string

     

       8
       8
       +
       import simplifile as file

     

       9
       9
       +
       

     

       10
       10
       +
       type Results =

     

       11
       11
       +
         Set(String)

     

       12
       12
       +
       

     

       13
       13
       +
       type Combinations =

     

       14
       14
       +
         Dict(String, Results)

     

       15
       15
       +
       

     

       16
       16
       +
       pub fn main() {

     

       17
       17
       +
         let assert Ok(input) = file.read(from: "../input.txt")

     

       18
       18
       +
           as "Input file not found"

     

       19
       19
       +
         let input = input |> string.trim |> string.split("\n") |> list.reverse

     

       20
       20
       +
         let combinations: Combinations =

     

       21
       21
       +
           input

     

       22
       22
       +
           |> list.drop(2)

     

       23
       23
       +
           |> list.map(fn(v) {

     

       24
       24
       +
             case v |> string.split(" ") {

     

       25
       25
       +
               [origin, _, result] -> #(origin, result)

     

       26
       26
       +
               _ -> #("", "")

     

       27
       27
       +
             }

     

       28
       28
       +
           })

     

       29
       29
       +
           |> list.fold(dict.new(), fn(acc, v) {

     

       30
       30
       +
             acc

     

       31
       31
       +
             |> dict.get(v.0)

     

       32
       32
       +
             |> result.unwrap(set.new())

     

       33
       33
       +
             |> set.insert(v.1)

     

       34
       34
       +
             |> dict.insert(acc, v.0, _)

     

       35
       35
       +
           })

     

       36
       36
       +
         let molecule = {

     

       37
       37
       +
           let molecule =

     

       38
       38
       +
             input

     

       39
       39
       +
             |> list.first

     

       40
       40
       +
             |> result.unwrap("")

     

       41
       41
       +
             |> string.to_graphemes

     

       42
       42
       +
             |> list.fold(#(list.new(), ""), fn(acc, letter) {

     

       43
       43
       +
               case letter == string.lowercase(letter) {

     

       44
       44
       +
                 True -> #(acc.0, acc.1 <> letter)

     

       45
       45
       +
                 False -> #(list.append(acc.0, [acc.1]), letter)

     

       46
       46
       +
               }

     

       47
       47
       +
             })

     

       48
       48
       +
           molecule.0 |> list.drop(1) |> list.append([molecule.1])

     

       49
       49
       +
         }

     

       50
       50
       +
         let part_1_res = {

     

       51
       51
       +
           list.range(1, list.length(molecule)) |> list.fold(set.new(), fn(acc, v) {

     

       52
       52
       +
             

     

       53
       53
       +
           })

     

       54
       54
       +
         }

     

       55
       55
       +
       }

+7

2015/19/rust/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

+6

2015/19/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+44

2015/19/rust/src/main.rs

···

       1
       1
       +
       use std::collections::{HashMap, HashSet};

     

       2
       2
       +
       

     

       3
       3
       +
       fn main() {

     

       4
       4
       +
           let input = include_str!("../../input.txt");

     

       5
       5
       +
           let input: Vec<&str> = input.trim().split("\n").collect();

     

       6
       6
       +
       

     

       7
       7
       +
           let combinations: HashMap<String, Vec<String>> = {

     

       8
       8
       +
               let mut combinations = HashMap::new();

     

       9
       9
       +
               input[..input.len() - 2].iter().for_each(|v| {

     

       10
       10
       +
                   let v: Vec<&str> = v.split(" ").collect();

     

       11
       11
       +
                   match v[..] {

     

       12
       12
       +
                       [original, "=>", target] => {

     

       13
       13
       +
                           let entry = combinations

     

       14
       14
       +
                               .entry(original.to_string())

     

       15
       15
       +
                               .or_insert(Vec::with_capacity(1));

     

       16
       16
       +
                           entry.push(target.to_string());

     

       17
       17
       +
                       }

     

       18
       18
       +
                       _ => panic!("{:?}", v),

     

       19
       19
       +
                   }

     

       20
       20
       +
               });

     

       21
       21
       +
               combinations

     

       22
       22
       +
           };

     

       23
       23
       +
       

     

       24
       24
       +
           let medicine_mol = input.last().unwrap();

     

       25
       25
       +
       

     

       26
       26
       +
           // part 1

     

       27
       27
       +
           {

     

       28
       28
       +
               let mol_len = medicine_mol.len();

     

       29
       29
       +
               let mut possibilities: HashSet<String> = HashSet::new();

     

       30
       30
       +
               for i in 0..mol_len {

     

       31
       31
       +
                   let (a, b) = medicine_mol.split_at(i);

     

       32
       32
       +
                   combinations.iter().for_each(|(from, to)| {

     

       33
       33
       +
                       to.iter().for_each(|to| {

     

       34
       34
       +
                           possibilities.insert(format!(

     

       35
       35
       +
                               "{}{}",

     

       36
       36
       +
                               a,

     

       37
       37
       +
                               b.replacen(from, to, 1)

     

       38
       38
       +
                           ));

     

       39
       39
       +
                       })

     

       40
       40
       +
                   });

     

       41
       41
       +
               }

     

       42
       42
       +
               println!("Part 1: {}", possibilities.len() - 1)

     

       43
       43
       +
           }

     

       44
       44
       +
       }

+30

2015/2/elixir/main.exs

···

       1
       1
       +
       defmodule Main do

     

       2
       2
       +
         {_, input} =

     

       3
       3
       +
           File.read("../input.txt")

     

       4
       4
       +
       

     

       5
       5
       +
         input =

     

       6
       6
       +
           input

     

       7
       7
       +
           |> String.trim()

     

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

     

       9
       9
       +
           |> Enum.map(fn v ->

     

       10
       10
       +
             v |> String.split("x") |> Enum.map(fn v -> String.to_integer(v) end)

     

       11
       11
       +
           end)

     

       12
       12
       +
       

     

       13
       13
       +
         input

     

       14
       14
       +
         |> Enum.reduce(0, fn v, acc ->

     

       15
       15
       +
           [l, w, h] = v

     

       16
       16
       +
           sides = [l * w, w * h, h * l]

     

       17
       17
       +
           acc + Enum.sum(sides) * 2 + Enum.min(sides)

     

       18
       18
       +
         end)

     

       19
       19
       +
         |> IO.puts()

     

       20
       20
       +
       

     

       21
       21
       +
         input

     

       22
       22
       +
         |> Enum.reduce(0, fn measure, acc ->

     

       23
       23
       +
           [l, w, h] = measure

     

       24
       24
       +
           half_perimeter = [l + w, w + h, h + l]

     

       25
       25
       +
       

     

       26
       26
       +
           acc + Enum.reduce(measure, fn a, b -> a * b end) +

     

       27
       27
       +
             Enum.min(half_perimeter) * 2

     

       28
       28
       +
         end)

     

       29
       29
       +
         |> IO.puts()

     

       30
       30
       +
       end

+38 -42

2015/2/gleam/src/main.gleam

···

       1
       1
       -
       import gleam/int.{add, min, multiply, to_string}

     

       2
       2
       -
       import gleam/io.{println}

     

       3
       3
       -
       import gleam/list.{combinations, fold, map, reduce}

     

       4
       4
       -
       import gleam/result.{unwrap}

     

       5
       5
       -
       import gleam/string.{split, trim}

     

       6
       6
       -
       import simplifile.{read}

     

       1
       1
       +
       import gleam/int

     

       2
       2
       +
       import gleam/io

     

       3
       3
       +
       import gleam/list

     

       4
       4
       +
       import gleam/result

     

       5
       5
       +
       import gleam/string

     

       6
       6
       +
       import simplifile as file

     

       7
       7
        
       

     

       8
       8
        
       pub fn main() {

     

       9
       9
        
         let input =

     

       10
       10
       -
           read(from: "../input.txt")

     

       11
       11
       -
           |> unwrap("")

     

       12
       12
       -
           |> trim()

     

       13
       13
       -
           |> split("\n")

     

       14
       14
       -
           |> map(fn(str) {

     

       15
       15
       -
             split(str, "x")

     

       16
       16
       -
             |> map(fn(str) { int.base_parse(str, 10) |> unwrap(0) })

     

       10
       10
       +
           file.read(from: "../input.txt")

     

       11
       11
       +
           |> result.unwrap("")

     

       12
       12
       +
           |> string.trim

     

       13
       13
       +
           |> string.split("\n")

     

       14
       14
       +
           |> list.map(fn(str) {

     

       15
       15
       +
             string.split(str, "x")

     

       16
       16
       +
             |> list.map(fn(str) { int.base_parse(str, 10) |> result.unwrap(0) })

     

       17
       17
        
           })

     

       18
       18
        
       

     

       19
       19
        
         // part 1

     

       20
       20
       -
         println(

     

       21
       21
       -
           input

     

       22
       22
       -
           |> fold(0, fn(prev, cur) {

     

       23
       23
       -
             let sides =

     

       24
       24
       -
               cur

     

       25
       25
       -
               |> combinations(2)

     

       26
       26
       -
               |> map(fn(v) { fold(v, 1, multiply) })

     

       20
       20
       +
         input

     

       21
       21
       +
         |> list.fold(0, fn(acc, cur) {

     

       22
       22
       +
           let sides =

     

       23
       23
       +
             cur

     

       24
       24
       +
             |> list.combinations(2)

     

       25
       25
       +
             |> list.map(fn(v) { list.fold(v, 1, int.multiply) })

     

       27
       26
        
       

     

       28
       28
       -
             prev

     

       29
       29
       -
             + fold(sides, 0, fn(prev, cur) { prev + 2 * cur })

     

       30
       30
       -
             + { reduce(sides, min) |> unwrap(0) }

     

       31
       31
       -
           })

     

       32
       32
       -
           |> to_string,

     

       33
       33
       -
         )

     

       27
       27
       +
           acc

     

       28
       28
       +
           + { list.fold(sides, 0, int.add) |> int.multiply(2) }

     

       29
       29
       +
           + { list.reduce(sides, int.min) |> result.unwrap(0) }

     

       30
       30
       +
         })

     

       31
       31
       +
         |> int.to_string

     

       32
       32
       +
         |> io.println

     

       34
       33
        
       

     

       35
       34
        
         // part 2

     

       36
       36
       -
         println(

     

       37
       37
       -
           input

     

       38
       38
       -
           |> fold(0, fn(prev, cur) {

     

       39
       39
       -
             let smallest_perimeter =

     

       40
       40
       -
               reduce(

     

       41
       41
       -
                 cur

     

       42
       42
       -
                   |> map(fn(v) { multiply(v, 2) })

     

       43
       43
       -
                   |> combinations(2)

     

       44
       44
       -
                   |> map(fn(v) { fold(v, 0, add) }),

     

       45
       45
       -
                 min,

     

       46
       46
       -
               )

     

       47
       47
       -
               |> unwrap(0)

     

       35
       35
       +
         input

     

       36
       36
       +
         |> list.fold(0, fn(acc, cur) {

     

       37
       37
       +
           let smallest_perimeter =

     

       38
       38
       +
             cur

     

       39
       39
       +
             |> list.map(fn(v) { v |> int.multiply(2) })

     

       40
       40
       +
             |> list.combinations(2)

     

       41
       41
       +
             |> list.map(fn(v) { list.fold(v, 0, int.add) })

     

       42
       42
       +
             |> list.reduce(int.min)

     

       43
       43
       +
             |> result.unwrap(0)

     

       48
       44
        
       

     

       49
       49
       -
             prev + smallest_perimeter + fold(cur, 1, multiply)

     

       50
       50
       -
           })

     

       51
       51
       -
           |> to_string,

     

       52
       52
       -
         )

     

       45
       45
       +
           acc + smallest_perimeter + list.fold(cur, 1, int.multiply)

     

       46
       46
       +
         })

     

       47
       47
       +
         |> int.to_string

     

       48
       48
       +
         |> io.println

     

       53
       49
        
       }

+25

2015/2/rust/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "either"

     

       7
       7
       +
       version = "1.15.0"

     

       8
       8
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       9
       9
       +
       checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"

     

       10
       10
       +
       

     

       11
       11
       +
       [[package]]

     

       12
       12
       +
       name = "itertools"

     

       13
       13
       +
       version = "0.14.0"

     

       14
       14
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       15
       15
       +
       checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"

     

       16
       16
       +
       dependencies = [

     

       17
       17
       +
        "either",

     

       18
       18
       +
       ]

     

       19
       19
       +
       

     

       20
       20
       +
       [[package]]

     

       21
       21
       +
       name = "rust"

     

       22
       22
       +
       version = "0.1.0"

     

       23
       23
       +
       dependencies = [

     

       24
       24
       +
        "itertools",

     

       25
       25
       +
       ]

+7

2015/2/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

     

       7
       7
       +
       itertools = "0.14.0"

+35

2015/2/rust/src/main.rs

···

       1
       1
       +
       use itertools::Itertools;

     

       2
       2
       +
       

     

       3
       3
       +
       fn main() {

     

       4
       4
       +
           let input =

     

       5
       5
       +
               std::fs::read_to_string("../input.txt").expect("invalid input!!");

     

       6
       6
       +
           let input = input

     

       7
       7
       +
               .trim()

     

       8
       8
       +
               .split("\n")

     

       9
       9
       +
               .map(|v| v.split("x").map(|n| n.parse().expect("not a number")));

     

       10
       10
       +
       

     

       11
       11
       +
           let part1 = input.clone().fold(0, |acc, v| {

     

       12
       12
       +
               let sides: Vec<i32> = v

     

       13
       13
       +
                   .combinations(2)

     

       14
       14
       +
                   .map(|pair| pair.into_iter().reduce(|a, b| a * b).unwrap())

     

       15
       15
       +
                   .collect();

     

       16
       16
       +
               let sides = sides.into_iter();

     

       17
       17
       +
       

     

       18
       18
       +
               acc + sides.clone().fold(0, |acc, v| acc + v) * 2

     

       19
       19
       +
                   + sides.clone().reduce(|a, b| a.min(b)).unwrap()

     

       20
       20
       +
           });

     

       21
       21
       +
           println!("{part1}");

     

       22
       22
       +
       

     

       23
       23
       +
           let part2 = input.clone().fold(0, |acc, v| {

     

       24
       24
       +
               let smallest_perimeter = v

     

       25
       25
       +
                   .clone()

     

       26
       26
       +
                   .map(|v| v * 2)

     

       27
       27
       +
                   .combinations(2)

     

       28
       28
       +
                   .map(|v| v.into_iter().fold(0, |a, b| a + b))

     

       29
       29
       +
                   .reduce(|a, b| a.min(b))

     

       30
       30
       +
                   .unwrap();

     

       31
       31
       +
       

     

       32
       32
       +
               acc + smallest_perimeter + v.fold(1, |a, b| a * b)

     

       33
       33
       +
           });

     

       34
       34
       +
           println!("{part2}");

     

       35
       35
       +
       }

+7

2015/20/rust/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

+6

2015/20/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+33

2015/20/rust/src/main.rs

···

       1
       1
       +
       fn main() {

     

       2
       2
       +
           let input: u64 = include_str!("../../input.txt")

     

       3
       3
       +
               .trim()

     

       4
       4
       +
               .parse()

     

       5
       5
       +
               .expect("bad input");

     

       6
       6
       +
           let input = input / 10;

     

       7
       7
       +
       

     

       8
       8
       +
           let mut highest_house = (0, 0);

     

       9
       9
       +
           let mut house: u64 = 1;

     

       10
       10
       +
           // while highest_house.1 < input {

     

       11
       11
       +
           while house < 10 {

     

       12
       12
       +
               let presents = if house % 2 == 0 {

     

       13
       13
       +
                   (1..house + 1).fold(0, |acc, elf| {

     

       14
       14
       +
                       if house % elf == 0 { acc + elf } else { acc }

     

       15
       15
       +
                   })

     

       16
       16
       +
               } else {

     

       17
       17
       +
                   (1..house.div_ceil(2) + 1).fold(0, |acc, elf| {

     

       18
       18
       +
                       if house % (elf * 2) == 0 {

     

       19
       19
       +
                           acc + elf

     

       20
       20
       +
                       } else {

     

       21
       21
       +
                           acc

     

       22
       22
       +
                       }

     

       23
       23
       +
                   })

     

       24
       24
       +
               };

     

       25
       25
       +
               if presents > highest_house.1 {

     

       26
       26
       +
                   highest_house = (house, presents);

     

       27
       27
       +
               }

     

       28
       28
       +
               house += 1;

     

       29
       29
       +
               println!("{} {}", house, presents);

     

       30
       30
       +
           }

     

       31
       31
       +
       

     

       32
       32
       +
           println!("Part 1: {:?}", highest_house);

     

       33
       33
       +
       }

+77

2015/4/rust/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "block-buffer"

     

       7
       7
       +
       version = "0.10.4"

     

       8
       8
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       9
       9
       +
       checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"

     

       10
       10
       +
       dependencies = [

     

       11
       11
       +
        "generic-array",

     

       12
       12
       +
       ]

     

       13
       13
       +
       

     

       14
       14
       +
       [[package]]

     

       15
       15
       +
       name = "cfg-if"

     

       16
       16
       +
       version = "1.0.4"

     

       17
       17
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       18
       18
       +
       checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"

     

       19
       19
       +
       

     

       20
       20
       +
       [[package]]

     

       21
       21
       +
       name = "crypto-common"

     

       22
       22
       +
       version = "0.1.7"

     

       23
       23
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       24
       24
       +
       checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"

     

       25
       25
       +
       dependencies = [

     

       26
       26
       +
        "generic-array",

     

       27
       27
       +
        "typenum",

     

       28
       28
       +
       ]

     

       29
       29
       +
       

     

       30
       30
       +
       [[package]]

     

       31
       31
       +
       name = "digest"

     

       32
       32
       +
       version = "0.10.7"

     

       33
       33
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       34
       34
       +
       checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"

     

       35
       35
       +
       dependencies = [

     

       36
       36
       +
        "block-buffer",

     

       37
       37
       +
        "crypto-common",

     

       38
       38
       +
       ]

     

       39
       39
       +
       

     

       40
       40
       +
       [[package]]

     

       41
       41
       +
       name = "generic-array"

     

       42
       42
       +
       version = "0.14.7"

     

       43
       43
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       44
       44
       +
       checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"

     

       45
       45
       +
       dependencies = [

     

       46
       46
       +
        "typenum",

     

       47
       47
       +
        "version_check",

     

       48
       48
       +
       ]

     

       49
       49
       +
       

     

       50
       50
       +
       [[package]]

     

       51
       51
       +
       name = "md-5"

     

       52
       52
       +
       version = "0.10.6"

     

       53
       53
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       54
       54
       +
       checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"

     

       55
       55
       +
       dependencies = [

     

       56
       56
       +
        "cfg-if",

     

       57
       57
       +
        "digest",

     

       58
       58
       +
       ]

     

       59
       59
       +
       

     

       60
       60
       +
       [[package]]

     

       61
       61
       +
       name = "rust"

     

       62
       62
       +
       version = "0.1.0"

     

       63
       63
       +
       dependencies = [

     

       64
       64
       +
        "md-5",

     

       65
       65
       +
       ]

     

       66
       66
       +
       

     

       67
       67
       +
       [[package]]

     

       68
       68
       +
       name = "typenum"

     

       69
       69
       +
       version = "1.19.0"

     

       70
       70
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       71
       71
       +
       checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"

     

       72
       72
       +
       

     

       73
       73
       +
       [[package]]

     

       74
       74
       +
       name = "version_check"

     

       75
       75
       +
       version = "0.9.5"

     

       76
       76
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       77
       77
       +
       checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"

+7

2015/4/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

     

       7
       7
       +
       md-5 = "0.10.6"

+33

2015/4/rust/src/main.rs

···

       1
       1
       +
       use md5::{Digest, Md5};

     

       2
       2
       +
       

     

       3
       3
       +
       // just putting it here that the idea of analysing it as bytes instead of a string and of putting the main hasher outside the loop was gemini

     

       4
       4
       +
       fn find(input: &str, requires: usize) -> u32 {

     

       5
       5
       +
           let mut i = 1;

     

       6
       6
       +
           let div_ceiled = requires.div_ceil(2) - 1;

     

       7
       7
       +
           let starts_with = &[0_u8].repeat(requires / 2);

     

       8
       8
       +
       

     

       9
       9
       +
           let mut hasher_main = Md5::new();

     

       10
       10
       +
           hasher_main.update(input.as_bytes());

     

       11
       11
       +
       

     

       12
       12
       +
           loop {

     

       13
       13
       +
               let mut hasher = hasher_main.clone();

     

       14
       14
       +
               hasher.update(i.to_string().as_bytes());

     

       15
       15
       +
               let result = hasher.finalize();

     

       16
       16
       +
               if result[div_ceiled] < 16 && result.starts_with(starts_with) {

     

       17
       17
       +
                   return i;

     

       18
       18
       +
               }

     

       19
       19
       +
               i += 1;

     

       20
       20
       +
           }

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       fn main() {

     

       24
       24
       +
           let input =

     

       25
       25
       +
               std::fs::read_to_string("../input.txt").expect("invalid input!!");

     

       26
       26
       +
           let input = input.trim();

     

       27
       27
       +
       

     

       28
       28
       +
           let res = find(input, 5);

     

       29
       29
       +
           println!("{}", &res);

     

       30
       30
       +
       

     

       31
       31
       +
           let res = find(input, 6);

     

       32
       32
       +
           println!("{}", &res);

     

       33
       33
       +
       }

+20

2025/1/gleam/gleam.toml

···

       1
       1
       +
       name = "main"

     

       2
       2
       +
       version = "1.0.0"

     

       3
       3
       +
       

     

       4
       4
       +
       # Fill out these fields if you intend to generate HTML documentation or publish

     

       5
       5
       +
       # your project to the Hex package manager.

     

       6
       6
       +
       #

     

       7
       7
       +
       # description = ""

     

       8
       8
       +
       # licences = ["Apache-2.0"]

     

       9
       9
       +
       # repository = { type = "github", user = "", repo = "" }

     

       10
       10
       +
       # links = [{ title = "Website", href = "" }]

     

       11
       11
       +
       #

     

       12
       12
       +
       # For a full reference of all the available options, you can have a look at

     

       13
       13
       +
       # https://gleam.run/writing-gleam/gleam-toml/.

     

       14
       14
       +
       

     

       15
       15
       +
       [dependencies]

     

       16
       16
       +
       gleam_stdlib = ">= 0.44.0 and < 2.0.0"

     

       17
       17
       +
       simplifile = ">= 2.3.0 and < 3.0.0"

     

       18
       18
       +
       

     

       19
       19
       +
       [dev-dependencies]

     

       20
       20
       +
       gleeunit = ">= 1.0.0 and < 2.0.0"

+14

2025/1/gleam/manifest.toml

···

       1
       1
       +
       # This file was generated by Gleam

     

       2
       2
       +
       # You typically do not need to edit this file

     

       3
       3
       +
       

     

       4
       4
       +
       packages = [

     

       5
       5
       +
         { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },

     

       6
       6
       +
         { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },

     

       7
       7
       +
         { name = "gleeunit", version = "1.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "CD701726CBCE5588B375D157B4391CFD0F2F134CD12D9B6998A395484DE05C58" },

     

       8
       8
       +
         { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },

     

       9
       9
       +
       ]

     

       10
       10
       +
       

     

       11
       11
       +
       [requirements]

     

       12
       12
       +
       gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }

     

       13
       13
       +
       gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

     

       14
       14
       +
       simplifile = { version = ">= 2.3.0 and < 3.0.0" }

+60

2025/1/gleam/src/main.gleam

···

       1
       1
       +
       import gleam/int

     

       2
       2
       +
       import gleam/io

     

       3
       3
       +
       import gleam/list

     

       4
       4
       +
       import gleam/result

     

       5
       5
       +
       import gleam/string

     

       6
       6
       +
       import simplifile as file

     

       7
       7
       +
       

     

       8
       8
       +
       pub type RotationState {

     

       9
       9
       +
         RotationState(turn: Int, zeroes: Int)

     

       10
       10
       +
       }

     

       11
       11
       +
       

     

       12
       12
       +
       pub fn main() {

     

       13
       13
       +
         let assert Ok(input) = file.read(from: "../input.txt")

     

       14
       14
       +
           as "Input file not found"

     

       15
       15
       +
         let input =

     

       16
       16
       +
           input

     

       17
       17
       +
           |> string.trim

     

       18
       18
       +
           |> string.split("\n")

     

       19
       19
       +
           |> list.map(fn(l) {

     

       20
       20
       +
             case l {

     

       21
       21
       +
               "R" <> turn -> turn |> int.parse |> result.unwrap(0)

     

       22
       22
       +
               "L" <> turn -> -{ turn |> int.parse |> result.unwrap(0) }

     

       23
       23
       +
               _ -> panic as "bad input"

     

       24
       24
       +
             }

     

       25
       25
       +
           })

     

       26
       26
       +
       

     

       27
       27
       +
         let part1 =

     

       28
       28
       +
           input

     

       29
       29
       +
           |> list.fold(RotationState(50, 0), fn(acc, v) {

     

       30
       30
       +
             let new_number =

     

       31
       31
       +
               int.modulo(acc.turn + v, 100)

     

       32
       32
       +
               |> result.unwrap(0)

     

       33
       33
       +
             RotationState(new_number, case new_number {

     

       34
       34
       +
               0 -> acc.zeroes + 1

     

       35
       35
       +
               _ -> acc.zeroes

     

       36
       36
       +
             })

     

       37
       37
       +
           })

     

       38
       38
       +
         part1.zeroes

     

       39
       39
       +
         |> int.to_string

     

       40
       40
       +
         |> io.println

     

       41
       41
       +
       

     

       42
       42
       +
         let part2 =

     

       43
       43
       +
           input

     

       44
       44
       +
           |> list.fold(RotationState(50, 0), fn(acc, v) {

     

       45
       45
       +
             let raw_new_number = acc.turn + v

     

       46
       46
       +
             let raw_zeroes = int.absolute_value(raw_new_number / 100)

     

       47
       47
       +
             let zeroes =

     

       48
       48
       +
               acc.zeroes

     

       49
       49
       +
               + case acc.turn != 0 && raw_new_number <= 0 {

     

       50
       50
       +
                 // if it is below zero before being moduloed and the original number itself wasn't zero it means that it did touch zero but the division thing wouldn't count it, so we give this extra support.

     

       51
       51
       +
                 // of course, there is no need to deal with a negative to positive situation because the acc.turn will never be negative!!!

     

       52
       52
       +
                 True -> raw_zeroes + 1

     

       53
       53
       +
                 False -> raw_zeroes

     

       54
       54
       +
               }

     

       55
       55
       +
             RotationState(int.modulo(raw_new_number, 100) |> result.unwrap(0), zeroes)

     

       56
       56
       +
           })

     

       57
       57
       +
         part2.zeroes

     

       58
       58
       +
         |> int.to_string

     

       59
       59
       +
         |> io.println

     

       60
       60
       +
       }

+7

2025/1/rust/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

+6

2025/1/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+53

2025/1/rust/src/main.rs

···

       1
       1
       +
       struct State {

     

       2
       2
       +
           turn: i32,

     

       3
       3
       +
           zeroes: i32,

     

       4
       4
       +
       }

     

       5
       5
       +
       

     

       6
       6
       +
       fn main() {

     

       7
       7
       +
           let input: Vec<i32> = include_str!("../../input.txt")

     

       8
       8
       +
               .trim()

     

       9
       9
       +
               .split("\n")

     

       10
       10
       +
               .map(|n| {

     

       11
       11
       +
                   n.replace("L", "-")

     

       12
       12
       +
                       .replace("R", "")

     

       13
       13
       +
                       .parse::<i32>()

     

       14
       14
       +
                       .expect("invalid input")

     

       15
       15
       +
               })

     

       16
       16
       +
               .collect();

     

       17
       17
       +
       

     

       18
       18
       +
           let part_1 = input.iter().fold(

     

       19
       19
       +
               State {

     

       20
       20
       +
                   turn: 50,

     

       21
       21
       +
                   zeroes: 0,

     

       22
       22
       +
               },

     

       23
       23
       +
               |acc, n| {

     

       24
       24
       +
                   let turn = (acc.turn + n).rem_euclid(100);

     

       25
       25
       +
                   State {

     

       26
       26
       +
                       turn,

     

       27
       27
       +
                       zeroes: acc.zeroes + (turn == 0) as i32,

     

       28
       28
       +
                   }

     

       29
       29
       +
               },

     

       30
       30
       +
           );

     

       31
       31
       +
           println!("{}", part_1.zeroes);

     

       32
       32
       +
       

     

       33
       33
       +
           let part_2 = input.iter().fold(

     

       34
       34
       +
               State {

     

       35
       35
       +
                   turn: 50,

     

       36
       36
       +
                   zeroes: 0,

     

       37
       37
       +
               },

     

       38
       38
       +
               |acc, n| {

     

       39
       39
       +
                   let raw_turn = acc.turn + n;

     

       40
       40
       +
                   let turn = raw_turn.rem_euclid(100);

     

       41
       41
       +
                   let raw_zeroes = (raw_turn / 100).abs();

     

       42
       42
       +
                   State {

     

       43
       43
       +
                       turn,

     

       44
       44
       +
                       // if it is below zero before being moduloed and the original number itself wasn't zero it means that it did touch zero but the division thing wouldn't count it, so we give this extra support.

     

       45
       45
       +
                       // of course, there is no need to deal with a negative to positive situation because the acc.turn will never be negative!!!

     

       46
       46
       +
                       zeroes: acc.zeroes

     

       47
       47
       +
                           + raw_zeroes

     

       48
       48
       +
                           + (acc.turn != 0 && raw_turn <= 0) as i32,

     

       49
       49
       +
                   }

     

       50
       50
       +
               },

     

       51
       51
       +
           );

     

       52
       52
       +
           println!("{}", part_2.zeroes);

     

       53
       53
       +
       }

+39

2025/1/zig/build.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       

     

       3
       3
       +
       pub fn build(b: *std.Build) void {

     

       4
       4
       +
           const target = b.standardTargetOptions(.{});

     

       5
       5
       +
       

     

       6
       6
       +
           const optimize = b.standardOptimizeOption(.{});

     

       7
       7
       +
       

     

       8
       8
       +
           const exe = b.addExecutable(.{

     

       9
       9
       +
               .name = "zig",

     

       10
       10
       +
               .root_module = b.createModule(.{

     

       11
       11
       +
                   .root_source_file = b.path("src/main.zig"),

     

       12
       12
       +
       

     

       13
       13
       +
                   .target = target,

     

       14
       14
       +
                   .optimize = optimize,

     

       15
       15
       +
               }),

     

       16
       16
       +
           });

     

       17
       17
       +
       

     

       18
       18
       +
           b.installArtifact(exe);

     

       19
       19
       +
       

     

       20
       20
       +
           const run_step = b.step("run", "Run the app");

     

       21
       21
       +
       

     

       22
       22
       +
           const run_cmd = b.addRunArtifact(exe);

     

       23
       23
       +
           run_step.dependOn(&run_cmd.step);

     

       24
       24
       +
       

     

       25
       25
       +
           run_cmd.step.dependOn(b.getInstallStep());

     

       26
       26
       +
       

     

       27
       27
       +
           if (b.args) |args| {

     

       28
       28
       +
               run_cmd.addArgs(args);

     

       29
       29
       +
           }

     

       30
       30
       +
       

     

       31
       31
       +
           const exe_tests = b.addTest(.{

     

       32
       32
       +
               .root_module = exe.root_module,

     

       33
       33
       +
           });

     

       34
       34
       +
       

     

       35
       35
       +
           const run_exe_tests = b.addRunArtifact(exe_tests);

     

       36
       36
       +
       

     

       37
       37
       +
           const test_step = b.step("test", "Run tests");

     

       38
       38
       +
           test_step.dependOn(&run_exe_tests.step);

     

       39
       39
       +
       }

+40

2025/1/zig/src/main.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       

     

       3
       3
       +
       const State = struct { turn: i32, zeroes: u32 };

     

       4
       4
       +
       

     

       5
       5
       +
       pub fn main() !void {

     

       6
       6
       +
           const allocator = std.heap.page_allocator;

     

       7
       7
       +
       

     

       8
       8
       +
           const input_raw = @embedFile("./input.txt");

     

       9
       9
       +
           const input_str = std.mem.trim(u8, input_raw, "\t\r\n");

     

       10
       10
       +
           var turns_str = std.mem.splitScalar(u8, input_str, '\n');

     

       11
       11
       +
       

     

       12
       12
       +
           const turns_len =

     

       13
       13
       +
               std.mem.count(u8, input_str, "\n") + 1;

     

       14
       14
       +
           const turns = try allocator.alloc(i32, turns_len);

     

       15
       15
       +
           defer allocator.free(turns);

     

       16
       16
       +
       

     

       17
       17
       +
           var i: u32 = 0;

     

       18
       18
       +
           while (turns_str.next()) |turn_str| {

     

       19
       19
       +
               const mult: i32 = if (turn_str[0] == 'L') -1 else 1;

     

       20
       20
       +
               turns[i] = try std.fmt.parseInt(i32, turn_str[1..], 10) * mult;

     

       21
       21
       +
               i += 1;

     

       22
       22
       +
           }

     

       23
       23
       +
       

     

       24
       24
       +
           var part_1 = State{ .turn = 50, .zeroes = 0 };

     

       25
       25
       +
           for (turns) |turn| {

     

       26
       26
       +
               part_1.turn = @mod(part_1.turn + turn, 100);

     

       27
       27
       +
               part_1.zeroes += @intFromBool(part_1.turn == 0);

     

       28
       28
       +
           }

     

       29
       29
       +
           std.debug.print("Part 1: {}\n", .{part_1.zeroes});

     

       30
       30
       +
       

     

       31
       31
       +
           var part_2 = State{ .turn = 50, .zeroes = 0 };

     

       32
       32
       +
           for (turns) |turn| {

     

       33
       33
       +
               const raw_turn: i32 = part_2.turn + turn;

     

       34
       34
       +
               // if it is below zero before being moduloed and the original number itself wasn't zero it means that it did touch zero but the division thing wouldn't count it, so we give this extra support.

     

       35
       35
       +
               // of course, there is no need to deal with a negative to positive situation because the acc.turn will never be negative!!!

     

       36
       36
       +
               part_2.zeroes += @abs(raw_turn) / 100 + @intFromBool(part_2.turn != 0 and raw_turn <= 0);

     

       37
       37
       +
               part_2.turn = @mod(raw_turn, 100);

     

       38
       38
       +
           }

     

       39
       39
       +
           std.debug.print("Part 2: {}\n", .{part_2.zeroes});

     

       40
       40
       +
       }

+20

2025/2/gleam/gleam.toml

···

       1
       1
       +
       name = "main"

     

       2
       2
       +
       version = "1.0.0"

     

       3
       3
       +
       

     

       4
       4
       +
       # Fill out these fields if you intend to generate HTML documentation or publish

     

       5
       5
       +
       # your project to the Hex package manager.

     

       6
       6
       +
       #

     

       7
       7
       +
       # description = ""

     

       8
       8
       +
       # licences = ["Apache-2.0"]

     

       9
       9
       +
       # repository = { type = "github", user = "", repo = "" }

     

       10
       10
       +
       # links = [{ title = "Website", href = "" }]

     

       11
       11
       +
       #

     

       12
       12
       +
       # For a full reference of all the available options, you can have a look at

     

       13
       13
       +
       # https://gleam.run/writing-gleam/gleam-toml/.

     

       14
       14
       +
       

     

       15
       15
       +
       [dependencies]

     

       16
       16
       +
       gleam_stdlib = ">= 0.44.0 and < 2.0.0"

     

       17
       17
       +
       simplifile = ">= 2.3.0 and < 3.0.0"

     

       18
       18
       +
       

     

       19
       19
       +
       [dev-dependencies]

     

       20
       20
       +
       gleeunit = ">= 1.0.0 and < 2.0.0"

+14

2025/2/gleam/manifest.toml

···

       1
       1
       +
       # This file was generated by Gleam

     

       2
       2
       +
       # You typically do not need to edit this file

     

       3
       3
       +
       

     

       4
       4
       +
       packages = [

     

       5
       5
       +
         { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },

     

       6
       6
       +
         { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },

     

       7
       7
       +
         { name = "gleeunit", version = "1.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "CD701726CBCE5588B375D157B4391CFD0F2F134CD12D9B6998A395484DE05C58" },

     

       8
       8
       +
         { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },

     

       9
       9
       +
       ]

     

       10
       10
       +
       

     

       11
       11
       +
       [requirements]

     

       12
       12
       +
       gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }

     

       13
       13
       +
       gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

     

       14
       14
       +
       simplifile = { version = ">= 2.3.0 and < 3.0.0" }

+70

2025/2/gleam/src/main.gleam

···

       1
       1
       +
       import gleam/int

     

       2
       2
       +
       import gleam/io

     

       3
       3
       +
       import gleam/list

     

       4
       4
       +
       import gleam/result

     

       5
       5
       +
       import gleam/string

     

       6
       6
       +
       import simplifile as file

     

       7
       7
       +
       

     

       8
       8
       +
       type Range {

     

       9
       9
       +
         Range(start: Int, end: Int)

     

       10
       10
       +
       }

     

       11
       11
       +
       

     

       12
       12
       +
       pub fn main() {

     

       13
       13
       +
         let assert Ok(input) = file.read(from: "../input.txt")

     

       14
       14
       +
           as "Input file not found"

     

       15
       15
       +
         let input =

     

       16
       16
       +
           input

     

       17
       17
       +
           |> string.trim

     

       18
       18
       +
           |> string.split(",")

     

       19
       19
       +
           |> list.map(fn(s) {

     

       20
       20
       +
             case string.split(s, "-") {

     

       21
       21
       +
               [start, end] ->

     

       22
       22
       +
                 Range(

     

       23
       23
       +
                   start |> int.parse |> result.unwrap(0),

     

       24
       24
       +
                   end |> int.parse |> result.unwrap(0),

     

       25
       25
       +
                 )

     

       26
       26
       +
               _ -> panic as "invalid input"

     

       27
       27
       +
             }

     

       28
       28
       +
           })

     

       29
       29
       +
       

     

       30
       30
       +
         input

     

       31
       31
       +
         |> list.fold(0, fn(acc, r) {

     

       32
       32
       +
           list.range(r.start, r.end)

     

       33
       33
       +
           |> list.fold(acc, fn(acc, i) {

     

       34
       34
       +
             let s = int.to_string(i)

     

       35
       35
       +
             let len = string.length(s)

     

       36
       36
       +
             case string.slice(s, 0, len / 2) |> string.repeat(2) == s {

     

       37
       37
       +
               True -> acc + i

     

       38
       38
       +
               False -> acc

     

       39
       39
       +
             }

     

       40
       40
       +
           })

     

       41
       41
       +
         })

     

       42
       42
       +
         |> int.to_string

     

       43
       43
       +
         |> io.println

     

       44
       44
       +
       

     

       45
       45
       +
         input

     

       46
       46
       +
         |> list.fold(0, fn(acc, r) {

     

       47
       47
       +
           list.range(r.start, r.end)

     

       48
       48
       +
           |> list.fold(acc, fn(acc, i) {

     

       49
       49
       +
             case i > 10 {

     

       50
       50
       +
               True -> {

     

       51
       51
       +
                 let s = int.to_string(i)

     

       52
       52
       +
                 let len = string.length(s)

     

       53
       53
       +
                 list.range(len / 2, 1)

     

       54
       54
       +
                 |> list.fold_until(acc, fn(acc, cur_len) {

     

       55
       55
       +
                   let n =

     

       56
       56
       +
                     string.slice(s, 0, cur_len)

     

       57
       57
       +
                     |> string.repeat(int.max(2, len / cur_len))

     

       58
       58
       +
                   case n == s {

     

       59
       59
       +
                     True -> list.Stop(acc + i)

     

       60
       60
       +
                     False -> list.Continue(acc)

     

       61
       61
       +
                   }

     

       62
       62
       +
                 })

     

       63
       63
       +
               }

     

       64
       64
       +
               False -> acc

     

       65
       65
       +
             }

     

       66
       66
       +
           })

     

       67
       67
       +
         })

     

       68
       68
       +
         |> int.to_string

     

       69
       69
       +
         |> io.println

     

       70
       70
       +
       }

+7

2025/2/rust/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

+6

2025/2/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+73

2025/2/rust/src/main.rs

···

       1
       1
       +
       use std::collections::HashSet;

     

       2
       2
       +
       

     

       3
       3
       +
       struct Range {

     

       4
       4
       +
           start: u64,

     

       5
       5
       +
           end: u64,

     

       6
       6
       +
       }

     

       7
       7
       +
       

     

       8
       8
       +
       const MAX_LENGTH: usize = 10;

     

       9
       9
       +
       

     

       10
       10
       +
       fn main() {

     

       11
       11
       +
           let input: Vec<Range> = include_str!("../../input.txt")

     

       12
       12
       +
               .trim()

     

       13
       13
       +
               .split(",")

     

       14
       14
       +
               .map(|v| {

     

       15
       15
       +
                   let range = v.split_once("-");

     

       16
       16
       +
                   match range {

     

       17
       17
       +
                       Some((start, end)) => Range {

     

       18
       18
       +
                           start: start.parse().expect("invalid number"),

     

       19
       19
       +
                           end: end.parse().expect("invalid number"),

     

       20
       20
       +
                       },

     

       21
       21
       +
                       _ => panic!("bad input!"),

     

       22
       22
       +
                   }

     

       23
       23
       +
               })

     

       24
       24
       +
               .collect();

     

       25
       25
       +
       

     

       26
       26
       +
           let powers_of_ten: Vec<u64> =

     

       27
       27
       +
               (0..=MAX_LENGTH as u32).map(|i| 10_u64.pow(i)).collect();

     

       28
       28
       +
       

     

       29
       29
       +
           let [invalid_part_1, invalid_part_2] = {

     

       30
       30
       +
               let mut part_1: HashSet<u64> = HashSet::new();

     

       31
       31
       +
               let mut part_2: HashSet<u64> = HashSet::new();

     

       32
       32
       +
       

     

       33
       33
       +
               for len in 1..=MAX_LENGTH / 2 {

     

       34
       34
       +
                   // 1-9, 10-99, 100-999, 100000-999999

     

       35
       35
       +
                   for combination in *powers_of_ten.get(len - 1).unwrap_or(&1)

     

       36
       36
       +
                       ..*powers_of_ten.get(len).unwrap()

     

       37
       37
       +
                   {

     

       38
       38
       +
                       let mut number = 0;

     

       39
       39
       +
                       // 0 is just the number (9), 1 is one repetition (99)

     

       40
       40
       +
                       for repeat in 0..MAX_LENGTH / len {

     

       41
       41
       +
                           number += combination

     

       42
       42
       +
                               * powers_of_ten.get((len * repeat) as usize).unwrap();

     

       43
       43
       +
                           if repeat > 0 {

     

       44
       44
       +
                               part_2.insert(number);

     

       45
       45
       +
                           }

     

       46
       46
       +
                           if repeat == 1 {

     

       47
       47
       +
                               part_1.insert(number);

     

       48
       48
       +
                           }

     

       49
       49
       +
                       }

     

       50
       50
       +
                   }

     

       51
       51
       +
               }

     

       52
       52
       +
       

     

       53
       53
       +
               [part_1, part_2]

     

       54
       54
       +
           };

     

       55
       55
       +
       

     

       56
       56
       +
           let part_1 = invalid_part_1.iter().fold(0, |acc, number| {

     

       57
       57
       +
               if input.iter().any(|r| *number >= r.start && *number <= r.end) {

     

       58
       58
       +
                   acc + number

     

       59
       59
       +
               } else {

     

       60
       60
       +
                   acc

     

       61
       61
       +
               }

     

       62
       62
       +
           });

     

       63
       63
       +
           println!("{}", part_1);

     

       64
       64
       +
       

     

       65
       65
       +
           let part_2 = invalid_part_2.iter().fold(0, |acc, number| {

     

       66
       66
       +
               if input.iter().any(|r| *number >= r.start && *number <= r.end) {

     

       67
       67
       +
                   acc + number

     

       68
       68
       +
               } else {

     

       69
       69
       +
                   acc

     

       70
       70
       +
               }

     

       71
       71
       +
           });

     

       72
       72
       +
           println!("{}", part_2);

     

       73
       73
       +
       }

+20

2025/3/gleam/gleam.toml

···

       1
       1
       +
       name = "main"

     

       2
       2
       +
       version = "1.0.0"

     

       3
       3
       +
       

     

       4
       4
       +
       # Fill out these fields if you intend to generate HTML documentation or publish

     

       5
       5
       +
       # your project to the Hex package manager.

     

       6
       6
       +
       #

     

       7
       7
       +
       # description = ""

     

       8
       8
       +
       # licences = ["Apache-2.0"]

     

       9
       9
       +
       # repository = { type = "github", user = "", repo = "" }

     

       10
       10
       +
       # links = [{ title = "Website", href = "" }]

     

       11
       11
       +
       #

     

       12
       12
       +
       # For a full reference of all the available options, you can have a look at

     

       13
       13
       +
       # https://gleam.run/writing-gleam/gleam-toml/.

     

       14
       14
       +
       

     

       15
       15
       +
       [dependencies]

     

       16
       16
       +
       gleam_stdlib = ">= 0.44.0 and < 2.0.0"

     

       17
       17
       +
       simplifile = ">= 2.3.0 and < 3.0.0"

     

       18
       18
       +
       

     

       19
       19
       +
       [dev-dependencies]

     

       20
       20
       +
       gleeunit = ">= 1.0.0 and < 2.0.0"

+14

2025/3/gleam/manifest.toml

···

       1
       1
       +
       # This file was generated by Gleam

     

       2
       2
       +
       # You typically do not need to edit this file

     

       3
       3
       +
       

     

       4
       4
       +
       packages = [

     

       5
       5
       +
         { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },

     

       6
       6
       +
         { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },

     

       7
       7
       +
         { name = "gleeunit", version = "1.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "CD701726CBCE5588B375D157B4391CFD0F2F134CD12D9B6998A395484DE05C58" },

     

       8
       8
       +
         { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },

     

       9
       9
       +
       ]

     

       10
       10
       +
       

     

       11
       11
       +
       [requirements]

     

       12
       12
       +
       gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }

     

       13
       13
       +
       gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

     

       14
       14
       +
       simplifile = { version = ">= 2.3.0 and < 3.0.0" }

+71

2025/3/gleam/src/main.gleam

···

       1
       1
       +
       import gleam/int

     

       2
       2
       +
       import gleam/io

     

       3
       3
       +
       import gleam/list

     

       4
       4
       +
       import gleam/result

     

       5
       5
       +
       import gleam/string

     

       6
       6
       +
       import simplifile as file

     

       7
       7
       +
       

     

       8
       8
       +
       pub fn do(input, digits) {

     

       9
       9
       +
         input

     

       10
       10
       +
         // ok so here we're just iterating through all the battery banks in the input

     

       11
       11
       +
         |> list.fold(0, fn(acc, bank) {

     

       12
       12
       +
           let #(n, _) =

     

       13
       13
       +
             // and here we're going and doing it the amount of times necessary. it's backwards for obvious reasons, we start from the end and this let's us not have like duplicated logic where we're doing digits - i constantly

     

       14
       14
       +
             // it needs to be digits - 1 to zero because otherwise it will cut too much when dropping stuff at list.reverse list.drop(i) list.reverse

     

       15
       15
       +
             list.range(digits - 1, 0)

     

       16
       16
       +
             // didn't want to create a type for it so yeah #(the digit we're at, the remaining part of the bank)

     

       17
       17
       +
             |> list.fold(#(0, bank), fn(acc, i) {

     

       18
       18
       +
               // annoying gleam stuff i wish i could destructure it from the function

     

       19
       19
       +
               let #(number, bank) = acc

     

       20
       20
       +
       

     

       21
       21
       +
               // that's the part that matters, and the one i took forever in and ended up splitting in multiple variables when i didn't need to

     

       22
       22
       +
               // but like it's very simple

     

       23
       23
       +
               // gleam doesn't let you drop from the end of lists, so we reverse the list, drop the digits we cannot use because they will necessarily be used latter in the number. the last i is the minimum because like we need at the very least finish the number yk

     

       24
       24
       +
               // and then the really annoying part, we turn it into an index map, so we can get the location of the number to later drop that part off for the next digit

     

       25
       25
       +
               // and then we get the highest number

     

       26
       26
       +
               // and done here

     

       27
       27
       +
               // little assert because failing is better than the silent failing of unwrap

     

       28
       28
       +
               // list.take instead of drop would allow me to do it without reversing two times but like it would also need list.length which also goes through the whole list but without letting me put it in just pipes

     

       29
       29
       +
               // i mean i COULD count it once when starting it when then after getting the location subtracting from it but meh already did the rust version and this would put too much stuff on here

     

       30
       30
       +
               let assert Ok(#(max, loc)) =

     

       31
       31
       +
                 bank

     

       32
       32
       +
                 |> list.reverse

     

       33
       33
       +
                 |> list.drop(i)

     

       34
       34
       +
                 |> list.reverse

     

       35
       35
       +
                 |> list.index_map(fn(n, i) { #(n, i) })

     

       36
       36
       +
                 |> list.max(fn(a, b) { int.compare(a.0, b.0) })

     

       37
       37
       +
       

     

       38
       38
       +
               // and then we send it off to the next digit

     

       39
       39
       +
               // i wasn't using this number trick when i was doing it, i was literally just finding a power of 10 and multiplying it but like the power thing in gleam sucks it's like float only. i now learned this trick from *someone* and will be using it. don't know how i didn't figure out myself. oh wait i do it's because i'm stupid

     

       40
       40
       +
               // but yeah it just multiplies the number by ten so like 4 becomes 40 and then we add our like 3 to it 43 and then 43 to 430 and the 5 you get the gist of it. again don't know how i didn't see it myself

     

       41
       41
       +
               // and then we drop the parts of the list that can't be used for the subsequent numbers. like off by one evil thing in here to not include the number we just used too

     

       42
       42
       +
               // why don't we add 1 to everything in the thing above? because that would be more math than just adding it only once here duh

     

       43
       43
       +
               #(number * 10 + max, list.drop(bank, loc + 1))

     

       44
       44
       +
             })

     

       45
       45
       +
           // and then like every advent of code we add it to the acc

     

       46
       46
       +
           acc + n

     

       47
       47
       +
         })

     

       48
       48
       +
       }

     

       49
       49
       +
       

     

       50
       50
       +
       pub fn main() {

     

       51
       51
       +
         let assert Ok(input) = file.read(from: "../input.txt")

     

       52
       52
       +
           as "Input file not found"

     

       53
       53
       +
         let input =

     

       54
       54
       +
           input

     

       55
       55
       +
           |> string.trim

     

       56
       56
       +
           |> string.split("\n")

     

       57
       57
       +
           |> list.map(fn(bank) {

     

       58
       58
       +
             // just get all the battery banks, separate them by character and turn each character in a member of a list

     

       59
       59
       +
             // and here we unwrap because only let's you do it with variables and that would be less clean here

     

       60
       60
       +
             string.to_graphemes(bank)

     

       61
       61
       +
             |> list.map(fn(s) { int.parse(s) |> result.unwrap(0) })

     

       62
       62
       +
           })

     

       63
       63
       +
       

     

       64
       64
       +
         do(input, 2)

     

       65
       65
       +
         |> int.to_string

     

       66
       66
       +
         |> io.println

     

       67
       67
       +
       

     

       68
       68
       +
         do(input, 12)

     

       69
       69
       +
         |> int.to_string

     

       70
       70
       +
         |> io.println

     

       71
       71
       +
       }

+7

2025/3/rust/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

+6

2025/3/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+38

2025/3/rust/src/main.rs

···

       1
       1
       +
       // fun fact for this version, my biggest bug was integer overflow when i was using u32 because im not accustumed to this shit

     

       2
       2
       +
       

     

       3
       3
       +
       fn solve(input: &Vec<Vec<u64>>, digits: usize) -> u64 {

     

       4
       4
       +
           input.iter().fold(0, |acc, bank| {

     

       5
       5
       +
               let bank_len = bank.len();

     

       6
       6
       +
               let (n, _) = (0..digits).rfold((0, 0), |(number, bank_index), i| {

     

       7
       7
       +
                   let (loc, max) = bank[bank_index..bank_len - i]

     

       8
       8
       +
                       .iter()

     

       9
       9
       +
                       .enumerate()

     

       10
       10
       +
                       // apparently the compiler is fine with reversing this and then using the standard max_by but im not. and it seems to have the same speed results. im not gonna be using tricks here ok im nice

     

       11
       11
       +
                       .reduce(

     

       12
       12
       +
                           |(maxi, max), (i, n)| {

     

       13
       13
       +
                               if n > max { (i, n) } else { (maxi, max) }

     

       14
       14
       +
                           },

     

       15
       15
       +
                       )

     

       16
       16
       +
                       // #yup #i'm unwrapping #idontwannausefold

     

       17
       17
       +
                       .unwrap();

     

       18
       18
       +
       

     

       19
       19
       +
                   ((number * 10) + max, bank_index + loc + 1)

     

       20
       20
       +
               });

     

       21
       21
       +
               acc + n

     

       22
       22
       +
           })

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       fn main() {

     

       26
       26
       +
           let input: Vec<Vec<u64>> = include_str!("../../input.txt")

     

       27
       27
       +
               .trim()

     

       28
       28
       +
               .split("\n")

     

       29
       29
       +
               .map(|bank| {

     

       30
       30
       +
                   bank.chars()

     

       31
       31
       +
                       .map(|s| s.to_digit(10).unwrap() as u64)

     

       32
       32
       +
                       .collect()

     

       33
       33
       +
               })

     

       34
       34
       +
               .collect();

     

       35
       35
       +
       

     

       36
       36
       +
           println!("Part 1: {}", solve(&input, 2));

     

       37
       37
       +
           println!("Part 2: {}", solve(&input, 12));

     

       38
       38
       +
       }

+20

2025/4/gleam/gleam.toml

···

       1
       1
       +
       name = "main"

     

       2
       2
       +
       version = "1.0.0"

     

       3
       3
       +
       

     

       4
       4
       +
       # Fill out these fields if you intend to generate HTML documentation or publish

     

       5
       5
       +
       # your project to the Hex package manager.

     

       6
       6
       +
       #

     

       7
       7
       +
       # description = ""

     

       8
       8
       +
       # licences = ["Apache-2.0"]

     

       9
       9
       +
       # repository = { type = "github", user = "", repo = "" }

     

       10
       10
       +
       # links = [{ title = "Website", href = "" }]

     

       11
       11
       +
       #

     

       12
       12
       +
       # For a full reference of all the available options, you can have a look at

     

       13
       13
       +
       # https://gleam.run/writing-gleam/gleam-toml/.

     

       14
       14
       +
       

     

       15
       15
       +
       [dependencies]

     

       16
       16
       +
       gleam_stdlib = ">= 0.44.0 and < 2.0.0"

     

       17
       17
       +
       simplifile = ">= 2.3.0 and < 3.0.0"

     

       18
       18
       +
       

     

       19
       19
       +
       [dev-dependencies]

     

       20
       20
       +
       gleeunit = ">= 1.0.0 and < 2.0.0"

+14

2025/4/gleam/manifest.toml

···

       1
       1
       +
       # This file was generated by Gleam

     

       2
       2
       +
       # You typically do not need to edit this file

     

       3
       3
       +
       

     

       4
       4
       +
       packages = [

     

       5
       5
       +
         { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },

     

       6
       6
       +
         { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },

     

       7
       7
       +
         { name = "gleeunit", version = "1.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "CD701726CBCE5588B375D157B4391CFD0F2F134CD12D9B6998A395484DE05C58" },

     

       8
       8
       +
         { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },

     

       9
       9
       +
       ]

     

       10
       10
       +
       

     

       11
       11
       +
       [requirements]

     

       12
       12
       +
       gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }

     

       13
       13
       +
       gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

     

       14
       14
       +
       simplifile = { version = ">= 2.3.0 and < 3.0.0" }

+96

2025/4/gleam/src/main.gleam

···

       1
       1
       +
       import gleam/bit_array

     

       2
       2
       +
       import gleam/int

     

       3
       3
       +
       import gleam/io

     

       4
       4
       +
       import gleam/list

     

       5
       5
       +
       import gleam/result

     

       6
       6
       +
       import gleam/string

     

       7
       7
       +
       import simplifile as file

     

       8
       8
       +
       

     

       9
       9
       +
       fn get_place(x, y, map, size) {

     

       10
       10
       +
         case

     

       11
       11
       +
           case x, y {

     

       12
       12
       +
             _, -1 | -1, _ -> <<>>

     

       13
       13
       +
             s, _ | _, s if s == size -> <<>>

     

       14
       14
       +
       

     

       15
       15
       +
             _, _ -> bit_array.slice(map, y * size + x, 1) |> result.unwrap(<<>>)

     

       16
       16
       +
           }

     

       17
       17
       +
         {

     

       18
       18
       +
           <<"@">> -> 1

     

       19
       19
       +
           _ -> 0

     

       20
       20
       +
         }

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       fn part_1(map, size) {

     

       24
       24
       +
         list.range(0, bit_array.byte_size(map) - 1)

     

       25
       25
       +
         |> list.fold(0, fn(acc, pos) {

     

       26
       26
       +
           let x = pos % size

     

       27
       27
       +
           let y = pos / size

     

       28
       28
       +
       

     

       29
       29
       +
           let roll = get_place(x, y, map, size)

     

       30
       30
       +
       

     

       31
       31
       +
           let neighbours =

     

       32
       32
       +
             get_place(x - 1, y - 1, map, size)

     

       33
       33
       +
             + get_place(x, y - 1, map, size)

     

       34
       34
       +
             + get_place(x + 1, y - 1, map, size)

     

       35
       35
       +
             + get_place(x - 1, y, map, size)

     

       36
       36
       +
             + get_place(x + 1, y, map, size)

     

       37
       37
       +
             + get_place(x - 1, y + 1, map, size)

     

       38
       38
       +
             + get_place(x, y + 1, map, size)

     

       39
       39
       +
             + get_place(x + 1, y + 1, map, size)

     

       40
       40
       +
       

     

       41
       41
       +
           case roll, neighbours < 4 {

     

       42
       42
       +
             1, True -> acc + 1

     

       43
       43
       +
             _, _ -> acc

     

       44
       44
       +
           }

     

       45
       45
       +
         })

     

       46
       46
       +
       }

     

       47
       47
       +
       

     

       48
       48
       +
       fn part_2(map, size, rolls) {

     

       49
       49
       +
         let #(rolls, new_map) =

     

       50
       50
       +
           list.range(0, bit_array.byte_size(map) - 1)

     

       51
       51
       +
           |> list.fold(#(rolls, <<>>), fn(acc, pos) {

     

       52
       52
       +
             let #(total, new_map) = acc

     

       53
       53
       +
             let x = pos % size

     

       54
       54
       +
             let y = pos / size

     

       55
       55
       +
       

     

       56
       56
       +
             let roll = get_place(x, y, map, size)

     

       57
       57
       +
       

     

       58
       58
       +
             let neighbours =

     

       59
       59
       +
               get_place(x - 1, y - 1, map, size)

     

       60
       60
       +
               + get_place(x, y - 1, map, size)

     

       61
       61
       +
               + get_place(x + 1, y - 1, map, size)

     

       62
       62
       +
               + get_place(x - 1, y, map, size)

     

       63
       63
       +
               + get_place(x + 1, y, map, size)

     

       64
       64
       +
               + get_place(x - 1, y + 1, map, size)

     

       65
       65
       +
               + get_place(x, y + 1, map, size)

     

       66
       66
       +
               + get_place(x + 1, y + 1, map, size)

     

       67
       67
       +
       

     

       68
       68
       +
             case roll, neighbours < 4 {

     

       69
       69
       +
               1, True -> #(total + 1, bit_array.append(new_map, <<".">>))

     

       70
       70
       +
               1, _ -> #(total, bit_array.append(new_map, <<"@">>))

     

       71
       71
       +
               _, _ -> #(total, bit_array.append(new_map, <<".">>))

     

       72
       72
       +
             }

     

       73
       73
       +
           })

     

       74
       74
       +
       

     

       75
       75
       +
         case map == new_map {

     

       76
       76
       +
           True -> rolls

     

       77
       77
       +
           False -> part_2(new_map, size, rolls)

     

       78
       78
       +
         }

     

       79
       79
       +
       }

     

       80
       80
       +
       

     

       81
       81
       +
       pub fn main() {

     

       82
       82
       +
         let assert Ok(input) = file.read(from: "../input.txt")

     

       83
       83
       +
           as "Input file not found"

     

       84
       84
       +
         let input =

     

       85
       85
       +
           input |> string.trim |> string.split("\n") |> list.map(fn(v) { <<v:utf8>> })

     

       86
       86
       +
         let size = list.length(input)

     

       87
       87
       +
         let input = input |> list.fold(<<>>, fn(acc, l) { bit_array.append(acc, l) })

     

       88
       88
       +
         // @ and .

     

       89
       89
       +
       

     

       90
       90
       +
         part_1(input, size)

     

       91
       91
       +
         |> int.to_string

     

       92
       92
       +
         |> io.println

     

       93
       93
       +
         part_2(input, size, 0)

     

       94
       94
       +
         |> int.to_string

     

       95
       95
       +
         |> io.println

     

       96
       96
       +
       }

+7

2025/4/rust/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

+6

2025/4/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+106

2025/4/rust/src/main.rs

···

       1
       1
       +
       use std::{

     

       2
       2
       +
           fs::{self, File},

     

       3
       3
       +
           io::Write,

     

       4
       4
       +
           mem::swap,

     

       5
       5
       +
       };

     

       6
       6
       +
       

     

       7
       7
       +
       fn to_img(warehouse: &Vec<u8>, size: usize, name: usize) {

     

       8
       8
       +
           let mut bytes: Vec<u8> = [].to_vec();

     

       9
       9
       +
           bytes.extend(format!("P5\n{size} {size}\n1\n").as_bytes());

     

       10
       10
       +
           let mut i = size + 3;

     

       11
       11
       +
           for _ in 0..size {

     

       12
       12
       +
               for _ in 0..size {

     

       13
       13
       +
                   bytes.push(*warehouse.get(i).unwrap());

     

       14
       14
       +
                   i += 1;

     

       15
       15
       +
               }

     

       16
       16
       +
               i += 2;

     

       17
       17
       +
           }

     

       18
       18
       +
           let mut file = File::create(format!("out/{name}.pgm")).unwrap();

     

       19
       19
       +
           file.write_all(&bytes).unwrap();

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       fn solve(

     

       23
       23
       +
           mut warehouse: Vec<u8>,

     

       24
       24
       +
           size: usize,

     

       25
       25
       +
           part_2: bool,

     

       26
       26
       +
           visualise: bool,

     

       27
       27
       +
       ) -> u32 {

     

       28
       28
       +
           if visualise {

     

       29
       29
       +
               fs::create_dir_all("out").unwrap();

     

       30
       30
       +
           }

     

       31
       31
       +
       

     

       32
       32
       +
           let pos = |x, y| y * (size + 2) + x;

     

       33
       33
       +
       

     

       34
       34
       +
           let sizep = size + 1;

     

       35
       35
       +
       

     

       36
       36
       +
           let mut new_warehouse = vec![0_u8; (size + 2).pow(2)];

     

       37
       37
       +
       

     

       38
       38
       +
           let mut rolls = 0;

     

       39
       39
       +
       

     

       40
       40
       +
           let mut i = 0;

     

       41
       41
       +
           loop {

     

       42
       42
       +
               for yo in 1..sizep {

     

       43
       43
       +
                   let ym = yo - 1;

     

       44
       44
       +
                   let yp = yo + 1;

     

       45
       45
       +
                   for xo in 1..sizep {

     

       46
       46
       +
                       let xm = xo - 1;

     

       47
       47
       +
                       let xp = xo + 1;

     

       48
       48
       +
       

     

       49
       49
       +
                       unsafe {

     

       50
       50
       +
                           let was = *warehouse.get_unchecked(pos(xo, yo)) == 1;

     

       51
       51
       +
                           let neighbours = warehouse.get_unchecked(pos(xm, ym))

     

       52
       52
       +
                               + warehouse.get_unchecked(pos(xo, ym))

     

       53
       53
       +
                               + warehouse.get_unchecked(pos(xp, ym))

     

       54
       54
       +
                               + warehouse.get_unchecked(pos(xm, yo))

     

       55
       55
       +
                               + warehouse.get_unchecked(pos(xp, yo))

     

       56
       56
       +
                               + warehouse.get_unchecked(pos(xm, yp))

     

       57
       57
       +
                               + warehouse.get_unchecked(pos(xo, yp))

     

       58
       58
       +
                               + warehouse.get_unchecked(pos(xp, yp));

     

       59
       59
       +
                           *new_warehouse.get_unchecked_mut(pos(xo, yo)) =

     

       60
       60
       +
                               match (was, neighbours < 4) {

     

       61
       61
       +
                                   (true, true) => {

     

       62
       62
       +
                                       rolls += 1;

     

       63
       63
       +
                                       0

     

       64
       64
       +
                                   }

     

       65
       65
       +
                                   (true, false) => 1,

     

       66
       66
       +
                                   (_, _) => 0,

     

       67
       67
       +
                               };

     

       68
       68
       +
                       }

     

       69
       69
       +
                   }

     

       70
       70
       +
               }

     

       71
       71
       +
       

     

       72
       72
       +
               if !part_2 || warehouse == new_warehouse {

     

       73
       73
       +
                   break;

     

       74
       74
       +
               }

     

       75
       75
       +
       

     

       76
       76
       +
               swap(&mut warehouse, &mut new_warehouse);

     

       77
       77
       +
               i += 1;

     

       78
       78
       +
               if visualise {

     

       79
       79
       +
                   to_img(&warehouse, size, i);

     

       80
       80
       +
               }

     

       81
       81
       +
           }

     

       82
       82
       +
           rolls

     

       83
       83
       +
       }

     

       84
       84
       +
       

     

       85
       85
       +
       fn main() {

     

       86
       86
       +
           let input = include_str!("../../input.txt").trim();

     

       87
       87
       +
           let size = input.split_once("\n").expect("invalid input").0.len();

     

       88
       88
       +
           // reads the input but adds a line of buffer on the sides

     

       89
       89
       +
           let buffer_line = ".".repeat(size);

     

       90
       90
       +
           let input: Vec<u8> = format!("{buffer_line}\n{input}\n{buffer_line}")

     

       91
       91
       +
               .split("\n")

     

       92
       92
       +
               .map(|line| -> Vec<u8> {

     

       93
       93
       +
                   format!(".{}.", line)

     

       94
       94
       +
                       .chars()

     

       95
       95
       +
                       .map(|v| (v == '@') as u8)

     

       96
       96
       +
                       .collect()

     

       97
       97
       +
               })

     

       98
       98
       +
               .flatten()

     

       99
       99
       +
               .collect();

     

       100
       100
       +
       

     

       101
       101
       +
           let part_1 = solve(input.clone(), size, false, false);

     

       102
       102
       +
           println!("Part 1: {}", part_1);

     

       103
       103
       +
       

     

       104
       104
       +
           let part_2 = solve(input.clone(), size, true, true);

     

       105
       105
       +
           println!("Part 2: {}", part_2);

     

       106
       106
       +
       }

+20

2025/5/gleam/gleam.toml

···

       1
       1
       +
       name = "main"

     

       2
       2
       +
       version = "1.0.0"

     

       3
       3
       +
       

     

       4
       4
       +
       # Fill out these fields if you intend to generate HTML documentation or publish

     

       5
       5
       +
       # your project to the Hex package manager.

     

       6
       6
       +
       #

     

       7
       7
       +
       # description = ""

     

       8
       8
       +
       # licences = ["Apache-2.0"]

     

       9
       9
       +
       # repository = { type = "github", user = "", repo = "" }

     

       10
       10
       +
       # links = [{ title = "Website", href = "" }]

     

       11
       11
       +
       #

     

       12
       12
       +
       # For a full reference of all the available options, you can have a look at

     

       13
       13
       +
       # https://gleam.run/writing-gleam/gleam-toml/.

     

       14
       14
       +
       

     

       15
       15
       +
       [dependencies]

     

       16
       16
       +
       gleam_stdlib = ">= 0.44.0 and < 2.0.0"

     

       17
       17
       +
       simplifile = ">= 2.3.0 and < 3.0.0"

     

       18
       18
       +
       

     

       19
       19
       +
       [dev-dependencies]

     

       20
       20
       +
       gleeunit = ">= 1.0.0 and < 2.0.0"

+14

2025/5/gleam/manifest.toml

···

       1
       1
       +
       # This file was generated by Gleam

     

       2
       2
       +
       # You typically do not need to edit this file

     

       3
       3
       +
       

     

       4
       4
       +
       packages = [

     

       5
       5
       +
         { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },

     

       6
       6
       +
         { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },

     

       7
       7
       +
         { name = "gleeunit", version = "1.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "CD701726CBCE5588B375D157B4391CFD0F2F134CD12D9B6998A395484DE05C58" },

     

       8
       8
       +
         { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },

     

       9
       9
       +
       ]

     

       10
       10
       +
       

     

       11
       11
       +
       [requirements]

     

       12
       12
       +
       gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }

     

       13
       13
       +
       gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

     

       14
       14
       +
       simplifile = { version = ">= 2.3.0 and < 3.0.0" }

+117

2025/5/gleam/src/main.gleam

···

       1
       1
       +
       import gleam/int

     

       2
       2
       +
       import gleam/io

     

       3
       3
       +
       import gleam/list

     

       4
       4
       +
       import gleam/order.{Eq, Gt, Lt}

     

       5
       5
       +
       import gleam/set

     

       6
       6
       +
       import gleam/string

     

       7
       7
       +
       import simplifile as file

     

       8
       8
       +
       

     

       9
       9
       +
       pub fn main() {

     

       10
       10
       +
         let assert Ok(input) = file.read(from: "../input.txt")

     

       11
       11
       +
           as "Input file not found"

     

       12
       12
       +
         let assert [fresh_ranges, available] =

     

       13
       13
       +
           input |> string.trim |> string.split("\n\n")

     

       14
       14
       +
         let fresh_ranges =

     

       15
       15
       +
           fresh_ranges

     

       16
       16
       +
           |> string.trim

     

       17
       17
       +
           |> string.split("\n")

     

       18
       18
       +
           // |> list.reverse

     

       19
       19
       +
           // |> list.drop(5)

     

       20
       20
       +
           // |> list.take(12)

     

       21
       21
       +
           // |> list.reverse

     

       22
       22
       +
           |> list.map(fn(i) {

     

       23
       23
       +
             let assert [from, to] = i |> string.trim |> string.split("-")

     

       24
       24
       +
             let assert Ok(from) = int.parse(from)

     

       25
       25
       +
             let assert Ok(to) = int.parse(to)

     

       26
       26
       +
             // #(from / 100_000_000, to / 100_000_000)

     

       27
       27
       +
             #(from, to)

     

       28
       28
       +
           })

     

       29
       29
       +
         let available =

     

       30
       30
       +
           available

     

       31
       31
       +
           |> string.split("\n")

     

       32
       32
       +
           |> list.map(fn(i) {

     

       33
       33
       +
             let assert Ok(id) = int.parse(i)

     

       34
       34
       +
             id

     

       35
       35
       +
           })

     

       36
       36
       +
       

     

       37
       37
       +
         available

     

       38
       38
       +
         |> list.fold(0, fn(acc, i) {

     

       39
       39
       +
           acc

     

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

     

       41
       41
       +
             True -> 1

     

       42
       42
       +
             False -> 0

     

       43
       43
       +
           }

     

       44
       44
       +
         })

     

       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

     

       55
       55
       +
         // let haha =

     

       56
       56
       +
         //   fresh_ranges

     

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

     

       58
       58
       +
         //     list.range(i.0, i.1) |> list.fold(acc, fn(acc, i) { set.insert(acc, i) })

     

       59
       59
       +
         //   })

     

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

     

       61
       61
       +
       

     

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

     

       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
       +
                   #(-1, -1),

     

       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
       +
             })

     

       108
       108
       +
       

     

       109
       109
       +
           case range == #(-1, -1) {

     

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

     

       111
       111
       +
             True -> seen_ranges

     

       112
       112
       +
           }

     

       113
       113
       +
         })

     

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

     

       115
       115
       +
         |> int.to_string

     

       116
       116
       +
         |> io.println

     

       117
       117
       +
       }

+7

2025/5/rust/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

+6

2025/5/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+75

2025/5/rust/src/main.rs

···

       1
       1
       +
       use std::{

     

       2
       2
       +
           cmp::Ordering::{Equal as Eq, Greater as Gt, Less as Lt},

     

       3
       3
       +
           collections::HashSet,

     

       4
       4
       +
       };

     

       5
       5
       +
       

     

       6
       6
       +
       fn main() {

     

       7
       7
       +
           let input = include_str!("../../input.txt").trim();

     

       8
       8
       +
           let (fresh_ranges, available) = input.split_once("\n\n").unwrap();

     

       9
       9
       +
           let fresh_ranges: Vec<(u64, u64)> = fresh_ranges

     

       10
       10
       +
               .split("\n")

     

       11
       11
       +
               .map(|i| {

     

       12
       12
       +
                   let (a, b) = i.split_once("-").unwrap();

     

       13
       13
       +
                   (a.parse().unwrap(), b.parse().unwrap())

     

       14
       14
       +
               })

     

       15
       15
       +
               .collect();

     

       16
       16
       +
           let available = available.split("\n").map(|i| {

     

       17
       17
       +
               let i: u64 = i.parse().unwrap();

     

       18
       18
       +
               i

     

       19
       19
       +
           });

     

       20
       20
       +
       

     

       21
       21
       +
           let part_1 = available.fold(0, |acc, i| {

     

       22
       22
       +
               acc + fresh_ranges

     

       23
       23
       +
                   .iter()

     

       24
       24
       +
                   .any(|(start, end)| &i >= start && &i <= end) as u64

     

       25
       25
       +
           });

     

       26
       26
       +
           println!("Part 1: {}", part_1);

     

       27
       27
       +
       

     

       28
       28
       +
           let mut seen_ranges: HashSet<(u64, u64)> =

     

       29
       29
       +
               HashSet::with_capacity(fresh_ranges.len());

     

       30
       30
       +
           fresh_ranges.iter().for_each(|range| {

     

       31
       31
       +
               let range = seen_ranges.clone().iter().try_fold(

     

       32
       32
       +
                   *range,

     

       33
       33
       +
                   |range: (u64, u64), seen_range: &(u64, u64)| {

     

       34
       34
       +
                       // 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

     

       35
       35
       +
                       match (

     

       36
       36
       +
                           range.0.cmp(&seen_range.0),

     

       37
       37
       +
                           range.1.cmp(&seen_range.1),

     

       38
       38
       +
                           range.0.cmp(&seen_range.1),

     

       39
       39
       +
                           range.1.cmp(&seen_range.0),

     

       40
       40
       +
                       ) {

     

       41
       41
       +
                           // if there's no touching

     

       42
       42
       +
                           (Gt, Gt, Gt, Gt) | (Lt, Lt, Lt, Lt) => Some(range),

     

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

     

       44
       44
       +
                           (Gt, Lt, _, _)

     

       45
       45
       +
                           | (Eq, Lt, _, _)

     

       46
       46
       +
                           | (Gt, Eq, _, _)

     

       47
       47
       +
                           | (Eq, Eq, _, _) => None,

     

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

     

       49
       49
       +
                           (Lt, Gt, _, _) | (Eq, Gt, _, _) | (Lt, Eq, _, _) => {

     

       50
       50
       +
                               seen_ranges.remove(seen_range);

     

       51
       51
       +
                               Some(range)

     

       52
       52
       +
                           }

     

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

     

       54
       54
       +
                           (Lt, Lt, _, _) => {

     

       55
       55
       +
                               seen_ranges.remove(seen_range);

     

       56
       56
       +
                               Some((range.0, seen_range.1))

     

       57
       57
       +
                           }

     

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

     

       59
       59
       +
                           (Gt, Gt, _, _) => {

     

       60
       60
       +
                               seen_ranges.remove(seen_range);

     

       61
       61
       +
                               Some((seen_range.0, range.1))

     

       62
       62
       +
                           }

     

       63
       63
       +
                       }

     

       64
       64
       +
                   },

     

       65
       65
       +
               );

     

       66
       66
       +
       

     

       67
       67
       +
               if range.is_some() {

     

       68
       68
       +
                   seen_ranges.insert(range.unwrap());

     

       69
       69
       +
               }

     

       70
       70
       +
           });

     

       71
       71
       +
           let part_2 = seen_ranges

     

       72
       72
       +
               .into_iter()

     

       73
       73
       +
               .fold(0, |acc, range| acc + range.1 - range.0 + 1);

     

       74
       74
       +
           println!("Part 2: {}", part_2);

     

       75
       75
       +
       }

+20

2025/6/gleam/gleam.toml

···

       1
       1
       +
       name = "main"

     

       2
       2
       +
       version = "1.0.0"

     

       3
       3
       +
       

     

       4
       4
       +
       # Fill out these fields if you intend to generate HTML documentation or publish

     

       5
       5
       +
       # your project to the Hex package manager.

     

       6
       6
       +
       #

     

       7
       7
       +
       # description = ""

     

       8
       8
       +
       # licences = ["Apache-2.0"]

     

       9
       9
       +
       # repository = { type = "github", user = "", repo = "" }

     

       10
       10
       +
       # links = [{ title = "Website", href = "" }]

     

       11
       11
       +
       #

     

       12
       12
       +
       # For a full reference of all the available options, you can have a look at

     

       13
       13
       +
       # https://gleam.run/writing-gleam/gleam-toml/.

     

       14
       14
       +
       

     

       15
       15
       +
       [dependencies]

     

       16
       16
       +
       gleam_stdlib = ">= 0.44.0 and < 2.0.0"

     

       17
       17
       +
       simplifile = ">= 2.3.0 and < 3.0.0"

     

       18
       18
       +
       

     

       19
       19
       +
       [dev-dependencies]

     

       20
       20
       +
       gleeunit = ">= 1.0.0 and < 2.0.0"

+14

2025/6/gleam/manifest.toml

···

       1
       1
       +
       # This file was generated by Gleam

     

       2
       2
       +
       # You typically do not need to edit this file

     

       3
       3
       +
       

     

       4
       4
       +
       packages = [

     

       5
       5
       +
         { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },

     

       6
       6
       +
         { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },

     

       7
       7
       +
         { name = "gleeunit", version = "1.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "CD701726CBCE5588B375D157B4391CFD0F2F134CD12D9B6998A395484DE05C58" },

     

       8
       8
       +
         { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },

     

       9
       9
       +
       ]

     

       10
       10
       +
       

     

       11
       11
       +
       [requirements]

     

       12
       12
       +
       gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }

     

       13
       13
       +
       gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

     

       14
       14
       +
       simplifile = { version = ">= 2.3.0 and < 3.0.0" }

+140

2025/6/gleam/src/main.gleam

···

       1
       1
       +
       import gleam/dict

     

       2
       2
       +
       import gleam/int

     

       3
       3
       +
       import gleam/io

     

       4
       4
       +
       import gleam/list

     

       5
       5
       +
       import gleam/result

     

       6
       6
       +
       import gleam/string

     

       7
       7
       +
       import simplifile as file

     

       8
       8
       +
       

     

       9
       9
       +
       type Part2Dict =

     

       10
       10
       +
         dict.Dict(Int, Int)

     

       11
       11
       +
       

     

       12
       12
       +
       type Align {

     

       13
       13
       +
         Left

     

       14
       14
       +
         Right

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       type Operation {

     

       18
       18
       +
         Sum

     

       19
       19
       +
         Mul

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       type Part2Line {

     

       23
       23
       +
         Part2Line(align: Align, op: Operation, numbers: List(String))

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       pub fn main() {

     

       27
       27
       +
         let assert Ok(input) = file.read(from: "../input.txt")

     

       28
       28
       +
           as "Input file not found"

     

       29
       29
       +
         let input = input |> string.trim

     

       30
       30
       +
         let input_pt_1 =

     

       31
       31
       +
           list.fold(list.range(1, 10), input, fn(acc, _) {

     

       32
       32
       +
             acc |> string.replace("  ", " ")

     

       33
       33
       +
           })

     

       34
       34
       +
       

     

       35
       35
       +
         input_pt_1

     

       36
       36
       +
         |> string.split("\n")

     

       37
       37
       +
         |> list.map(fn(i) { string.trim(i) |> string.split(" ") })

     

       38
       38
       +
         |> list.transpose

     

       39
       39
       +
         |> list.map(fn(i) {

     

       40
       40
       +
           let i = list.reverse(i)

     

       41
       41
       +
           let assert Ok(s) = list.first(i)

     

       42
       42
       +
           let i =

     

       43
       43
       +
             list.drop(i, 1) |> list.map(fn(i) { int.parse(i) |> result.unwrap(0) })

     

       44
       44
       +
           let r = case s {

     

       45
       45
       +
             "+" -> int.sum(i)

     

       46
       46
       +
             "*" -> list.reduce(i, int.multiply) |> result.unwrap(0)

     

       47
       47
       +
             _ -> panic as "invalid"

     

       48
       48
       +
           }

     

       49
       49
       +
           r

     

       50
       50
       +
         })

     

       51
       51
       +
         |> int.sum

     

       52
       52
       +
         |> int.to_string

     

       53
       53
       +
         |> io.println

     

       54
       54
       +
       

     

       55
       55
       +
         let lines =

     

       56
       56
       +
           input

     

       57
       57
       +
           |> string.split("\n")

     

       58
       58
       +
           |> list.reverse

     

       59
       59
       +
         let assert Ok(last_line) = list.first(lines)

     

       60
       60
       +
         let #(_, bounds) =

     

       61
       61
       +
           { last_line <> "                         *" }

     

       62
       62
       +
           |> string.to_graphemes

     

       63
       63
       +
           |> list.index_fold(#(0, list.new()), fn(acc, char, i) {

     

       64
       64
       +
             let #(bound_start, bounds) = acc

     

       65
       65
       +
             case char {

     

       66
       66
       +
               "*" | "+" if i > 0 -> #(i, list.append([#(bound_start, i - 1)], bounds))

     

       67
       67
       +
               _ -> acc

     

       68
       68
       +
             }

     

       69
       69
       +
           })

     

       70
       70
       +
         bounds

     

       71
       71
       +
         |> list.index_fold(dict.new(), fn(d, bound, i) {

     

       72
       72
       +
           let numbers =

     

       73
       73
       +
             list.map(lines, fn(line) {

     

       74
       74
       +
               string.slice(line, bound.0, bound.1 - bound.0)

     

       75
       75
       +
             })

     

       76
       76
       +
           let align =

     

       77
       77
       +
             numbers

     

       78
       78
       +
             |> list.drop(1)

     

       79
       79
       +
             |> list.fold_until(Left, fn(res, number) {

     

       80
       80
       +
               case

     

       81
       81
       +
                 string.trim(number) == number,

     

       82
       82
       +
                 string.trim_start(number) == number

     

       83
       83
       +
               {

     

       84
       84
       +
                 True, _ -> list.Continue(res)

     

       85
       85
       +
                 _, True -> list.Stop(Left)

     

       86
       86
       +
                 _, _ -> list.Stop(Right)

     

       87
       87
       +
               }

     

       88
       88
       +
             })

     

       89
       89
       +
           let assert Ok(sign) = list.first(numbers)

     

       90
       90
       +
           let sign = case string.trim(sign) {

     

       91
       91
       +
             "*" -> Mul

     

       92
       92
       +
             "+" -> Sum

     

       93
       93
       +
             _ -> panic as sign

     

       94
       94
       +
           }

     

       95
       95
       +
           dict.insert(

     

       96
       96
       +
             d,

     

       97
       97
       +
             i,

     

       98
       98
       +
             Part2Line(

     

       99
       99
       +
               align,

     

       100
       100
       +
               sign,

     

       101
       101
       +
               numbers |> list.drop(1) |> list.map(string.trim) |> list.reverse,

     

       102
       102
       +
             ),

     

       103
       103
       +
           )

     

       104
       104
       +
         })

     

       105
       105
       +
         |> dict.to_list

     

       106
       106
       +
         |> list.map(fn(i) { i.1 })

     

       107
       107
       +
         |> list.map(fn(line) {

     

       108
       108
       +
           let d: Part2Dict = dict.new()

     

       109
       109
       +
           let d =

     

       110
       110
       +
             line.numbers

     

       111
       111
       +
             |> list.fold(d, fn(d, number) {

     

       112
       112
       +
               let number_len = string.length(number)

     

       113
       113
       +
               string.to_graphemes(number)

     

       114
       114
       +
               |> list.index_fold(d, fn(d, digit, index) {

     

       115
       115
       +
                 let assert Ok(digit) = digit |> int.parse

     

       116
       116
       +
                 let pos = case line.align {

     

       117
       117
       +
                   Right -> number_len - index

     

       118
       118
       +
                   Left -> index

     

       119
       119
       +
                 }

     

       120
       120
       +
                 dict.insert(

     

       121
       121
       +
                   d,

     

       122
       122
       +
                   pos,

     

       123
       123
       +
                   { dict.get(d, pos) |> result.unwrap(0) } * 10 + digit,

     

       124
       124
       +
                 )

     

       125
       125
       +
               })

     

       126
       126
       +
             })

     

       127
       127
       +
           let numbers =

     

       128
       128
       +
             dict.to_list(d)

     

       129
       129
       +
             |> list.map(fn(n) { n.1 })

     

       130
       130
       +
       

     

       131
       131
       +
           let r = case line.op {

     

       132
       132
       +
             Sum -> int.sum(numbers)

     

       133
       133
       +
             Mul -> list.reduce(numbers, int.multiply) |> result.unwrap(0)

     

       134
       134
       +
           }

     

       135
       135
       +
           r

     

       136
       136
       +
         })

     

       137
       137
       +
         |> int.sum

     

       138
       138
       +
         |> int.to_string

     

       139
       139
       +
         |> io.println

     

       140
       140
       +
       }

+20

2025/7/gleam/gleam.toml

···

       1
       1
       +
       name = "main"

     

       2
       2
       +
       version = "1.0.0"

     

       3
       3
       +
       

     

       4
       4
       +
       # Fill out these fields if you intend to generate HTML documentation or publish

     

       5
       5
       +
       # your project to the Hex package manager.

     

       6
       6
       +
       #

     

       7
       7
       +
       # description = ""

     

       8
       8
       +
       # licences = ["Apache-2.0"]

     

       9
       9
       +
       # repository = { type = "github", user = "", repo = "" }

     

       10
       10
       +
       # links = [{ title = "Website", href = "" }]

     

       11
       11
       +
       #

     

       12
       12
       +
       # For a full reference of all the available options, you can have a look at

     

       13
       13
       +
       # https://gleam.run/writing-gleam/gleam-toml/.

     

       14
       14
       +
       

     

       15
       15
       +
       [dependencies]

     

       16
       16
       +
       gleam_stdlib = ">= 0.44.0 and < 2.0.0"

     

       17
       17
       +
       simplifile = ">= 2.3.0 and < 3.0.0"

     

       18
       18
       +
       

     

       19
       19
       +
       [dev-dependencies]

     

       20
       20
       +
       gleeunit = ">= 1.0.0 and < 2.0.0"

+14

2025/7/gleam/manifest.toml

···

       1
       1
       +
       # This file was generated by Gleam

     

       2
       2
       +
       # You typically do not need to edit this file

     

       3
       3
       +
       

     

       4
       4
       +
       packages = [

     

       5
       5
       +
         { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },

     

       6
       6
       +
         { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },

     

       7
       7
       +
         { name = "gleeunit", version = "1.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "CD701726CBCE5588B375D157B4391CFD0F2F134CD12D9B6998A395484DE05C58" },

     

       8
       8
       +
         { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },

     

       9
       9
       +
       ]

     

       10
       10
       +
       

     

       11
       11
       +
       [requirements]

     

       12
       12
       +
       gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }

     

       13
       13
       +
       gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

     

       14
       14
       +
       simplifile = { version = ">= 2.3.0 and < 3.0.0" }

+93

2025/7/gleam/src/main.gleam

···

       1
       1
       +
       import gleam/dict

     

       2
       2
       +
       import gleam/int

     

       3
       3
       +
       import gleam/io

     

       4
       4
       +
       import gleam/list

     

       5
       5
       +
       import gleam/set

     

       6
       6
       +
       import gleam/string

     

       7
       7
       +
       import simplifile as file

     

       8
       8
       +
       

     

       9
       9
       +
       pub fn main() {

     

       10
       10
       +
         let assert Ok(input) = file.read(from: "../input.txt")

     

       11
       11
       +
           as "Input file not found"

     

       12
       12
       +
         let input = input |> string.trim |> string.split("\n")

     

       13
       13
       +
         let assert Ok(start) = input |> list.first

     

       14
       14
       +
         let start =

     

       15
       15
       +
           start

     

       16
       16
       +
           |> string.to_graphemes

     

       17
       17
       +
           |> list.index_fold(0, fn(acc, v, i) {

     

       18
       18
       +
             case v {

     

       19
       19
       +
               "S" -> i

     

       20
       20
       +
               _ -> acc

     

       21
       21
       +
             }

     

       22
       22
       +
           })

     

       23
       23
       +
         let splitters_map =

     

       24
       24
       +
           input

     

       25
       25
       +
           |> list.drop(1)

     

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

     

       27
       27
       +
             case i % 2 {

     

       28
       28
       +
               0 -> ""

     

       29
       29
       +
               _ -> line

     

       30
       30
       +
             }

     

       31
       31
       +
           })

     

       32
       32
       +
           |> list.filter(fn(line) { line != "" })

     

       33
       33
       +
           |> list.map(fn(line) {

     

       34
       34
       +
             line

     

       35
       35
       +
             |> string.to_graphemes

     

       36
       36
       +
             |> list.index_fold(set.new(), fn(d, char, i) {

     

       37
       37
       +
               case char {

     

       38
       38
       +
                 "^" -> set.insert(d, i)

     

       39
       39
       +
                 _ -> d

     

       40
       40
       +
               }

     

       41
       41
       +
             })

     

       42
       42
       +
           })

     

       43
       43
       +
         let #(_beams, times) =

     

       44
       44
       +
           splitters_map

     

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

     

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

     

       47
       47
       +
             beams

     

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

     

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

     

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

     

       51
       51
       +
                 False -> acc

     

       52
       52
       +
                 True -> #(

     

       53
       53
       +
                   beams

     

       54
       54
       +
                     |> set.delete(beam)

     

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

     

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

     

       57
       57
       +
                   times + 1,

     

       58
       58
       +
                 )

     

       59
       59
       +
               }

     

       60
       60
       +
             })

     

       61
       61
       +
           })

     

       62
       62
       +
       

     

       63
       63
       +
         times

     

       64
       64
       +
         |> int.to_string

     

       65
       65
       +
         |> io.println

     

       66
       66
       +
       

     

       67
       67
       +
         let timelines =

     

       68
       68
       +
           splitters_map

     

       69
       69
       +
           |> list.index_fold(

     

       70
       70
       +
             dict.new() |> dict.insert("", start),

     

       71
       71
       +
             fn(timelines, splitters, i) {

     

       72
       72
       +
               echo i

     

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

     

       74
       74
       +
               timelines

     

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

     

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

     

       77
       77
       +
                   False -> timelines

     

       78
       78
       +
                   True -> {

     

       79
       79
       +
                     timelines

     

       80
       80
       +
                     |> dict.delete(timeline)

     

       81
       81
       +
                     |> dict.insert(timeline <> "-", beam - 1)

     

       82
       82
       +
                     |> dict.insert(timeline <> "+", beam + 1)

     

       83
       83
       +
                   }

     

       84
       84
       +
                 }

     

       85
       85
       +
               })

     

       86
       86
       +
             },

     

       87
       87
       +
           )

     

       88
       88
       +
         echo timelines

     

       89
       89
       +
         timelines

     

       90
       90
       +
         |> dict.size

     

       91
       91
       +
         |> int.to_string

     

       92
       92
       +
         |> io.println

     

       93
       93
       +
       }

+7

2025/7/rust/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

+6

2025/7/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+62

2025/7/rust/src/main.rs

···

       1
       1
       +
       use std::{

     

       2
       2
       +
           collections::{HashMap, HashSet},

     

       3
       3
       +
           mem::swap,

     

       4
       4
       +
       };

     

       5
       5
       +
       

     

       6
       6
       +
       fn main() {

     

       7
       7
       +
           let input = include_str!("../../input.txt").trim();

     

       8
       8
       +
       

     

       9
       9
       +
           let input: Vec<&str> = input.trim().split("\n").collect();

     

       10
       10
       +
           // let width = input[0].len() as u64;

     

       11
       11
       +
           let start = input[0].find("S").unwrap() as u64;

     

       12
       12
       +
           let splitters_map: Vec<HashSet<u64>> = input[0..input.len()]

     

       13
       13
       +
               .iter()

     

       14
       14
       +
               .enumerate()

     

       15
       15
       +
               .map(|(i, line)| if i % 2 != 0 { "" } else { line })

     

       16
       16
       +
               .filter(|line| line != &"")

     

       17
       17
       +
               .map(|line| {

     

       18
       18
       +
                   line.chars()

     

       19
       19
       +
                       .enumerate()

     

       20
       20
       +
                       .fold(HashSet::new(), |mut s, (i, char)| {

     

       21
       21
       +
                           if char == '^' {

     

       22
       22
       +
                               s.insert(i as u64);

     

       23
       23
       +
                           }

     

       24
       24
       +
                           s

     

       25
       25
       +
                       })

     

       26
       26
       +
               })

     

       27
       27
       +
               .collect();

     

       28
       28
       +
       

     

       29
       29
       +
           let timelines = {

     

       30
       30
       +
               let mut timelines: HashMap<u64, u64> = HashMap::new();

     

       31
       31
       +
               timelines.insert(start, 1);

     

       32
       32
       +
               let mut timelines_new: HashMap<u64, u64> = HashMap::new();

     

       33
       33
       +
               for splitters in splitters_map {

     

       34
       34
       +
                   for (pos, amount) in &timelines {

     

       35
       35
       +
                       if splitters.contains(&pos) {

     

       36
       36
       +
                           let m1 = timelines_new.entry(pos - 1).or_insert(0);

     

       37
       37
       +
                           *m1 += amount;

     

       38
       38
       +
                           let p1 = timelines_new.entry(pos + 1).or_insert(0);

     

       39
       39
       +
                           *p1 += amount;

     

       40
       40
       +
                       } else {

     

       41
       41
       +
                           let e = timelines_new.entry(*pos).or_insert(0);

     

       42
       42
       +
                           *e += amount;

     

       43
       43
       +
                       }

     

       44
       44
       +
                   }

     

       45
       45
       +
                   // for pos in 0..width as u64 {

     

       46
       46
       +
                   //     if splitters.contains(&pos) {

     

       47
       47
       +
                   //         print!("^");

     

       48
       48
       +
                   //     } else if timelines_new.contains_key(&pos) {

     

       49
       49
       +
                   //         print!("|");

     

       50
       50
       +
                   //     } else {

     

       51
       51
       +
                   //         print!(".");

     

       52
       52
       +
                   //     }

     

       53
       53
       +
                   // }

     

       54
       54
       +
                   // print!("\n\n");

     

       55
       55
       +
                   swap(&mut timelines, &mut timelines_new);

     

       56
       56
       +
                   timelines_new.clear();

     

       57
       57
       +
               }

     

       58
       58
       +
               timelines

     

       59
       59
       +
           };

     

       60
       60
       +
           // println!("{:?}", timelines);

     

       61
       61
       +
           println!("{}", timelines.iter().fold(0, |acc, v| { acc + v.1 }))

     

       62
       62
       +
       }

+21

LICENSE

···

       1
       1
       +
       MIT License

     

       2
       2
       +
       

     

       3
       3
       +
       Copyright (c) 2025 aylac.top

     

       4
       4
       +
       

     

       5
       5
       +
       Permission is hereby granted, free of charge, to any person obtaining a copy

     

       6
       6
       +
       of this software and associated documentation files (the "Software"), to deal

     

       7
       7
       +
       in the Software without restriction, including without limitation the rights

     

       8
       8
       +
       to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

     

       9
       9
       +
       copies of the Software, and to permit persons to whom the Software is

     

       10
       10
       +
       furnished to do so, subject to the following conditions:

     

       11
       11
       +
       

     

       12
       12
       +
       The above copyright notice and this permission notice shall be included in all

     

       13
       13
       +
       copies or substantial portions of the Software.

     

       14
       14
       +
       

     

       15
       15
       +
       THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

     

       16
       16
       +
       IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

     

       17
       17
       +
       FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

     

       18
       18
       +
       AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

     

       19
       19
       +
       LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

     

       20
       20
       +
       OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

     

       21
       21
       +
       SOFTWARE.

+2

rustfmt.toml

···

       1
       1
       +
       edition = "2024"

     

       2
       2
       +
       max_width = 80

+14

shell.nix

···

       4
       4
        
       #in

     

       5
       5
        
       pkgs.mkShellNoCC {

     

       6
       6
        
         #inputsFrom = [ defaultPackage ];

     

       7
       7
       +
         #

     

       8
       8
       +
         env = {

     

       9
       9
       +
           RUST_SRC_PATH = pkgs.rustPlatform.rustLibSrc;

     

       10
       10
       +
         };

     

       7
       11
        
       

     

       8
       12
        
         packages = with pkgs; [

     

       9
       13
        
           bun

     
···

       11
       15
        
           gleam

     

       12
       16
        
           beam28Packages.erlang

     

       13
       17
        
           beam28Packages.rebar3

     

       18
       18
       +
       

     

       19
       19
       +
           elixir

     

       20
       20
       +
       

     

       21
       21
       +
           rustc

     

       22
       22
       +
           cargo

     

       23
       23
       +
           clippy

     

       24
       24
       +
           rustfmt

     

       25
       25
       +
           rust-analyzer

     

       26
       26
       +
       

     

       27
       27
       +
           clang

     

       14
       28
        
       

     

       15
       29
        
           hyperfine

     

       16
       30
        
           fish

+8

template/elixir/main.exs

···

       1
       1
       +
       defmodule Main do

     

       2
       2
       +
         {_, input} =

     

       3
       3
       +
           File.read("../input.txt")

     

       4
       4
       +
       

     

       5
       5
       +
         input = input |> String.trim()

     

       6
       6
       +
       

     

       7
       7
       +
         IO.puts(input)

     

       8
       8
       +
       end

+7

template/rust/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

+6

template/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+5

template/rust/src/main.rs

···

       1
       1
       +
       fn main() {

     

       2
       2
       +
           let input = include_str!("../../input.txt").trim();

     

       3
       3
       +
       

     

       4
       4
       +
           println!("{}", &input);

     

       5
       5
       +
       }

+39

template/zig/build.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       

     

       3
       3
       +
       pub fn build(b: *std.Build) void {

     

       4
       4
       +
           const target = b.standardTargetOptions(.{});

     

       5
       5
       +
       

     

       6
       6
       +
           const optimize = b.standardOptimizeOption(.{});

     

       7
       7
       +
       

     

       8
       8
       +
           const exe = b.addExecutable(.{

     

       9
       9
       +
               .name = "zig",

     

       10
       10
       +
               .root_module = b.createModule(.{

     

       11
       11
       +
                   .root_source_file = b.path("src/main.zig"),

     

       12
       12
       +
       

     

       13
       13
       +
                   .target = target,

     

       14
       14
       +
                   .optimize = optimize,

     

       15
       15
       +
               }),

     

       16
       16
       +
           });

     

       17
       17
       +
       

     

       18
       18
       +
           b.installArtifact(exe);

     

       19
       19
       +
       

     

       20
       20
       +
           const run_step = b.step("run", "Run the app");

     

       21
       21
       +
       

     

       22
       22
       +
           const run_cmd = b.addRunArtifact(exe);

     

       23
       23
       +
           run_step.dependOn(&run_cmd.step);

     

       24
       24
       +
       

     

       25
       25
       +
           run_cmd.step.dependOn(b.getInstallStep());

     

       26
       26
       +
       

     

       27
       27
       +
           if (b.args) |args| {

     

       28
       28
       +
               run_cmd.addArgs(args);

     

       29
       29
       +
           }

     

       30
       30
       +
       

     

       31
       31
       +
           const exe_tests = b.addTest(.{

     

       32
       32
       +
               .root_module = exe.root_module,

     

       33
       33
       +
           });

     

       34
       34
       +
       

     

       35
       35
       +
           const run_exe_tests = b.addRunArtifact(exe_tests);

     

       36
       36
       +
       

     

       37
       37
       +
           const test_step = b.step("test", "Run tests");

     

       38
       38
       +
           test_step.dependOn(&run_exe_tests.step);

     

       39
       39
       +
       }

+6

template/zig/src/main.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       const raw_input = @embedFile("./input.txt");

     

       3
       3
       +
       

     

       4
       4
       +
       pub fn main() !void {

     

       5
       5
       +
           std.debug.print("{s}", .{raw_input});

     

       6
       6
       +
       }

Compare changes