comparing b56be8f084ee26049b071567633b09f623d9cc35 and main on aylac.top/advent_of_code

.gitattributes

···

       1
       +
       template/** -linguist-detectable

     

       2
       +
       build.zig -linguist-detectable

     

       3
       +
       template/** linguist-vendored

     

       4
       +
       build.zig linguist-vendored

+11

.gitignore

···

       5
        
       input_example.txt

     

       6
        
       _build

     

       7
        
       target

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       5
        
       input_example.txt

     

       6
        
       _build

     

       7
        
       target

     

       8
       +
       zig-out

     

       9
       +
       .zig-cache

     

       10
       +
       out

     

       11
       +
       *.ppm

     

       12
       +
       *.pgm

     

       13
       +
       *.pbm

     

       14
       +
       *.bmp

     

       15
       +
       *.png

     

       16
       +
       *.gif

     

       17
       +
       *.qoi

     

       18
       +
       *.txt

-10

2015/16/sue.txt

···

       1
       -
       children: 3

     

       2
       -
       cats: 7

     

       3
       -
       samoyeds: 2

     

       4
       -
       pomeranians: 3

     

       5
       -
       akitas: 0

     

       6
       -
       vizslas: 0

     

       7
       -
       goldfish: 5

     

       8
       -
       trees: 3

     

       9
       -
       cars: 2

     

       10
       -
       perfumes: 1

2015/18/rust/Cargo.lock

···

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

     

       2
       +
       # It is not intended for manual editing.

     

       3
       +
       version = 4

     

       4
       +
       

     

       5
       +
       [[package]]

     

       6
       +
       name = "rust"

     

       7
       +
       version = "0.1.0"

2015/18/rust/Cargo.toml

···

       1
       +
       [package]

     

       2
       +
       name = "rust"

     

       3
       +
       version = "0.1.0"

     

       4
       +
       edition = "2024"

     

       5
       +
       

     

       6
       +
       [dependencies]

+90

2015/18/rust/src/main.rs

···

       1
       +
       use std::mem::swap;

     

       2
       +
       

     

       3
       +
       fn generations(

     

       4
       +
           times: u32,

     

       5
       +
           mut world: Vec<u8>,

     

       6
       +
           size: usize,

     

       7
       +
           stuck: bool,

     

       8
       +
       ) -> Vec<u8> {

     

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

     

       10
       +
       

     

       11
       +
           let sizep = size + 1;

     

       12
       +
       

     

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

     

       14
       +
       

     

       15
       +
           unsafe {

     

       16
       +
               if stuck {

     

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

     

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

     

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

     

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

     

       21
       +
               }

     

       22
       +
           }

     

       23
       +
       

     

       24
       +
           for _ in 0..times {

     

       25
       +
               for yo in 1..sizep {

     

       26
       +
                   let ym = yo - 1;

     

       27
       +
                   let yp = yo + 1;

     

       28
       +
                   for xo in 1..sizep {

     

       29
       +
                       let xm = xo - 1;

     

       30
       +
                       let xp = xo + 1;

     

       31
       +
       

     

       32
       +
                       unsafe {

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       44
       +
                       }

     

       45
       +
                   }

     

       46
       +
               }

     

       47
       +
       

     

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

     

       49
       +
       

     

       50
       +
               // i hate the duplication here :(

     

       51
       +
               unsafe {

     

       52
       +
                   if stuck {

     

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

     

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

     

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

     

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

     

       57
       +
                   }

     

       58
       +
               }

     

       59
       +
           }

     

       60
       +
           world

     

       61
       +
       }

     

       62
       +
       

     

       63
       +
       fn main() {

     

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

     

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

     

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

     

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

     

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

     

       69
       +
               .split("\n")

     

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

     

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

     

       72
       +
                       .chars()

     

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

     

       74
       +
                       .collect()

     

       75
       +
               })

     

       76
       +
               .flatten()

     

       77
       +
               .collect();

     

       78
       +
       

     

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

     

       80
       +
               .iter()

     

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

     

       82
       +
               .count();

     

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

     

       84
       +
       

     

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

     

       86
       +
               .iter()

     

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

     

       88
       +
               .count();

     

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

     

       90
       +
       }

+40 -18

2015/19/rust/src/main.rs

···

       1
       -
       struct Combination {

     

       2
       -
           original: String,

     

       3
       -
           target: String,

     

       4
       -
       }

     

       5
        
       

     

       6
        
       fn main() {

     

       7
       -
           let input: String = std::fs::read_to_string("../input.txt").expect("invalid input!!");

     

       8
       -
           let input: Vec<&str> = input.split("\n").collect();

     

       9
       -
           let combinations: Vec<Combination> = &input[..input.len() - 2].iter().map(|v| {

     

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

     

       11
       -
               match v[..] {

     

       12
       -
                   [original, _, target] => Combination {

     

       13
       -
                       original: original.to_string(),

     

       14
       -
                       target: target.to_string(),

     

       15
       -
                   },

     

       16
       -
                   _ => Combination {

     

       17
       -
                       original: "".to_string(),

     

       18
       -
                       target: "".to_string(),

     

       19
       -
                   },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       20
        
               }

     

       21
       -
           }).

     

       0
        
       
     

       22
        
       }

···

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2
        
       

     

       3
        
       fn main() {

     

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

     

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

     

       6
       +
       

     

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

     

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

     

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

     

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

     

       11
       +
                   match v[..] {

     

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

     

       13
       +
                           let entry = combinations

     

       14
       +
                               .entry(original.to_string())

     

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

     

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

     

       17
       +
                       }

     

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

     

       19
       +
                   }

     

       20
       +
               });

     

       21
       +
               combinations

     

       22
       +
           };

     

       23
       +
       

     

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

     

       25
       +
       

     

       26
       +
           // part 1

     

       27
       +
           {

     

       28
       +
               let mol_len = medicine_mol.len();

     

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

     

       30
       +
               for i in 0..mol_len {

     

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

     

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

     

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

     

       34
       +
                           possibilities.insert(format!(

     

       35
       +
                               "{}{}",

     

       36
       +
                               a,

     

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

     

       38
       +
                           ));

     

       39
       +
                       })

     

       40
       +
                   });

     

       41
        
               }

     

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

     

       43
       +
           }

     

       44
        
       }

+2 -1

2015/2/rust/src/main.rs

···

       1
        
       use itertools::Itertools;

     

       2
        
       

     

       3
        
       fn main() {

     

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

     

       0
        
       
     

       5
        
           let input = input

     

       6
        
               .trim()

     

       7
        
               .split("\n")

···

       1
        
       use itertools::Itertools;

     

       2
        
       

     

       3
        
       fn main() {

     

       4
       +
           let input =

     

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

     

       6
        
           let input = input

     

       7
        
               .trim()

     

       8
        
               .split("\n")

2015/20/rust/Cargo.lock

···

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

     

       2
       +
       # It is not intended for manual editing.

     

       3
       +
       version = 4

     

       4
       +
       

     

       5
       +
       [[package]]

     

       6
       +
       name = "rust"

     

       7
       +
       version = "0.1.0"

2015/20/rust/Cargo.toml

···

       1
       +
       [package]

     

       2
       +
       name = "rust"

     

       3
       +
       version = "0.1.0"

     

       4
       +
       edition = "2024"

     

       5
       +
       

     

       6
       +
       [dependencies]

+33

2015/20/rust/src/main.rs

···

       1
       +
       fn main() {

     

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

     

       3
       +
               .trim()

     

       4
       +
               .parse()

     

       5
       +
               .expect("bad input");

     

       6
       +
           let input = input / 10;

     

       7
       +
       

     

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

     

       9
       +
           let mut house: u64 = 1;

     

       10
       +
           // while highest_house.1 < input {

     

       11
       +
           while house < 10 {

     

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

     

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

     

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

     

       15
       +
                   })

     

       16
       +
               } else {

     

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

     

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

     

       19
       +
                           acc + elf

     

       20
       +
                       } else {

     

       21
       +
                           acc

     

       22
       +
                       }

     

       23
       +
                   })

     

       24
       +
               };

     

       25
       +
               if presents > highest_house.1 {

     

       26
       +
                   highest_house = (house, presents);

     

       27
       +
               }

     

       28
       +
               house += 1;

     

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

     

       30
       +
           }

     

       31
       +
       

     

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

     

       33
       +
       }

+2 -1

2015/4/rust/src/main.rs

···

       21
        
       }

     

       22
        
       

     

       23
        
       fn main() {

     

       24
       -
           let input = std::fs::read_to_string("../input.txt").expect("invalid input!!");

     

       0
        
       
     

       25
        
           let input = input.trim();

     

       26
        
       

     

       27
        
           let res = find(input, 5);

···

       21
        
       }

     

       22
        
       

     

       23
        
       fn main() {

     

       24
       +
           let input =

     

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

     

       26
        
           let input = input.trim();

     

       27
        
       

     

       28
        
           let res = find(input, 5);

+13 -13

2025/1/gleam/src/main.gleam

···

       6
        
       import simplifile as file

     

       7
        
       

     

       8
        
       pub type RotationState {

     

       9
       -
         RotationState(number: Int, zeroes: Int)

     

       10
        
       }

     

       11
        
       

     

       12
        
       pub fn main() {

     
···

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

     

       20
        
             case l {

     

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

     

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

     

       23
        
               _ -> panic as "bad input"

     

       24
        
             }

     

       25
        
           })

     
···

       28
        
           input

     

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

     

       30
        
             let new_number =

     

       31
       -
               int.modulo(acc.number + v, 100)

     

       32
        
               |> result.unwrap(0)

     

       33
        
             RotationState(new_number, case new_number {

     

       34
        
               0 -> acc.zeroes + 1

     
···

       42
        
         let part2 =

     

       43
        
           input

     

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

     

       45
       -
             let raw_new_number = acc.number + v

     

       46
       -
             let new_number = int.modulo(raw_new_number, 100) |> result.unwrap(0)

     

       47
       -
             let times_it_went_zero = {

     

       48
       -
               let value = int.absolute_value(raw_new_number / 100)

     

       49
       -
               case acc.number != 0, raw_new_number > 0 {

     

       50
       -
                 True, False -> value + 1

     

       51
       -
                 _, _ -> value

     

       0
        
       
     

       0
        
       
     

       52
        
               }

     

       53
       -
             }

     

       54
       -
             RotationState(new_number, acc.zeroes + times_it_went_zero)

     

       55
        
           })

     

       56
       -
       

     

       57
        
         part2.zeroes

     

       58
        
         |> int.to_string

     

       59
        
         |> io.println

···

       6
        
       import simplifile as file

     

       7
        
       

     

       8
        
       pub type RotationState {

     

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

     

       10
        
       }

     

       11
        
       

     

       12
        
       pub fn main() {

     
···

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

     

       20
        
             case l {

     

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

     

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

     

       23
        
               _ -> panic as "bad input"

     

       24
        
             }

     

       25
        
           })

     
···

       28
        
           input

     

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

     

       30
        
             let new_number =

     

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

     

       32
        
               |> result.unwrap(0)

     

       33
        
             RotationState(new_number, case new_number {

     

       34
        
               0 -> acc.zeroes + 1

     
···

       42
        
         let part2 =

     

       43
        
           input

     

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

     

       45
       +
             let raw_new_number = acc.turn + v

     

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

     

       47
       +
             let zeroes =

     

       48
       +
               acc.zeroes

     

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

     

       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
       +
                 // of course, there is no need to deal with a negative to positive situation because the acc.turn will never be negative!!!

     

       52
       +
                 True -> raw_zeroes + 1

     

       53
       +
                 False -> raw_zeroes

     

       54
        
               }

     

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

     

       0
        
       
     

       56
        
           })

     

       0
        
       
     

       57
        
         part2.zeroes

     

       58
        
         |> int.to_string

     

       59
        
         |> io.println

-10

2025/1/input_example.txt

2025/1/rust/Cargo.lock

···

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

     

       2
       +
       # It is not intended for manual editing.

     

       3
       +
       version = 4

     

       4
       +
       

     

       5
       +
       [[package]]

     

       6
       +
       name = "rust"

     

       7
       +
       version = "0.1.0"

2025/1/rust/Cargo.toml

···

       1
       +
       [package]

     

       2
       +
       name = "rust"

     

       3
       +
       version = "0.1.0"

     

       4
       +
       edition = "2024"

     

       5
       +
       

     

       6
       +
       [dependencies]

+53

2025/1/rust/src/main.rs

···

       1
       +
       struct State {

     

       2
       +
           turn: i32,

     

       3
       +
           zeroes: i32,

     

       4
       +
       }

     

       5
       +
       

     

       6
       +
       fn main() {

     

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

     

       8
       +
               .trim()

     

       9
       +
               .split("\n")

     

       10
       +
               .map(|n| {

     

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

     

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

     

       13
       +
                       .parse::<i32>()

     

       14
       +
                       .expect("invalid input")

     

       15
       +
               })

     

       16
       +
               .collect();

     

       17
       +
       

     

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

     

       19
       +
               State {

     

       20
       +
                   turn: 50,

     

       21
       +
                   zeroes: 0,

     

       22
       +
               },

     

       23
       +
               |acc, n| {

     

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

     

       25
       +
                   State {

     

       26
       +
                       turn,

     

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

     

       28
       +
                   }

     

       29
       +
               },

     

       30
       +
           );

     

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

     

       32
       +
       

     

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

     

       34
       +
               State {

     

       35
       +
                   turn: 50,

     

       36
       +
                   zeroes: 0,

     

       37
       +
               },

     

       38
       +
               |acc, n| {

     

       39
       +
                   let raw_turn = acc.turn + n;

     

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

     

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

     

       42
       +
                   State {

     

       43
       +
                       turn,

     

       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
       +
                       // of course, there is no need to deal with a negative to positive situation because the acc.turn will never be negative!!!

     

       46
       +
                       zeroes: acc.zeroes

     

       47
       +
                           + raw_zeroes

     

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

     

       49
       +
                   }

     

       50
       +
               },

     

       51
       +
           );

     

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

     

       53
       +
       }

+39

2025/1/zig/build.zig

···

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

     

       2
       +
       

     

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

     

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

     

       5
       +
       

     

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

     

       7
       +
       

     

       8
       +
           const exe = b.addExecutable(.{

     

       9
       +
               .name = "zig",

     

       10
       +
               .root_module = b.createModule(.{

     

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

     

       12
       +
       

     

       13
       +
                   .target = target,

     

       14
       +
                   .optimize = optimize,

     

       15
       +
               }),

     

       16
       +
           });

     

       17
       +
       

     

       18
       +
           b.installArtifact(exe);

     

       19
       +
       

     

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

     

       21
       +
       

     

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

     

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

     

       24
       +
       

     

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

     

       26
       +
       

     

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

     

       28
       +
               run_cmd.addArgs(args);

     

       29
       +
           }

     

       30
       +
       

     

       31
       +
           const exe_tests = b.addTest(.{

     

       32
       +
               .root_module = exe.root_module,

     

       33
       +
           });

     

       34
       +
       

     

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

     

       36
       +
       

     

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

     

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

     

       39
       +
       }

+40

2025/1/zig/src/main.zig

···

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

     

       2
       +
       

     

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

     

       4
       +
       

     

       5
       +
       pub fn main() !void {

     

       6
       +
           const allocator = std.heap.page_allocator;

     

       7
       +
       

     

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

     

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

     

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

     

       11
       +
       

     

       12
       +
           const turns_len =

     

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

     

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

     

       15
       +
           defer allocator.free(turns);

     

       16
       +
       

     

       17
       +
           var i: u32 = 0;

     

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

     

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

     

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

     

       21
       +
               i += 1;

     

       22
       +
           }

     

       23
       +
       

     

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

     

       25
       +
           for (turns) |turn| {

     

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

     

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

     

       28
       +
           }

     

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

     

       30
       +
       

     

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

     

       32
       +
           for (turns) |turn| {

     

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

     

       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
       +
               // of course, there is no need to deal with a negative to positive situation because the acc.turn will never be negative!!!

     

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

     

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

     

       38
       +
           }

     

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

     

       40
       +
       }

+20

2025/2/gleam/gleam.toml

···

       1
       +
       name = "main"

     

       2
       +
       version = "1.0.0"

     

       3
       +
       

     

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

     

       5
       +
       # your project to the Hex package manager.

     

       6
       +
       #

     

       7
       +
       # description = ""

     

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

     

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

     

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

     

       11
       +
       #

     

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

     

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

     

       14
       +
       

     

       15
       +
       [dependencies]

     

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

     

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

     

       18
       +
       

     

       19
       +
       [dev-dependencies]

     

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

+14

2025/2/gleam/manifest.toml

···

       1
       +
       # This file was generated by Gleam

     

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

     

       3
       +
       

     

       4
       +
       packages = [

     

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

     

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

     

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

     

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

     

       9
       +
       ]

     

       10
       +
       

     

       11
       +
       [requirements]

     

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

     

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

     

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

+70

2025/2/gleam/src/main.gleam

···

       1
       +
       import gleam/int

     

       2
       +
       import gleam/io

     

       3
       +
       import gleam/list

     

       4
       +
       import gleam/result

     

       5
       +
       import gleam/string

     

       6
       +
       import simplifile as file

     

       7
       +
       

     

       8
       +
       type Range {

     

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

     

       10
       +
       }

     

       11
       +
       

     

       12
       +
       pub fn main() {

     

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

     

       14
       +
           as "Input file not found"

     

       15
       +
         let input =

     

       16
       +
           input

     

       17
       +
           |> string.trim

     

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

     

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

     

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

     

       21
       +
               [start, end] ->

     

       22
       +
                 Range(

     

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

     

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

     

       25
       +
                 )

     

       26
       +
               _ -> panic as "invalid input"

     

       27
       +
             }

     

       28
       +
           })

     

       29
       +
       

     

       30
       +
         input

     

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

     

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

     

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

     

       34
       +
             let s = int.to_string(i)

     

       35
       +
             let len = string.length(s)

     

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

     

       37
       +
               True -> acc + i

     

       38
       +
               False -> acc

     

       39
       +
             }

     

       40
       +
           })

     

       41
       +
         })

     

       42
       +
         |> int.to_string

     

       43
       +
         |> io.println

     

       44
       +
       

     

       45
       +
         input

     

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

     

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

     

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

     

       49
       +
             case i > 10 {

     

       50
       +
               True -> {

     

       51
       +
                 let s = int.to_string(i)

     

       52
       +
                 let len = string.length(s)

     

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

     

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

     

       55
       +
                   let n =

     

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

     

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

     

       58
       +
                   case n == s {

     

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

     

       60
       +
                     False -> list.Continue(acc)

     

       61
       +
                   }

     

       62
       +
                 })

     

       63
       +
               }

     

       64
       +
               False -> acc

     

       65
       +
             }

     

       66
       +
           })

     

       67
       +
         })

     

       68
       +
         |> int.to_string

     

       69
       +
         |> io.println

     

       70
       +
       }

2025/2/rust/Cargo.lock

···

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

     

       2
       +
       # It is not intended for manual editing.

     

       3
       +
       version = 4

     

       4
       +
       

     

       5
       +
       [[package]]

     

       6
       +
       name = "rust"

     

       7
       +
       version = "0.1.0"

2025/2/rust/Cargo.toml

···

       1
       +
       [package]

     

       2
       +
       name = "rust"

     

       3
       +
       version = "0.1.0"

     

       4
       +
       edition = "2024"

     

       5
       +
       

     

       6
       +
       [dependencies]

+73

2025/2/rust/src/main.rs

···

       1
       +
       use std::collections::HashSet;

     

       2
       +
       

     

       3
       +
       struct Range {

     

       4
       +
           start: u64,

     

       5
       +
           end: u64,

     

       6
       +
       }

     

       7
       +
       

     

       8
       +
       const MAX_LENGTH: usize = 10;

     

       9
       +
       

     

       10
       +
       fn main() {

     

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

     

       12
       +
               .trim()

     

       13
       +
               .split(",")

     

       14
       +
               .map(|v| {

     

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

     

       16
       +
                   match range {

     

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

     

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

     

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

     

       20
       +
                       },

     

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

     

       22
       +
                   }

     

       23
       +
               })

     

       24
       +
               .collect();

     

       25
       +
       

     

       26
       +
           let powers_of_ten: Vec<u64> =

     

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

     

       28
       +
       

     

       29
       +
           let [invalid_part_1, invalid_part_2] = {

     

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

     

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

     

       32
       +
       

     

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

     

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

     

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

     

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

     

       37
       +
                   {

     

       38
       +
                       let mut number = 0;

     

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

     

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

     

       41
       +
                           number += combination

     

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

     

       43
       +
                           if repeat > 0 {

     

       44
       +
                               part_2.insert(number);

     

       45
       +
                           }

     

       46
       +
                           if repeat == 1 {

     

       47
       +
                               part_1.insert(number);

     

       48
       +
                           }

     

       49
       +
                       }

     

       50
       +
                   }

     

       51
       +
               }

     

       52
       +
       

     

       53
       +
               [part_1, part_2]

     

       54
       +
           };

     

       55
       +
       

     

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

     

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

     

       58
       +
                   acc + number

     

       59
       +
               } else {

     

       60
       +
                   acc

     

       61
       +
               }

     

       62
       +
           });

     

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

     

       64
       +
       

     

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

     

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

     

       67
       +
                   acc + number

     

       68
       +
               } else {

     

       69
       +
                   acc

     

       70
       +
               }

     

       71
       +
           });

     

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

     

       73
       +
       }

+20

2025/3/gleam/gleam.toml

···

       1
       +
       name = "main"

     

       2
       +
       version = "1.0.0"

     

       3
       +
       

     

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

     

       5
       +
       # your project to the Hex package manager.

     

       6
       +
       #

     

       7
       +
       # description = ""

     

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

     

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

     

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

     

       11
       +
       #

     

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

     

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

     

       14
       +
       

     

       15
       +
       [dependencies]

     

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

     

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

     

       18
       +
       

     

       19
       +
       [dev-dependencies]

     

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

+14

2025/3/gleam/manifest.toml

···

       1
       +
       # This file was generated by Gleam

     

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

     

       3
       +
       

     

       4
       +
       packages = [

     

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

     

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

     

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

     

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

     

       9
       +
       ]

     

       10
       +
       

     

       11
       +
       [requirements]

     

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

     

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

     

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

+71

2025/3/gleam/src/main.gleam

···

       1
       +
       import gleam/int

     

       2
       +
       import gleam/io

     

       3
       +
       import gleam/list

     

       4
       +
       import gleam/result

     

       5
       +
       import gleam/string

     

       6
       +
       import simplifile as file

     

       7
       +
       

     

       8
       +
       pub fn do(input, digits) {

     

       9
       +
         input

     

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

     

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

     

       12
       +
           let #(n, _) =

     

       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
       +
             // 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
       +
             list.range(digits - 1, 0)

     

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

     

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

     

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

     

       19
       +
               let #(number, bank) = acc

     

       20
       +
       

     

       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
       +
               // but like it's very simple

     

       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
       +
               // 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
       +
               // and then we get the highest number

     

       26
       +
               // and done here

     

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

     

       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
       +
               // 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
       +
               let assert Ok(#(max, loc)) =

     

       31
       +
                 bank

     

       32
       +
                 |> list.reverse

     

       33
       +
                 |> list.drop(i)

     

       34
       +
                 |> list.reverse

     

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

     

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

     

       37
       +
       

     

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

     

       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
       +
               // 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
       +
               // 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
       +
               // 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
       +
               #(number * 10 + max, list.drop(bank, loc + 1))

     

       44
       +
             })

     

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

     

       46
       +
           acc + n

     

       47
       +
         })

     

       48
       +
       }

     

       49
       +
       

     

       50
       +
       pub fn main() {

     

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

     

       52
       +
           as "Input file not found"

     

       53
       +
         let input =

     

       54
       +
           input

     

       55
       +
           |> string.trim

     

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

     

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

     

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

     

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

     

       60
       +
             string.to_graphemes(bank)

     

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

     

       62
       +
           })

     

       63
       +
       

     

       64
       +
         do(input, 2)

     

       65
       +
         |> int.to_string

     

       66
       +
         |> io.println

     

       67
       +
       

     

       68
       +
         do(input, 12)

     

       69
       +
         |> int.to_string

     

       70
       +
         |> io.println

     

       71
       +
       }

2025/3/rust/Cargo.lock

···

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

     

       2
       +
       # It is not intended for manual editing.

     

       3
       +
       version = 4

     

       4
       +
       

     

       5
       +
       [[package]]

     

       6
       +
       name = "rust"

     

       7
       +
       version = "0.1.0"

2025/3/rust/Cargo.toml

···

       1
       +
       [package]

     

       2
       +
       name = "rust"

     

       3
       +
       version = "0.1.0"

     

       4
       +
       edition = "2024"

     

       5
       +
       

     

       6
       +
       [dependencies]

+38

2025/3/rust/src/main.rs

···

       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
       +
       

     

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

     

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

     

       5
       +
               let bank_len = bank.len();

     

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

     

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

     

       8
       +
                       .iter()

     

       9
       +
                       .enumerate()

     

       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
       +
                       .reduce(

     

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

     

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

     

       14
       +
                           },

     

       15
       +
                       )

     

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

     

       17
       +
                       .unwrap();

     

       18
       +
       

     

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

     

       20
       +
               });

     

       21
       +
               acc + n

     

       22
       +
           })

     

       23
       +
       }

     

       24
       +
       

     

       25
       +
       fn main() {

     

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

     

       27
       +
               .trim()

     

       28
       +
               .split("\n")

     

       29
       +
               .map(|bank| {

     

       30
       +
                   bank.chars()

     

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

     

       32
       +
                       .collect()

     

       33
       +
               })

     

       34
       +
               .collect();

     

       35
       +
       

     

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

     

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

     

       38
       +
       }

+20

2025/4/gleam/gleam.toml

···

       1
       +
       name = "main"

     

       2
       +
       version = "1.0.0"

     

       3
       +
       

     

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

     

       5
       +
       # your project to the Hex package manager.

     

       6
       +
       #

     

       7
       +
       # description = ""

     

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

     

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

     

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

     

       11
       +
       #

     

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

     

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

     

       14
       +
       

     

       15
       +
       [dependencies]

     

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

     

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

     

       18
       +
       

     

       19
       +
       [dev-dependencies]

     

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

+14

2025/4/gleam/manifest.toml

···

       1
       +
       # This file was generated by Gleam

     

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

     

       3
       +
       

     

       4
       +
       packages = [

     

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

     

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

     

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

     

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

     

       9
       +
       ]

     

       10
       +
       

     

       11
       +
       [requirements]

     

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

     

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

     

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

+96

2025/4/gleam/src/main.gleam

···

       1
       +
       import gleam/bit_array

     

       2
       +
       import gleam/int

     

       3
       +
       import gleam/io

     

       4
       +
       import gleam/list

     

       5
       +
       import gleam/result

     

       6
       +
       import gleam/string

     

       7
       +
       import simplifile as file

     

       8
       +
       

     

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

     

       10
       +
         case

     

       11
       +
           case x, y {

     

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

     

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

     

       14
       +
       

     

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

     

       16
       +
           }

     

       17
       +
         {

     

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

     

       19
       +
           _ -> 0

     

       20
       +
         }

     

       21
       +
       }

     

       22
       +
       

     

       23
       +
       fn part_1(map, size) {

     

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

     

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

     

       26
       +
           let x = pos % size

     

       27
       +
           let y = pos / size

     

       28
       +
       

     

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

     

       30
       +
       

     

       31
       +
           let neighbours =

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       40
       +
       

     

       41
       +
           case roll, neighbours < 4 {

     

       42
       +
             1, True -> acc + 1

     

       43
       +
             _, _ -> acc

     

       44
       +
           }

     

       45
       +
         })

     

       46
       +
       }

     

       47
       +
       

     

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

     

       49
       +
         let #(rolls, new_map) =

     

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

     

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

     

       52
       +
             let #(total, new_map) = acc

     

       53
       +
             let x = pos % size

     

       54
       +
             let y = pos / size

     

       55
       +
       

     

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

     

       57
       +
       

     

       58
       +
             let neighbours =

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       67
       +
       

     

       68
       +
             case roll, neighbours < 4 {

     

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

     

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

     

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

     

       72
       +
             }

     

       73
       +
           })

     

       74
       +
       

     

       75
       +
         case map == new_map {

     

       76
       +
           True -> rolls

     

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

     

       78
       +
         }

     

       79
       +
       }

     

       80
       +
       

     

       81
       +
       pub fn main() {

     

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

     

       83
       +
           as "Input file not found"

     

       84
       +
         let input =

     

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

     

       86
       +
         let size = list.length(input)

     

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

     

       88
       +
         // @ and .

     

       89
       +
       

     

       90
       +
         part_1(input, size)

     

       91
       +
         |> int.to_string

     

       92
       +
         |> io.println

     

       93
       +
         part_2(input, size, 0)

     

       94
       +
         |> int.to_string

     

       95
       +
         |> io.println

     

       96
       +
       }

2025/4/rust/Cargo.lock

···

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

     

       2
       +
       # It is not intended for manual editing.

     

       3
       +
       version = 4

     

       4
       +
       

     

       5
       +
       [[package]]

     

       6
       +
       name = "rust"

     

       7
       +
       version = "0.1.0"

2025/4/rust/Cargo.toml

···

       1
       +
       [package]

     

       2
       +
       name = "rust"

     

       3
       +
       version = "0.1.0"

     

       4
       +
       edition = "2024"

     

       5
       +
       

     

       6
       +
       [dependencies]

+106

2025/4/rust/src/main.rs

···

       1
       +
       use std::{

     

       2
       +
           fs::{self, File},

     

       3
       +
           io::Write,

     

       4
       +
           mem::swap,

     

       5
       +
       };

     

       6
       +
       

     

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

     

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

     

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

     

       10
       +
           let mut i = size + 3;

     

       11
       +
           for _ in 0..size {

     

       12
       +
               for _ in 0..size {

     

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

     

       14
       +
                   i += 1;

     

       15
       +
               }

     

       16
       +
               i += 2;

     

       17
       +
           }

     

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

     

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

     

       20
       +
       }

     

       21
       +
       

     

       22
       +
       fn solve(

     

       23
       +
           mut warehouse: Vec<u8>,

     

       24
       +
           size: usize,

     

       25
       +
           part_2: bool,

     

       26
       +
           visualise: bool,

     

       27
       +
       ) -> u32 {

     

       28
       +
           if visualise {

     

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

     

       30
       +
           }

     

       31
       +
       

     

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

     

       33
       +
       

     

       34
       +
           let sizep = size + 1;

     

       35
       +
       

     

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

     

       37
       +
       

     

       38
       +
           let mut rolls = 0;

     

       39
       +
       

     

       40
       +
           let mut i = 0;

     

       41
       +
           loop {

     

       42
       +
               for yo in 1..sizep {

     

       43
       +
                   let ym = yo - 1;

     

       44
       +
                   let yp = yo + 1;

     

       45
       +
                   for xo in 1..sizep {

     

       46
       +
                       let xm = xo - 1;

     

       47
       +
                       let xp = xo + 1;

     

       48
       +
       

     

       49
       +
                       unsafe {

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       60
       +
                               match (was, neighbours < 4) {

     

       61
       +
                                   (true, true) => {

     

       62
       +
                                       rolls += 1;

     

       63
       +
                                       0

     

       64
       +
                                   }

     

       65
       +
                                   (true, false) => 1,

     

       66
       +
                                   (_, _) => 0,

     

       67
       +
                               };

     

       68
       +
                       }

     

       69
       +
                   }

     

       70
       +
               }

     

       71
       +
       

     

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

     

       73
       +
                   break;

     

       74
       +
               }

     

       75
       +
       

     

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

     

       77
       +
               i += 1;

     

       78
       +
               if visualise {

     

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

     

       80
       +
               }

     

       81
       +
           }

     

       82
       +
           rolls

     

       83
       +
       }

     

       84
       +
       

     

       85
       +
       fn main() {

     

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

     

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

     

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

     

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

     

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

     

       91
       +
               .split("\n")

     

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

     

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

     

       94
       +
                       .chars()

     

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

     

       96
       +
                       .collect()

     

       97
       +
               })

     

       98
       +
               .flatten()

     

       99
       +
               .collect();

     

       100
       +
       

     

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

     

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

     

       103
       +
       

     

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

     

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

     

       106
       +
       }

+20

2025/5/gleam/gleam.toml

···

       1
       +
       name = "main"

     

       2
       +
       version = "1.0.0"

     

       3
       +
       

     

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

     

       5
       +
       # your project to the Hex package manager.

     

       6
       +
       #

     

       7
       +
       # description = ""

     

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

     

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

     

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

     

       11
       +
       #

     

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

     

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

     

       14
       +
       

     

       15
       +
       [dependencies]

     

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

     

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

     

       18
       +
       

     

       19
       +
       [dev-dependencies]

     

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

+14

2025/5/gleam/manifest.toml

···

       1
       +
       # This file was generated by Gleam

     

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

     

       3
       +
       

     

       4
       +
       packages = [

     

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

     

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

     

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

     

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

     

       9
       +
       ]

     

       10
       +
       

     

       11
       +
       [requirements]

     

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

     

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

     

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

+117

2025/5/gleam/src/main.gleam

···

       1
       +
       import gleam/int

     

       2
       +
       import gleam/io

     

       3
       +
       import gleam/list

     

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

     

       5
       +
       import gleam/set

     

       6
       +
       import gleam/string

     

       7
       +
       import simplifile as file

     

       8
       +
       

     

       9
       +
       pub fn main() {

     

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

     

       11
       +
           as "Input file not found"

     

       12
       +
         let assert [fresh_ranges, available] =

     

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

     

       14
       +
         let fresh_ranges =

     

       15
       +
           fresh_ranges

     

       16
       +
           |> string.trim

     

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

     

       18
       +
           // |> list.reverse

     

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

     

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

     

       21
       +
           // |> list.reverse

     

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

     

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

     

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

     

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

     

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

     

       27
       +
             #(from, to)

     

       28
       +
           })

     

       29
       +
         let available =

     

       30
       +
           available

     

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

     

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

     

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

     

       34
       +
             id

     

       35
       +
           })

     

       36
       +
       

     

       37
       +
         available

     

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

     

       39
       +
           acc

     

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

     

       41
       +
             True -> 1

     

       42
       +
             False -> 0

     

       43
       +
           }

     

       44
       +
         })

     

       45
       +
         |> int.to_string

     

       46
       +
         |> io.println

     

       47
       +
       

     

       48
       +
         // nicer looking but idc

     

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

     

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

     

       51
       +
         // })

     

       52
       +
         // |> list.length

     

       53
       +
       

     

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

     

       55
       +
         // let haha =

     

       56
       +
         //   fresh_ranges

     

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

     

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

     

       59
       +
         //   })

     

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

     

       61
       +
       

     

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

     

       63
       +
         fresh_ranges

     

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

     

       65
       +
           let #(range, seen_ranges) =

     

       66
       +
             prev_seen_ranges

     

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

     

       68
       +
               let #(range, seen_ranges) = acc

     

       69
       +
               // echo #(

     

       70
       +
               //   range,

     

       71
       +
               //   seen_range,

     

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

     

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

     

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

     

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

     

       76
       +
               // )

     

       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
       +
               case

     

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

     

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

     

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

     

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

     

       83
       +
               {

     

       84
       +
                 // if there's no touching

     

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

     

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

     

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

     

       88
       +
                   #(-1, -1),

     

       89
       +
                   seen_ranges,

     

       90
       +
                 )

     

       91
       +
                 // if the other one is inside it

     

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

     

       93
       +
                   range,

     

       94
       +
                   set.delete(seen_ranges, seen_range),

     

       95
       +
                 )

     

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

     

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

     

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

     

       99
       +
                   set.delete(seen_ranges, seen_range),

     

       100
       +
                 )

     

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

     

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

     

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

     

       104
       +
                   set.delete(seen_ranges, seen_range),

     

       105
       +
                 )

     

       106
       +
               }

     

       107
       +
             })

     

       108
       +
       

     

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

     

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

     

       111
       +
             True -> seen_ranges

     

       112
       +
           }

     

       113
       +
         })

     

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

     

       115
       +
         |> int.to_string

     

       116
       +
         |> io.println

     

       117
       +
       }

2025/5/rust/Cargo.lock

···

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

     

       2
       +
       # It is not intended for manual editing.

     

       3
       +
       version = 4

     

       4
       +
       

     

       5
       +
       [[package]]

     

       6
       +
       name = "rust"

     

       7
       +
       version = "0.1.0"

2025/5/rust/Cargo.toml

···

       1
       +
       [package]

     

       2
       +
       name = "rust"

     

       3
       +
       version = "0.1.0"

     

       4
       +
       edition = "2024"

     

       5
       +
       

     

       6
       +
       [dependencies]

+75

2025/5/rust/src/main.rs

···

       1
       +
       use std::{

     

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

     

       3
       +
           collections::HashSet,

     

       4
       +
       };

     

       5
       +
       

     

       6
       +
       fn main() {

     

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

     

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

     

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

     

       10
       +
               .split("\n")

     

       11
       +
               .map(|i| {

     

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

     

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

     

       14
       +
               })

     

       15
       +
               .collect();

     

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

     

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

     

       18
       +
               i

     

       19
       +
           });

     

       20
       +
       

     

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

     

       22
       +
               acc + fresh_ranges

     

       23
       +
                   .iter()

     

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

     

       25
       +
           });

     

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

     

       27
       +
       

     

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

     

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

     

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

     

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

     

       32
       +
                   *range,

     

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

     

       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
       +
                       match (

     

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

     

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

     

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

     

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

     

       40
       +
                       ) {

     

       41
       +
                           // if there's no touching

     

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

     

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

     

       44
       +
                           (Gt, Lt, _, _)

     

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

     

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

     

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

     

       48
       +
                           // if the other one is inside it

     

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

     

       50
       +
                               seen_ranges.remove(seen_range);

     

       51
       +
                               Some(range)

     

       52
       +
                           }

     

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

     

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

     

       55
       +
                               seen_ranges.remove(seen_range);

     

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

     

       57
       +
                           }

     

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

     

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

     

       60
       +
                               seen_ranges.remove(seen_range);

     

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

     

       62
       +
                           }

     

       63
       +
                       }

     

       64
       +
                   },

     

       65
       +
               );

     

       66
       +
       

     

       67
       +
               if range.is_some() {

     

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

     

       69
       +
               }

     

       70
       +
           });

     

       71
       +
           let part_2 = seen_ranges

     

       72
       +
               .into_iter()

     

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

     

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

     

       75
       +
       }

+20

2025/6/gleam/gleam.toml

···

       1
       +
       name = "main"

     

       2
       +
       version = "1.0.0"

     

       3
       +
       

     

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

     

       5
       +
       # your project to the Hex package manager.

     

       6
       +
       #

     

       7
       +
       # description = ""

     

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

     

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

     

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

     

       11
       +
       #

     

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

     

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

     

       14
       +
       

     

       15
       +
       [dependencies]

     

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

     

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

     

       18
       +
       

     

       19
       +
       [dev-dependencies]

     

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

+14

2025/6/gleam/manifest.toml

···

       1
       +
       # This file was generated by Gleam

     

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

     

       3
       +
       

     

       4
       +
       packages = [

     

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

     

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

     

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

     

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

     

       9
       +
       ]

     

       10
       +
       

     

       11
       +
       [requirements]

     

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

     

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

     

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

+140

2025/6/gleam/src/main.gleam

···

       1
       +
       import gleam/dict

     

       2
       +
       import gleam/int

     

       3
       +
       import gleam/io

     

       4
       +
       import gleam/list

     

       5
       +
       import gleam/result

     

       6
       +
       import gleam/string

     

       7
       +
       import simplifile as file

     

       8
       +
       

     

       9
       +
       type Part2Dict =

     

       10
       +
         dict.Dict(Int, Int)

     

       11
       +
       

     

       12
       +
       type Align {

     

       13
       +
         Left

     

       14
       +
         Right

     

       15
       +
       }

     

       16
       +
       

     

       17
       +
       type Operation {

     

       18
       +
         Sum

     

       19
       +
         Mul

     

       20
       +
       }

     

       21
       +
       

     

       22
       +
       type Part2Line {

     

       23
       +
         Part2Line(align: Align, op: Operation, numbers: List(String))

     

       24
       +
       }

     

       25
       +
       

     

       26
       +
       pub fn main() {

     

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

     

       28
       +
           as "Input file not found"

     

       29
       +
         let input = input |> string.trim

     

       30
       +
         let input_pt_1 =

     

       31
       +
           list.fold(list.range(1, 10), input, fn(acc, _) {

     

       32
       +
             acc |> string.replace("  ", " ")

     

       33
       +
           })

     

       34
       +
       

     

       35
       +
         input_pt_1

     

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

     

       37
       +
         |> list.map(fn(i) { string.trim(i) |> string.split(" ") })

     

       38
       +
         |> list.transpose

     

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

     

       40
       +
           let i = list.reverse(i)

     

       41
       +
           let assert Ok(s) = list.first(i)

     

       42
       +
           let i =

     

       43
       +
             list.drop(i, 1) |> list.map(fn(i) { int.parse(i) |> result.unwrap(0) })

     

       44
       +
           let r = case s {

     

       45
       +
             "+" -> int.sum(i)

     

       46
       +
             "*" -> list.reduce(i, int.multiply) |> result.unwrap(0)

     

       47
       +
             _ -> panic as "invalid"

     

       48
       +
           }

     

       49
       +
           r

     

       50
       +
         })

     

       51
       +
         |> int.sum

     

       52
       +
         |> int.to_string

     

       53
       +
         |> io.println

     

       54
       +
       

     

       55
       +
         let lines =

     

       56
       +
           input

     

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

     

       58
       +
           |> list.reverse

     

       59
       +
         let assert Ok(last_line) = list.first(lines)

     

       60
       +
         let #(_, bounds) =

     

       61
       +
           { last_line <> "                         *" }

     

       62
       +
           |> string.to_graphemes

     

       63
       +
           |> list.index_fold(#(0, list.new()), fn(acc, char, i) {

     

       64
       +
             let #(bound_start, bounds) = acc

     

       65
       +
             case char {

     

       66
       +
               "*" | "+" if i > 0 -> #(i, list.append([#(bound_start, i - 1)], bounds))

     

       67
       +
               _ -> acc

     

       68
       +
             }

     

       69
       +
           })

     

       70
       +
         bounds

     

       71
       +
         |> list.index_fold(dict.new(), fn(d, bound, i) {

     

       72
       +
           let numbers =

     

       73
       +
             list.map(lines, fn(line) {

     

       74
       +
               string.slice(line, bound.0, bound.1 - bound.0)

     

       75
       +
             })

     

       76
       +
           let align =

     

       77
       +
             numbers

     

       78
       +
             |> list.drop(1)

     

       79
       +
             |> list.fold_until(Left, fn(res, number) {

     

       80
       +
               case

     

       81
       +
                 string.trim(number) == number,

     

       82
       +
                 string.trim_start(number) == number

     

       83
       +
               {

     

       84
       +
                 True, _ -> list.Continue(res)

     

       85
       +
                 _, True -> list.Stop(Left)

     

       86
       +
                 _, _ -> list.Stop(Right)

     

       87
       +
               }

     

       88
       +
             })

     

       89
       +
           let assert Ok(sign) = list.first(numbers)

     

       90
       +
           let sign = case string.trim(sign) {

     

       91
       +
             "*" -> Mul

     

       92
       +
             "+" -> Sum

     

       93
       +
             _ -> panic as sign

     

       94
       +
           }

     

       95
       +
           dict.insert(

     

       96
       +
             d,

     

       97
       +
             i,

     

       98
       +
             Part2Line(

     

       99
       +
               align,

     

       100
       +
               sign,

     

       101
       +
               numbers |> list.drop(1) |> list.map(string.trim) |> list.reverse,

     

       102
       +
             ),

     

       103
       +
           )

     

       104
       +
         })

     

       105
       +
         |> dict.to_list

     

       106
       +
         |> list.map(fn(i) { i.1 })

     

       107
       +
         |> list.map(fn(line) {

     

       108
       +
           let d: Part2Dict = dict.new()

     

       109
       +
           let d =

     

       110
       +
             line.numbers

     

       111
       +
             |> list.fold(d, fn(d, number) {

     

       112
       +
               let number_len = string.length(number)

     

       113
       +
               string.to_graphemes(number)

     

       114
       +
               |> list.index_fold(d, fn(d, digit, index) {

     

       115
       +
                 let assert Ok(digit) = digit |> int.parse

     

       116
       +
                 let pos = case line.align {

     

       117
       +
                   Right -> number_len - index

     

       118
       +
                   Left -> index

     

       119
       +
                 }

     

       120
       +
                 dict.insert(

     

       121
       +
                   d,

     

       122
       +
                   pos,

     

       123
       +
                   { dict.get(d, pos) |> result.unwrap(0) } * 10 + digit,

     

       124
       +
                 )

     

       125
       +
               })

     

       126
       +
             })

     

       127
       +
           let numbers =

     

       128
       +
             dict.to_list(d)

     

       129
       +
             |> list.map(fn(n) { n.1 })

     

       130
       +
       

     

       131
       +
           let r = case line.op {

     

       132
       +
             Sum -> int.sum(numbers)

     

       133
       +
             Mul -> list.reduce(numbers, int.multiply) |> result.unwrap(0)

     

       134
       +
           }

     

       135
       +
           r

     

       136
       +
         })

     

       137
       +
         |> int.sum

     

       138
       +
         |> int.to_string

     

       139
       +
         |> io.println

     

       140
       +
       }

+20

2025/7/gleam/gleam.toml

···

       1
       +
       name = "main"

     

       2
       +
       version = "1.0.0"

     

       3
       +
       

     

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

     

       5
       +
       # your project to the Hex package manager.

     

       6
       +
       #

     

       7
       +
       # description = ""

     

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

     

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

     

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

     

       11
       +
       #

     

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

     

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

     

       14
       +
       

     

       15
       +
       [dependencies]

     

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

     

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

     

       18
       +
       

     

       19
       +
       [dev-dependencies]

     

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

+14

2025/7/gleam/manifest.toml

···

       1
       +
       # This file was generated by Gleam

     

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

     

       3
       +
       

     

       4
       +
       packages = [

     

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

     

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

     

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

     

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

     

       9
       +
       ]

     

       10
       +
       

     

       11
       +
       [requirements]

     

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

     

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

     

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

+93

2025/7/gleam/src/main.gleam

···

       1
       +
       import gleam/dict

     

       2
       +
       import gleam/int

     

       3
       +
       import gleam/io

     

       4
       +
       import gleam/list

     

       5
       +
       import gleam/set

     

       6
       +
       import gleam/string

     

       7
       +
       import simplifile as file

     

       8
       +
       

     

       9
       +
       pub fn main() {

     

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

     

       11
       +
           as "Input file not found"

     

       12
       +
         let input = input |> string.trim |> string.split("\n")

     

       13
       +
         let assert Ok(start) = input |> list.first

     

       14
       +
         let start =

     

       15
       +
           start

     

       16
       +
           |> string.to_graphemes

     

       17
       +
           |> list.index_fold(0, fn(acc, v, i) {

     

       18
       +
             case v {

     

       19
       +
               "S" -> i

     

       20
       +
               _ -> acc

     

       21
       +
             }

     

       22
       +
           })

     

       23
       +
         let splitters_map =

     

       24
       +
           input

     

       25
       +
           |> list.drop(1)

     

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

     

       27
       +
             case i % 2 {

     

       28
       +
               0 -> ""

     

       29
       +
               _ -> line

     

       30
       +
             }

     

       31
       +
           })

     

       32
       +
           |> list.filter(fn(line) { line != "" })

     

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

     

       34
       +
             line

     

       35
       +
             |> string.to_graphemes

     

       36
       +
             |> list.index_fold(set.new(), fn(d, char, i) {

     

       37
       +
               case char {

     

       38
       +
                 "^" -> set.insert(d, i)

     

       39
       +
                 _ -> d

     

       40
       +
               }

     

       41
       +
             })

     

       42
       +
           })

     

       43
       +
         let #(_beams, times) =

     

       44
       +
           splitters_map

     

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

     

       46
       +
             let #(beams, times) = acc

     

       47
       +
             beams

     

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

     

       49
       +
               let #(beams, times) = acc

     

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

     

       51
       +
                 False -> acc

     

       52
       +
                 True -> #(

     

       53
       +
                   beams

     

       54
       +
                     |> set.delete(beam)

     

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

     

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

     

       57
       +
                   times + 1,

     

       58
       +
                 )

     

       59
       +
               }

     

       60
       +
             })

     

       61
       +
           })

     

       62
       +
       

     

       63
       +
         times

     

       64
       +
         |> int.to_string

     

       65
       +
         |> io.println

     

       66
       +
       

     

       67
       +
         let timelines =

     

       68
       +
           splitters_map

     

       69
       +
           |> list.index_fold(

     

       70
       +
             dict.new() |> dict.insert("", start),

     

       71
       +
             fn(timelines, splitters, i) {

     

       72
       +
               echo i

     

       73
       +
               // echo #(timelines, splitters)

     

       74
       +
               timelines

     

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

     

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

     

       77
       +
                   False -> timelines

     

       78
       +
                   True -> {

     

       79
       +
                     timelines

     

       80
       +
                     |> dict.delete(timeline)

     

       81
       +
                     |> dict.insert(timeline <> "-", beam - 1)

     

       82
       +
                     |> dict.insert(timeline <> "+", beam + 1)

     

       83
       +
                   }

     

       84
       +
                 }

     

       85
       +
               })

     

       86
       +
             },

     

       87
       +
           )

     

       88
       +
         echo timelines

     

       89
       +
         timelines

     

       90
       +
         |> dict.size

     

       91
       +
         |> int.to_string

     

       92
       +
         |> io.println

     

       93
       +
       }

2025/7/rust/Cargo.lock

···

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

     

       2
       +
       # It is not intended for manual editing.

     

       3
       +
       version = 4

     

       4
       +
       

     

       5
       +
       [[package]]

     

       6
       +
       name = "rust"

     

       7
       +
       version = "0.1.0"

2025/7/rust/Cargo.toml

···

       1
       +
       [package]

     

       2
       +
       name = "rust"

     

       3
       +
       version = "0.1.0"

     

       4
       +
       edition = "2024"

     

       5
       +
       

     

       6
       +
       [dependencies]

+62

2025/7/rust/src/main.rs

···

       1
       +
       use std::{

     

       2
       +
           collections::{HashMap, HashSet},

     

       3
       +
           mem::swap,

     

       4
       +
       };

     

       5
       +
       

     

       6
       +
       fn main() {

     

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

     

       8
       +
       

     

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

     

       10
       +
           // let width = input[0].len() as u64;

     

       11
       +
           let start = input[0].find("S").unwrap() as u64;

     

       12
       +
           let splitters_map: Vec<HashSet<u64>> = input[0..input.len()]

     

       13
       +
               .iter()

     

       14
       +
               .enumerate()

     

       15
       +
               .map(|(i, line)| if i % 2 != 0 { "" } else { line })

     

       16
       +
               .filter(|line| line != &"")

     

       17
       +
               .map(|line| {

     

       18
       +
                   line.chars()

     

       19
       +
                       .enumerate()

     

       20
       +
                       .fold(HashSet::new(), |mut s, (i, char)| {

     

       21
       +
                           if char == '^' {

     

       22
       +
                               s.insert(i as u64);

     

       23
       +
                           }

     

       24
       +
                           s

     

       25
       +
                       })

     

       26
       +
               })

     

       27
       +
               .collect();

     

       28
       +
       

     

       29
       +
           let timelines = {

     

       30
       +
               let mut timelines: HashMap<u64, u64> = HashMap::new();

     

       31
       +
               timelines.insert(start, 1);

     

       32
       +
               let mut timelines_new: HashMap<u64, u64> = HashMap::new();

     

       33
       +
               for splitters in splitters_map {

     

       34
       +
                   for (pos, amount) in &timelines {

     

       35
       +
                       if splitters.contains(&pos) {

     

       36
       +
                           let m1 = timelines_new.entry(pos - 1).or_insert(0);

     

       37
       +
                           *m1 += amount;

     

       38
       +
                           let p1 = timelines_new.entry(pos + 1).or_insert(0);

     

       39
       +
                           *p1 += amount;

     

       40
       +
                       } else {

     

       41
       +
                           let e = timelines_new.entry(*pos).or_insert(0);

     

       42
       +
                           *e += amount;

     

       43
       +
                       }

     

       44
       +
                   }

     

       45
       +
                   // for pos in 0..width as u64 {

     

       46
       +
                   //     if splitters.contains(&pos) {

     

       47
       +
                   //         print!("^");

     

       48
       +
                   //     } else if timelines_new.contains_key(&pos) {

     

       49
       +
                   //         print!("|");

     

       50
       +
                   //     } else {

     

       51
       +
                   //         print!(".");

     

       52
       +
                   //     }

     

       53
       +
                   // }

     

       54
       +
                   // print!("\n\n");

     

       55
       +
                   swap(&mut timelines, &mut timelines_new);

     

       56
       +
                   timelines_new.clear();

     

       57
       +
               }

     

       58
       +
               timelines

     

       59
       +
           };

     

       60
       +
           // println!("{:?}", timelines);

     

       61
       +
           println!("{}", timelines.iter().fold(0, |acc, v| { acc + v.1 }))

     

       62
       +
       }

rustfmt.toml

···

       1
       +
       edition = "2024"

     

       2
       +
       max_width = 80

+2 -1

shell.nix

···

       23
        
           clippy

     

       24
        
           rustfmt

     

       25
        
           rust-analyzer

     

       26
       -
           gcc

     

       0
        
       
     

       27
        
       

     

       28
        
           hyperfine

     

       29
        
           fish

···

       23
        
           clippy

     

       24
        
           rustfmt

     

       25
        
           rust-analyzer

     

       26
       +
       

     

       27
       +
           clang

     

       28
        
       

     

       29
        
           hyperfine

     

       30
        
           fish

+1 -1

template/rust/src/main.rs

···

       1
        
       fn main() {

     

       2
       -
           let input = std::fs::read_to_string("../input.txt").expect("invalid input!!");

     

       3
        
       

     

       4
        
           println!("{}", &input);

     

       5
        
       }

···

       1
        
       fn main() {

     

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

     

       3
        
       

     

       4
        
           println!("{}", &input);

     

       5
        
       }

+39

template/zig/build.zig

···

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

     

       2
       +
       

     

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

     

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

     

       5
       +
       

     

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

     

       7
       +
       

     

       8
       +
           const exe = b.addExecutable(.{

     

       9
       +
               .name = "zig",

     

       10
       +
               .root_module = b.createModule(.{

     

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

     

       12
       +
       

     

       13
       +
                   .target = target,

     

       14
       +
                   .optimize = optimize,

     

       15
       +
               }),

     

       16
       +
           });

     

       17
       +
       

     

       18
       +
           b.installArtifact(exe);

     

       19
       +
       

     

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

     

       21
       +
       

     

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

     

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

     

       24
       +
       

     

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

     

       26
       +
       

     

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

     

       28
       +
               run_cmd.addArgs(args);

     

       29
       +
           }

     

       30
       +
       

     

       31
       +
           const exe_tests = b.addTest(.{

     

       32
       +
               .root_module = exe.root_module,

     

       33
       +
           });

     

       34
       +
       

     

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

     

       36
       +
       

     

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

     

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

     

       39
       +
       }

template/zig/src/main.zig

···

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

     

       2
       +
       const raw_input = @embedFile("./input.txt");

     

       3
       +
       

     

       4
       +
       pub fn main() !void {

     

       5
       +
           std.debug.print("{s}", .{raw_input});

     

       6
       +
       }

Compare changes