comparing 537f7051b3ca6bd2ea792c6d7db7dc8640713080 and main on aylac.top/advent_of_code

.gitignore

-10

2015/16/sue.txt

···

       1
       1
       -
       children: 3

     

       2
       2
       -
       cats: 7

     

       3
       3
       -
       samoyeds: 2

     

       4
       4
       -
       pomeranians: 3

     

       5
       5
       -
       akitas: 0

     

       6
       6
       -
       vizslas: 0

     

       7
       7
       -
       goldfish: 5

     

       8
       8
       -
       trees: 3

     

       9
       9
       -
       cars: 2

     

       10
       10
       -
       perfumes: 1

+50 -42

2015/18/rust/src/main.rs

···

       1
       1
       -
       use std::{iter::once, mem::swap};

     

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

     

       2
       2
        
       

     

       3
       3
       -
       fn generations(times: u32, mut world: Vec<u8>, size: usize, stuck: bool) -> Vec<u8> {

     

       4
       4
       -
           #[inline]

     

       5
       5
       -
           fn get_at(world: &Vec<u8>, size: usize, x: usize, y: usize) -> u8 {

     

       6
       6
       -
               // benefits from the integer overflow to simplify code

     

       7
       7
       -
               if x >= size || y >= size {

     

       8
       8
       -
                   return 0;

     

       9
       9
       -
               };

     

       10
       10
       -
               // this is in known bounds

     

       11
       11
       -
               unsafe { *world.get_unchecked(y * size + x) }

     

       12
       12
       -
           }

     

       3
       3
       +
       fn generations(

     

       4
       4
       +
           times: u32,

     

       5
       5
       +
           mut world: Vec<u8>,

     

       6
       6
       +
           size: usize,

     

       7
       7
       +
           stuck: bool,

     

       8
       8
       +
       ) -> Vec<u8> {

     

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

     

       13
       10
        
       

     

       14
       14
       -
           let mut new_world = vec![0_u8; size * size];

     

       15
       15
       -
           let sizem = size - 1;

     

       16
       16
       -
           if stuck {

     

       17
       17
       -
               world[0] = 1;

     

       18
       18
       -
               world[sizem] = 1;

     

       19
       19
       -
               world[(size * size) - 1] = 1;

     

       20
       20
       -
               world[size * sizem] = 1;

     

       11
       11
       +
           let sizep = size + 1;

     

       12
       12
       +
       

     

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

     

       14
       14
       +
       

     

       15
       15
       +
           unsafe {

     

       16
       16
       +
               if stuck {

     

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

     

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

     

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

     

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

     

       21
       21
       +
               }

     

       21
       22
        
           }

     

       22
       23
        
       

     

       23
       24
        
           for _ in 0..times {

     

       24
       24
       -
               for yo in 1..=size {

     

       25
       25
       +
               for yo in 1..sizep {

     

       25
       26
        
                   let ym = yo - 1;

     

       26
       27
        
                   let yp = yo + 1;

     

       27
       27
       -
                   for xo in 1..=size {

     

       28
       28
       +
                   for xo in 1..sizep {

     

       28
       29
        
                       let xm = xo - 1;

     

       29
       30
        
                       let xp = xo + 1;

     

       30
       31
        
       

     

       31
       31
       -
                       let was = get_at(&world, size, xo, yo) == 1;

     

       32
       32
       -
                       let neighbours = get_at(&world, size, xm, ym)

     

       33
       33
       -
                           + get_at(&world, size, xo, ym)

     

       34
       34
       -
                           + get_at(&world, size, xp, ym)

     

       35
       35
       -
                           + get_at(&world, size, xm, yo)

     

       36
       36
       -
                           + get_at(&world, size, xp, yo)

     

       37
       37
       -
                           + get_at(&world, size, xm, yp)

     

       38
       38
       -
                           + get_at(&world, size, xo, yp)

     

       39
       39
       -
                           + get_at(&world, size, xp, yp);

     

       40
       40
       -
                       new_world[yo * size + xo] = (neighbours == 3 || (neighbours == 2 && was)) as u8;

     

       32
       32
       +
                       unsafe {

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       44
       44
       +
                       }

     

       41
       45
        
                   }

     

       42
       46
        
               }

     

       43
       47
        
       

     

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

     

       45
       49
        
       

     

       46
       50
        
               // i hate the duplication here :(

     

       47
       47
       -
               if stuck {

     

       48
       48
       -
                   world[0] = 1;

     

       49
       49
       -
                   world[sizem] = 1;

     

       50
       50
       -
                   world[(size * size) - 1] = 1;

     

       51
       51
       -
                   world[size * sizem] = 1;

     

       51
       51
       +
               unsafe {

     

       52
       52
       +
                   if stuck {

     

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

     

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

     

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

     

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

     

       57
       57
       +
                   }

     

       52
       58
        
               }

     

       53
       59
        
           }

     

       54
       60
        
           world

     
···

       57
       63
        
       fn main() {

     

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

     

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

     

       60
       60
       -
           let input: Vec<u8> = once(".".repeat(size))

     

       61
       61
       -
               .chain(input.split("\n"))

     

       62
       62
       -
               .chain(".".repeat(size))

     

       63
       63
       -
               .map(|line| {

     

       64
       64
       -
                   once(0)

     

       65
       65
       -
                       .chain(line.chars().map(|v| (v == '#') as u8))

     

       66
       66
       -
                       .chain(once(0))

     

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

     

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

     

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

     

       69
       69
       +
               .split("\n")

     

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

     

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

     

       72
       72
       +
                       .chars()

     

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

     

       74
       74
       +
                       .collect()

     

       67
       75
        
               })

     

       68
       76
        
               .flatten()

     

       69
       77
        
               .collect();

+40 -18

2015/19/rust/src/main.rs

···

       1
       1
       -
       struct Combination {

     

       2
       2
       -
           original: String,

     

       3
       3
       -
           target: String,

     

       4
       4
       -
       }

     

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

     

       5
       2
        
       

     

       6
       3
        
       fn main() {

     

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

     

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

     

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

     

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

     

       11
       11
       -
               match v[..] {

     

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

     

       13
       13
       -
                       original: original.to_string(),

     

       14
       14
       -
                       target: target.to_string(),

     

       15
       15
       -
                   },

     

       16
       16
       -
                   _ => Combination {

     

       17
       17
       -
                       original: "".to_string(),

     

       18
       18
       -
                       target: "".to_string(),

     

       19
       19
       -
                   },

     

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

     

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

     

       6
       6
       +
       

     

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

     

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

     

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

     

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

     

       11
       11
       +
                   match v[..] {

     

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

     

       13
       13
       +
                           let entry = combinations

     

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

     

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

     

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

     

       17
       17
       +
                       }

     

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

     

       19
       19
       +
                   }

     

       20
       20
       +
               });

     

       21
       21
       +
               combinations

     

       22
       22
       +
           };

     

       23
       23
       +
       

     

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

     

       25
       25
       +
       

     

       26
       26
       +
           // part 1

     

       27
       27
       +
           {

     

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

     

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

     

       30
       30
       +
               for i in 0..mol_len {

     

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

     

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

     

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

     

       34
       34
       +
                           possibilities.insert(format!(

     

       35
       35
       +
                               "{}{}",

     

       36
       36
       +
                               a,

     

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

     

       38
       38
       +
                           ));

     

       39
       39
       +
                       })

     

       40
       40
       +
                   });

     

       20
       41
        
               }

     

       21
       21
       -
           }).

     

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

     

       43
       43
       +
           }

     

       22
       44
        
       }

+2 -1

2015/2/rust/src/main.rs

···

       1
       1
        
       use itertools::Itertools;

     

       2
       2
        
       

     

       3
       3
        
       fn main() {

     

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

     

       4
       4
       +
           let input =

     

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

     

       5
       6
        
           let input = input

     

       6
       7
        
               .trim()

     

       7
       8
        
               .split("\n")

2015/20/rust/Cargo.lock

···

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

     

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

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

2015/20/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+33

2015/20/rust/src/main.rs

···

       1
       1
       +
       fn main() {

     

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

     

       3
       3
       +
               .trim()

     

       4
       4
       +
               .parse()

     

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

     

       6
       6
       +
           let input = input / 10;

     

       7
       7
       +
       

     

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

     

       9
       9
       +
           let mut house: u64 = 1;

     

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

     

       11
       11
       +
           while house < 10 {

     

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

     

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

     

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

     

       15
       15
       +
                   })

     

       16
       16
       +
               } else {

     

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

     

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

     

       19
       19
       +
                           acc + elf

     

       20
       20
       +
                       } else {

     

       21
       21
       +
                           acc

     

       22
       22
       +
                       }

     

       23
       23
       +
                   })

     

       24
       24
       +
               };

     

       25
       25
       +
               if presents > highest_house.1 {

     

       26
       26
       +
                   highest_house = (house, presents);

     

       27
       27
       +
               }

     

       28
       28
       +
               house += 1;

     

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

     

       30
       30
       +
           }

     

       31
       31
       +
       

     

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

     

       33
       33
       +
       }

+2 -1

2015/4/rust/src/main.rs

···

       21
       21
        
       }

     

       22
       22
        
       

     

       23
       23
        
       fn main() {

     

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

     

       24
       24
       +
           let input =

     

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

     

       25
       26
        
           let input = input.trim();

     

       26
       27
        
       

     

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

+3 -1

2025/1/rust/src/main.rs

···

       43
       43
        
                       turn,

     

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

     

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

     

       46
       46
       -
                       zeroes: acc.zeroes + raw_zeroes + (acc.turn != 0 && raw_turn <= 0) as i32,

     

       46
       46
       +
                       zeroes: acc.zeroes

     

       47
       47
       +
                           + raw_zeroes

     

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

     

       47
       49
        
                   }

     

       48
       50
        
               },

     

       49
       51
        
           );

+2 -88

2025/1/zig/build.zig

···

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

     

       2
       2
        
       

     

       3
       3
       -
       // Although this function looks imperative, it does not perform the build

     

       4
       4
       -
       // directly and instead it mutates the build graph (`b`) that will be then

     

       5
       5
       -
       // executed by an external runner. The functions in `std.Build` implement a DSL

     

       6
       6
       -
       // for defining build steps and express dependencies between them, allowing the

     

       7
       7
       -
       // build runner to parallelize the build automatically (and the cache system to

     

       8
       8
       -
       // know when a step doesn't need to be re-run).

     

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

     

       10
       10
       -
           // Standard target options allow the person running `zig build` to choose

     

       11
       11
       -
           // what target to build for. Here we do not override the defaults, which

     

       12
       12
       -
           // means any target is allowed, and the default is native. Other options

     

       13
       13
       -
           // for restricting supported target set are available.

     

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

     

       15
       15
       -
           // Standard optimization options allow the person running `zig build` to select

     

       16
       16
       -
           // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not

     

       17
       17
       -
           // set a preferred release mode, allowing the user to decide how to optimize.

     

       5
       5
       +
       

     

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

     

       19
       19
       -
           // It's also possible to define more custom flags to toggle optional features

     

       20
       20
       -
           // of this build script using `b.option()`. All defined flags (including

     

       21
       21
       -
           // target and optimize options) will be listed when running `zig build --help`

     

       22
       22
       -
           // in this directory.

     

       23
       7
        
       

     

       24
       24
       -
           // This creates a module, which represents a collection of source files alongside

     

       25
       25
       -
           // some compilation options, such as optimization mode and linked system libraries.

     

       26
       26
       -
           // Zig modules are the preferred way of making Zig code available to consumers.

     

       27
       27
       -
           // addModule defines a module that we intend to make available for importing

     

       28
       28
       -
           // to our consumers. We must give it a name because a Zig package can expose

     

       29
       29
       -
           // multiple modules and consumers will need to be able to specify which

     

       30
       30
       -
           // module they want to access.

     

       31
       31
       -
       

     

       32
       32
       -
           // Here we define an executable. An executable needs to have a root module

     

       33
       33
       -
           // which needs to expose a `main` function. While we could add a main function

     

       34
       34
       -
           // to the module defined above, it's sometimes preferable to split business

     

       35
       35
       -
           // logic and the CLI into two separate modules.

     

       36
       36
       -
           //

     

       37
       37
       -
           // If your goal is to create a Zig library for others to use, consider if

     

       38
       38
       -
           // it might benefit from also exposing a CLI tool. A parser library for a

     

       39
       39
       -
           // data serialization format could also bundle a CLI syntax checker, for example.

     

       40
       40
       -
           //

     

       41
       41
       -
           // If instead your goal is to create an executable, consider if users might

     

       42
       42
       -
           // be interested in also being able to embed the core functionality of your

     

       43
       43
       -
           // program in their own executable in order to avoid the overhead involved in

     

       44
       44
       -
           // subprocessing your CLI tool.

     

       45
       45
       -
           //

     

       46
       46
       -
           // If neither case applies to you, feel free to delete the declaration you

     

       47
       47
       -
           // don't need and to put everything under a single module.

     

       48
       8
        
           const exe = b.addExecutable(.{

     

       49
       9
        
               .name = "zig",

     

       50
       10
        
               .root_module = b.createModule(.{

     

       51
       51
       -
                   // b.createModule defines a new module just like b.addModule but,

     

       52
       52
       -
                   // unlike b.addModule, it does not expose the module to consumers of

     

       53
       53
       -
                   // this package, which is why in this case we don't have to give it a name.

     

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

     

       55
       55
       -
                   // Target and optimization levels must be explicitly wired in when

     

       56
       56
       -
                   // defining an executable or library (in the root module), and you

     

       57
       57
       -
                   // can also hardcode a specific target for an executable or library

     

       58
       58
       -
                   // definition if desireable (e.g. firmware for embedded devices).

     

       12
       12
       +
       

     

       59
       13
        
                   .target = target,

     

       60
       14
        
                   .optimize = optimize,

     

       61
       61
       -
                   // List of modules available for import in source files part of the

     

       62
       62
       -
                   // root module.

     

       63
       15
        
               }),

     

       64
       16
        
           });

     

       65
       17
        
       

     

       66
       66
       -
           // This declares intent for the executable to be installed into the

     

       67
       67
       -
           // install prefix when running `zig build` (i.e. when executing the default

     

       68
       68
       -
           // step). By default the install prefix is `zig-out/` but can be overridden

     

       69
       69
       -
           // by passing `--prefix` or `-p`.

     

       70
       18
        
           b.installArtifact(exe);

     

       71
       19
        
       

     

       72
       72
       -
           // This creates a top level step. Top level steps have a name and can be

     

       73
       73
       -
           // invoked by name when running `zig build` (e.g. `zig build run`).

     

       74
       74
       -
           // This will evaluate the `run` step rather than the default step.

     

       75
       75
       -
           // For a top level step to actually do something, it must depend on other

     

       76
       76
       -
           // steps (e.g. a Run step, as we will see in a moment).

     

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

     

       78
       21
        
       

     

       79
       79
       -
           // This creates a RunArtifact step in the build graph. A RunArtifact step

     

       80
       80
       -
           // invokes an executable compiled by Zig. Steps will only be executed by the

     

       81
       81
       -
           // runner if invoked directly by the user (in the case of top level steps)

     

       82
       82
       -
           // or if another step depends on it, so it's up to you to define when and

     

       83
       83
       -
           // how this Run step will be executed. In our case we want to run it when

     

       84
       84
       -
           // the user runs `zig build run`, so we create a dependency link.

     

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

     

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

     

       87
       24
        
       

     

       88
       88
       -
           // By making the run step depend on the default step, it will be run from the

     

       89
       89
       -
           // installation directory rather than directly from within the cache directory.

     

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

     

       91
       26
        
       

     

       92
       92
       -
           // This allows the user to pass arguments to the application in the build

     

       93
       93
       -
           // command itself, like this: `zig build run -- arg1 arg2 etc`

     

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

     

       95
       28
        
               run_cmd.addArgs(args);

     

       96
       29
        
           }

     

       97
       30
        
       

     

       98
       98
       -
           // Creates an executable that will run `test` blocks from the executable's

     

       99
       99
       -
           // root module. Note that test executables only test one module at a time,

     

       100
       100
       -
           // hence why we have to create two separate ones.

     

       101
       31
        
           const exe_tests = b.addTest(.{

     

       102
       32
        
               .root_module = exe.root_module,

     

       103
       33
        
           });

     

       104
       34
        
       

     

       105
       105
       -
           // A run step that will run the second test executable.

     

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

     

       107
       36
        
       

     

       108
       108
       -
           // A top level step for running all tests. dependOn can be called multiple

     

       109
       109
       -
           // times and since the two run steps do not depend on one another, this will

     

       110
       110
       -
           // make the two of them run in parallel.

     

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

     

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

     

       113
       113
       -
       

     

       114
       114
       -
           // Just like flags, top level steps are also listed in the `--help` menu.

     

       115
       115
       -
           //

     

       116
       116
       -
           // The Zig build system is entirely implemented in userland, which means

     

       117
       117
       -
           // that it cannot hook into private compiler APIs. All compilation work

     

       118
       118
       -
           // orchestrated by the build system will result in other Zig compiler

     

       119
       119
       -
           // subcommands being invoked with the right flags defined. You can observe

     

       120
       120
       -
           // these invocations when one fails (or you pass a flag to increase

     

       121
       121
       -
           // verbosity) to validate assumptions and diagnose problems.

     

       122
       122
       -
           //

     

       123
       123
       -
           // Lastly, the Zig build system is relatively simple and self-contained,

     

       124
       124
       -
           // and reading its source code will allow you to master it.

     

       125
       39
        
       }

+6 -4

2025/2/rust/src/main.rs

···

       23
       23
        
               })

     

       24
       24
        
               .collect();

     

       25
       25
        
       

     

       26
       26
       -
           let powers_of_ten: Vec<u64> = (0..=MAX_LENGTH as u32).map(|i| 10_u64.pow(i)).collect();

     

       26
       26
       +
           let powers_of_ten: Vec<u64> =

     

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

     

       27
       28
        
       

     

       28
       29
        
           let [invalid_part_1, invalid_part_2] = {

     

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

     
···

       31
       32
        
       

     

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

     

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

     

       34
       34
       -
                   for combination in

     

       35
       35
       -
                       *powers_of_ten.get(len - 1).unwrap_or(&1)..*powers_of_ten.get(len).unwrap()

     

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

     

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

     

       36
       37
        
                   {

     

       37
       38
        
                       let mut number = 0;

     

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

     

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

     

       40
       40
       -
                           number += combination * powers_of_ten.get((len * repeat) as usize).unwrap();

     

       41
       41
       +
                           number += combination

     

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

     

       41
       43
        
                           if repeat > 0 {

     

       42
       44
        
                               part_2.insert(number);

     

       43
       45
        
                           }

+3 -1

2025/3/gleam/src/main.gleam

···

       25
       25
        
               // and then we get the highest number

     

       26
       26
        
               // and done here

     

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

     

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

     

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

     

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

     

       29
       31
        
                 bank

     

       30
       32
        
                 |> list.reverse

     
···

       37
       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

     

       38
       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

     

       39
       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

     

       40
       40
       -
               // wky 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

     

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

     

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

     

       42
       44
        
             })

     

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

2025/3/rust/Cargo.lock

···

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

     

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

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

2025/3/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+38

2025/3/rust/src/main.rs

···

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

     

       2
       2
       +
       

     

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

     

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

     

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

     

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

     

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

     

       8
       8
       +
                       .iter()

     

       9
       9
       +
                       .enumerate()

     

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

     

       11
       11
       +
                       .reduce(

     

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

     

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

     

       14
       14
       +
                           },

     

       15
       15
       +
                       )

     

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

     

       17
       17
       +
                       .unwrap();

     

       18
       18
       +
       

     

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

     

       20
       20
       +
               });

     

       21
       21
       +
               acc + n

     

       22
       22
       +
           })

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       fn main() {

     

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

     

       27
       27
       +
               .trim()

     

       28
       28
       +
               .split("\n")

     

       29
       29
       +
               .map(|bank| {

     

       30
       30
       +
                   bank.chars()

     

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

     

       32
       32
       +
                       .collect()

     

       33
       33
       +
               })

     

       34
       34
       +
               .collect();

     

       35
       35
       +
       

     

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

     

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

     

       38
       38
       +
       }

+20

2025/4/gleam/gleam.toml

···

       1
       1
       +
       name = "main"

     

       2
       2
       +
       version = "1.0.0"

     

       3
       3
       +
       

     

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

     

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

     

       6
       6
       +
       #

     

       7
       7
       +
       # description = ""

     

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

     

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

     

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

     

       11
       11
       +
       #

     

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

     

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

     

       14
       14
       +
       

     

       15
       15
       +
       [dependencies]

     

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

     

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

     

       18
       18
       +
       

     

       19
       19
       +
       [dev-dependencies]

     

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

+14

2025/4/gleam/manifest.toml

···

       1
       1
       +
       # This file was generated by Gleam

     

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

     

       3
       3
       +
       

     

       4
       4
       +
       packages = [

     

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

     

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

     

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

     

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

     

       9
       9
       +
       ]

     

       10
       10
       +
       

     

       11
       11
       +
       [requirements]

     

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

     

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

     

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

+96

2025/4/gleam/src/main.gleam

···

       1
       1
       +
       import gleam/bit_array

     

       2
       2
       +
       import gleam/int

     

       3
       3
       +
       import gleam/io

     

       4
       4
       +
       import gleam/list

     

       5
       5
       +
       import gleam/result

     

       6
       6
       +
       import gleam/string

     

       7
       7
       +
       import simplifile as file

     

       8
       8
       +
       

     

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

     

       10
       10
       +
         case

     

       11
       11
       +
           case x, y {

     

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

     

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

     

       14
       14
       +
       

     

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

     

       16
       16
       +
           }

     

       17
       17
       +
         {

     

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

     

       19
       19
       +
           _ -> 0

     

       20
       20
       +
         }

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       fn part_1(map, size) {

     

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

     

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

     

       26
       26
       +
           let x = pos % size

     

       27
       27
       +
           let y = pos / size

     

       28
       28
       +
       

     

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

     

       30
       30
       +
       

     

       31
       31
       +
           let neighbours =

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       40
       40
       +
       

     

       41
       41
       +
           case roll, neighbours < 4 {

     

       42
       42
       +
             1, True -> acc + 1

     

       43
       43
       +
             _, _ -> acc

     

       44
       44
       +
           }

     

       45
       45
       +
         })

     

       46
       46
       +
       }

     

       47
       47
       +
       

     

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

     

       49
       49
       +
         let #(rolls, new_map) =

     

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

     

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

     

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

     

       53
       53
       +
             let x = pos % size

     

       54
       54
       +
             let y = pos / size

     

       55
       55
       +
       

     

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

     

       57
       57
       +
       

     

       58
       58
       +
             let neighbours =

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       67
       67
       +
       

     

       68
       68
       +
             case roll, neighbours < 4 {

     

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

     

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

     

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

     

       72
       72
       +
             }

     

       73
       73
       +
           })

     

       74
       74
       +
       

     

       75
       75
       +
         case map == new_map {

     

       76
       76
       +
           True -> rolls

     

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

     

       78
       78
       +
         }

     

       79
       79
       +
       }

     

       80
       80
       +
       

     

       81
       81
       +
       pub fn main() {

     

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

     

       83
       83
       +
           as "Input file not found"

     

       84
       84
       +
         let input =

     

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

     

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

     

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

     

       88
       88
       +
         // @ and .

     

       89
       89
       +
       

     

       90
       90
       +
         part_1(input, size)

     

       91
       91
       +
         |> int.to_string

     

       92
       92
       +
         |> io.println

     

       93
       93
       +
         part_2(input, size, 0)

     

       94
       94
       +
         |> int.to_string

     

       95
       95
       +
         |> io.println

     

       96
       96
       +
       }

2025/4/rust/Cargo.lock

···

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

     

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

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

2025/4/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+106

2025/4/rust/src/main.rs

···

       1
       1
       +
       use std::{

     

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

     

       3
       3
       +
           io::Write,

     

       4
       4
       +
           mem::swap,

     

       5
       5
       +
       };

     

       6
       6
       +
       

     

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

     

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

     

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

     

       10
       10
       +
           let mut i = size + 3;

     

       11
       11
       +
           for _ in 0..size {

     

       12
       12
       +
               for _ in 0..size {

     

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

     

       14
       14
       +
                   i += 1;

     

       15
       15
       +
               }

     

       16
       16
       +
               i += 2;

     

       17
       17
       +
           }

     

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

     

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

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       fn solve(

     

       23
       23
       +
           mut warehouse: Vec<u8>,

     

       24
       24
       +
           size: usize,

     

       25
       25
       +
           part_2: bool,

     

       26
       26
       +
           visualise: bool,

     

       27
       27
       +
       ) -> u32 {

     

       28
       28
       +
           if visualise {

     

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

     

       30
       30
       +
           }

     

       31
       31
       +
       

     

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

     

       33
       33
       +
       

     

       34
       34
       +
           let sizep = size + 1;

     

       35
       35
       +
       

     

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

     

       37
       37
       +
       

     

       38
       38
       +
           let mut rolls = 0;

     

       39
       39
       +
       

     

       40
       40
       +
           let mut i = 0;

     

       41
       41
       +
           loop {

     

       42
       42
       +
               for yo in 1..sizep {

     

       43
       43
       +
                   let ym = yo - 1;

     

       44
       44
       +
                   let yp = yo + 1;

     

       45
       45
       +
                   for xo in 1..sizep {

     

       46
       46
       +
                       let xm = xo - 1;

     

       47
       47
       +
                       let xp = xo + 1;

     

       48
       48
       +
       

     

       49
       49
       +
                       unsafe {

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       61
       61
       +
                                   (true, true) => {

     

       62
       62
       +
                                       rolls += 1;

     

       63
       63
       +
                                       0

     

       64
       64
       +
                                   }

     

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

     

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

     

       67
       67
       +
                               };

     

       68
       68
       +
                       }

     

       69
       69
       +
                   }

     

       70
       70
       +
               }

     

       71
       71
       +
       

     

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

     

       73
       73
       +
                   break;

     

       74
       74
       +
               }

     

       75
       75
       +
       

     

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

     

       77
       77
       +
               i += 1;

     

       78
       78
       +
               if visualise {

     

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

     

       80
       80
       +
               }

     

       81
       81
       +
           }

     

       82
       82
       +
           rolls

     

       83
       83
       +
       }

     

       84
       84
       +
       

     

       85
       85
       +
       fn main() {

     

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

     

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

     

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

     

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

     

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

     

       91
       91
       +
               .split("\n")

     

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

     

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

     

       94
       94
       +
                       .chars()

     

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

     

       96
       96
       +
                       .collect()

     

       97
       97
       +
               })

     

       98
       98
       +
               .flatten()

     

       99
       99
       +
               .collect();

     

       100
       100
       +
       

     

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

     

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

     

       103
       103
       +
       

     

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

     

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

     

       106
       106
       +
       }

+20

2025/5/gleam/gleam.toml

···

       1
       1
       +
       name = "main"

     

       2
       2
       +
       version = "1.0.0"

     

       3
       3
       +
       

     

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

     

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

     

       6
       6
       +
       #

     

       7
       7
       +
       # description = ""

     

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

     

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

     

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

     

       11
       11
       +
       #

     

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

     

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

     

       14
       14
       +
       

     

       15
       15
       +
       [dependencies]

     

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

     

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

     

       18
       18
       +
       

     

       19
       19
       +
       [dev-dependencies]

     

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

+14

2025/5/gleam/manifest.toml

···

       1
       1
       +
       # This file was generated by Gleam

     

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

     

       3
       3
       +
       

     

       4
       4
       +
       packages = [

     

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

     

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

     

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

     

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

     

       9
       9
       +
       ]

     

       10
       10
       +
       

     

       11
       11
       +
       [requirements]

     

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

     

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

     

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

+117

2025/5/gleam/src/main.gleam

···

       1
       1
       +
       import gleam/int

     

       2
       2
       +
       import gleam/io

     

       3
       3
       +
       import gleam/list

     

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

     

       5
       5
       +
       import gleam/set

     

       6
       6
       +
       import gleam/string

     

       7
       7
       +
       import simplifile as file

     

       8
       8
       +
       

     

       9
       9
       +
       pub fn main() {

     

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

     

       11
       11
       +
           as "Input file not found"

     

       12
       12
       +
         let assert [fresh_ranges, available] =

     

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

     

       14
       14
       +
         let fresh_ranges =

     

       15
       15
       +
           fresh_ranges

     

       16
       16
       +
           |> string.trim

     

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

     

       18
       18
       +
           // |> list.reverse

     

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

     

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

     

       21
       21
       +
           // |> list.reverse

     

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

     

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

     

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

     

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

     

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

     

       27
       27
       +
             #(from, to)

     

       28
       28
       +
           })

     

       29
       29
       +
         let available =

     

       30
       30
       +
           available

     

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

     

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

     

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

     

       34
       34
       +
             id

     

       35
       35
       +
           })

     

       36
       36
       +
       

     

       37
       37
       +
         available

     

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

     

       39
       39
       +
           acc

     

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

     

       41
       41
       +
             True -> 1

     

       42
       42
       +
             False -> 0

     

       43
       43
       +
           }

     

       44
       44
       +
         })

     

       45
       45
       +
         |> int.to_string

     

       46
       46
       +
         |> io.println

     

       47
       47
       +
       

     

       48
       48
       +
         // nicer looking but idc

     

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

     

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

     

       51
       51
       +
         // })

     

       52
       52
       +
         // |> list.length

     

       53
       53
       +
       

     

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

     

       55
       55
       +
         // let haha =

     

       56
       56
       +
         //   fresh_ranges

     

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

     

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

     

       59
       59
       +
         //   })

     

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

     

       61
       61
       +
       

     

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

     

       63
       63
       +
         fresh_ranges

     

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

     

       65
       65
       +
           let #(range, seen_ranges) =

     

       66
       66
       +
             prev_seen_ranges

     

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

     

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

     

       69
       69
       +
               // echo #(

     

       70
       70
       +
               //   range,

     

       71
       71
       +
               //   seen_range,

     

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

     

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

     

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

     

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

     

       76
       76
       +
               // )

     

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

     

       78
       78
       +
               case

     

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

     

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

     

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

     

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

     

       83
       83
       +
               {

     

       84
       84
       +
                 // if there's no touching

     

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

     

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

     

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

     

       88
       88
       +
                   #(-1, -1),

     

       89
       89
       +
                   seen_ranges,

     

       90
       90
       +
                 )

     

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

     

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

     

       93
       93
       +
                   range,

     

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

     

       95
       95
       +
                 )

     

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

     

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

     

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

     

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

     

       100
       100
       +
                 )

     

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

     

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

     

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

     

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

     

       105
       105
       +
                 )

     

       106
       106
       +
               }

     

       107
       107
       +
             })

     

       108
       108
       +
       

     

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

     

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

     

       111
       111
       +
             True -> seen_ranges

     

       112
       112
       +
           }

     

       113
       113
       +
         })

     

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

     

       115
       115
       +
         |> int.to_string

     

       116
       116
       +
         |> io.println

     

       117
       117
       +
       }

2025/5/rust/Cargo.lock

···

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

     

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

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

2025/5/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+75

2025/5/rust/src/main.rs

···

       1
       1
       +
       use std::{

     

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

     

       3
       3
       +
           collections::HashSet,

     

       4
       4
       +
       };

     

       5
       5
       +
       

     

       6
       6
       +
       fn main() {

     

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

     

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

     

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

     

       10
       10
       +
               .split("\n")

     

       11
       11
       +
               .map(|i| {

     

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

     

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

     

       14
       14
       +
               })

     

       15
       15
       +
               .collect();

     

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

     

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

     

       18
       18
       +
               i

     

       19
       19
       +
           });

     

       20
       20
       +
       

     

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

     

       22
       22
       +
               acc + fresh_ranges

     

       23
       23
       +
                   .iter()

     

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

     

       25
       25
       +
           });

     

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

     

       27
       27
       +
       

     

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

     

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

     

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

     

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

     

       32
       32
       +
                   *range,

     

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

     

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

     

       35
       35
       +
                       match (

     

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

     

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

     

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

     

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

     

       40
       40
       +
                       ) {

     

       41
       41
       +
                           // if there's no touching

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       50
       50
       +
                               seen_ranges.remove(seen_range);

     

       51
       51
       +
                               Some(range)

     

       52
       52
       +
                           }

     

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

     

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

     

       55
       55
       +
                               seen_ranges.remove(seen_range);

     

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

     

       57
       57
       +
                           }

     

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

     

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

     

       60
       60
       +
                               seen_ranges.remove(seen_range);

     

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

     

       62
       62
       +
                           }

     

       63
       63
       +
                       }

     

       64
       64
       +
                   },

     

       65
       65
       +
               );

     

       66
       66
       +
       

     

       67
       67
       +
               if range.is_some() {

     

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

     

       69
       69
       +
               }

     

       70
       70
       +
           });

     

       71
       71
       +
           let part_2 = seen_ranges

     

       72
       72
       +
               .into_iter()

     

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

     

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

     

       75
       75
       +
       }

+20

2025/6/gleam/gleam.toml

···

       1
       1
       +
       name = "main"

     

       2
       2
       +
       version = "1.0.0"

     

       3
       3
       +
       

     

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

     

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

     

       6
       6
       +
       #

     

       7
       7
       +
       # description = ""

     

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

     

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

     

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

     

       11
       11
       +
       #

     

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

     

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

     

       14
       14
       +
       

     

       15
       15
       +
       [dependencies]

     

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

     

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

     

       18
       18
       +
       

     

       19
       19
       +
       [dev-dependencies]

     

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

+14

2025/6/gleam/manifest.toml

···

       1
       1
       +
       # This file was generated by Gleam

     

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

     

       3
       3
       +
       

     

       4
       4
       +
       packages = [

     

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

     

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

     

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

     

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

     

       9
       9
       +
       ]

     

       10
       10
       +
       

     

       11
       11
       +
       [requirements]

     

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

     

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

     

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

+140

2025/6/gleam/src/main.gleam

···

       1
       1
       +
       import gleam/dict

     

       2
       2
       +
       import gleam/int

     

       3
       3
       +
       import gleam/io

     

       4
       4
       +
       import gleam/list

     

       5
       5
       +
       import gleam/result

     

       6
       6
       +
       import gleam/string

     

       7
       7
       +
       import simplifile as file

     

       8
       8
       +
       

     

       9
       9
       +
       type Part2Dict =

     

       10
       10
       +
         dict.Dict(Int, Int)

     

       11
       11
       +
       

     

       12
       12
       +
       type Align {

     

       13
       13
       +
         Left

     

       14
       14
       +
         Right

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       type Operation {

     

       18
       18
       +
         Sum

     

       19
       19
       +
         Mul

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       type Part2Line {

     

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

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       pub fn main() {

     

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

     

       28
       28
       +
           as "Input file not found"

     

       29
       29
       +
         let input = input |> string.trim

     

       30
       30
       +
         let input_pt_1 =

     

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

     

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

     

       33
       33
       +
           })

     

       34
       34
       +
       

     

       35
       35
       +
         input_pt_1

     

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

     

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

     

       38
       38
       +
         |> list.transpose

     

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

     

       40
       40
       +
           let i = list.reverse(i)

     

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

     

       42
       42
       +
           let i =

     

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

     

       44
       44
       +
           let r = case s {

     

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

     

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

     

       47
       47
       +
             _ -> panic as "invalid"

     

       48
       48
       +
           }

     

       49
       49
       +
           r

     

       50
       50
       +
         })

     

       51
       51
       +
         |> int.sum

     

       52
       52
       +
         |> int.to_string

     

       53
       53
       +
         |> io.println

     

       54
       54
       +
       

     

       55
       55
       +
         let lines =

     

       56
       56
       +
           input

     

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

     

       58
       58
       +
           |> list.reverse

     

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

     

       60
       60
       +
         let #(_, bounds) =

     

       61
       61
       +
           { last_line <> "                         *" }

     

       62
       62
       +
           |> string.to_graphemes

     

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

     

       64
       64
       +
             let #(bound_start, bounds) = acc

     

       65
       65
       +
             case char {

     

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

     

       67
       67
       +
               _ -> acc

     

       68
       68
       +
             }

     

       69
       69
       +
           })

     

       70
       70
       +
         bounds

     

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

     

       72
       72
       +
           let numbers =

     

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

     

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

     

       75
       75
       +
             })

     

       76
       76
       +
           let align =

     

       77
       77
       +
             numbers

     

       78
       78
       +
             |> list.drop(1)

     

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

     

       80
       80
       +
               case

     

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

     

       82
       82
       +
                 string.trim_start(number) == number

     

       83
       83
       +
               {

     

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

     

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

     

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

     

       87
       87
       +
               }

     

       88
       88
       +
             })

     

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

     

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

     

       91
       91
       +
             "*" -> Mul

     

       92
       92
       +
             "+" -> Sum

     

       93
       93
       +
             _ -> panic as sign

     

       94
       94
       +
           }

     

       95
       95
       +
           dict.insert(

     

       96
       96
       +
             d,

     

       97
       97
       +
             i,

     

       98
       98
       +
             Part2Line(

     

       99
       99
       +
               align,

     

       100
       100
       +
               sign,

     

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

     

       102
       102
       +
             ),

     

       103
       103
       +
           )

     

       104
       104
       +
         })

     

       105
       105
       +
         |> dict.to_list

     

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

     

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

     

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

     

       109
       109
       +
           let d =

     

       110
       110
       +
             line.numbers

     

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

     

       112
       112
       +
               let number_len = string.length(number)

     

       113
       113
       +
               string.to_graphemes(number)

     

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

     

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

     

       116
       116
       +
                 let pos = case line.align {

     

       117
       117
       +
                   Right -> number_len - index

     

       118
       118
       +
                   Left -> index

     

       119
       119
       +
                 }

     

       120
       120
       +
                 dict.insert(

     

       121
       121
       +
                   d,

     

       122
       122
       +
                   pos,

     

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

     

       124
       124
       +
                 )

     

       125
       125
       +
               })

     

       126
       126
       +
             })

     

       127
       127
       +
           let numbers =

     

       128
       128
       +
             dict.to_list(d)

     

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

     

       130
       130
       +
       

     

       131
       131
       +
           let r = case line.op {

     

       132
       132
       +
             Sum -> int.sum(numbers)

     

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

     

       134
       134
       +
           }

     

       135
       135
       +
           r

     

       136
       136
       +
         })

     

       137
       137
       +
         |> int.sum

     

       138
       138
       +
         |> int.to_string

     

       139
       139
       +
         |> io.println

     

       140
       140
       +
       }

+20

2025/7/gleam/gleam.toml

···

       1
       1
       +
       name = "main"

     

       2
       2
       +
       version = "1.0.0"

     

       3
       3
       +
       

     

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

     

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

     

       6
       6
       +
       #

     

       7
       7
       +
       # description = ""

     

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

     

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

     

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

     

       11
       11
       +
       #

     

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

     

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

     

       14
       14
       +
       

     

       15
       15
       +
       [dependencies]

     

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

     

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

     

       18
       18
       +
       

     

       19
       19
       +
       [dev-dependencies]

     

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

+14

2025/7/gleam/manifest.toml

···

       1
       1
       +
       # This file was generated by Gleam

     

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

     

       3
       3
       +
       

     

       4
       4
       +
       packages = [

     

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

     

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

     

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

     

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

     

       9
       9
       +
       ]

     

       10
       10
       +
       

     

       11
       11
       +
       [requirements]

     

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

     

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

     

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

+93

2025/7/gleam/src/main.gleam

···

       1
       1
       +
       import gleam/dict

     

       2
       2
       +
       import gleam/int

     

       3
       3
       +
       import gleam/io

     

       4
       4
       +
       import gleam/list

     

       5
       5
       +
       import gleam/set

     

       6
       6
       +
       import gleam/string

     

       7
       7
       +
       import simplifile as file

     

       8
       8
       +
       

     

       9
       9
       +
       pub fn main() {

     

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

     

       11
       11
       +
           as "Input file not found"

     

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

     

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

     

       14
       14
       +
         let start =

     

       15
       15
       +
           start

     

       16
       16
       +
           |> string.to_graphemes

     

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

     

       18
       18
       +
             case v {

     

       19
       19
       +
               "S" -> i

     

       20
       20
       +
               _ -> acc

     

       21
       21
       +
             }

     

       22
       22
       +
           })

     

       23
       23
       +
         let splitters_map =

     

       24
       24
       +
           input

     

       25
       25
       +
           |> list.drop(1)

     

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

     

       27
       27
       +
             case i % 2 {

     

       28
       28
       +
               0 -> ""

     

       29
       29
       +
               _ -> line

     

       30
       30
       +
             }

     

       31
       31
       +
           })

     

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

     

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

     

       34
       34
       +
             line

     

       35
       35
       +
             |> string.to_graphemes

     

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

     

       37
       37
       +
               case char {

     

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

     

       39
       39
       +
                 _ -> d

     

       40
       40
       +
               }

     

       41
       41
       +
             })

     

       42
       42
       +
           })

     

       43
       43
       +
         let #(_beams, times) =

     

       44
       44
       +
           splitters_map

     

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

     

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

     

       47
       47
       +
             beams

     

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

     

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

     

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

     

       51
       51
       +
                 False -> acc

     

       52
       52
       +
                 True -> #(

     

       53
       53
       +
                   beams

     

       54
       54
       +
                     |> set.delete(beam)

     

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

     

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

     

       57
       57
       +
                   times + 1,

     

       58
       58
       +
                 )

     

       59
       59
       +
               }

     

       60
       60
       +
             })

     

       61
       61
       +
           })

     

       62
       62
       +
       

     

       63
       63
       +
         times

     

       64
       64
       +
         |> int.to_string

     

       65
       65
       +
         |> io.println

     

       66
       66
       +
       

     

       67
       67
       +
         let timelines =

     

       68
       68
       +
           splitters_map

     

       69
       69
       +
           |> list.index_fold(

     

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

     

       71
       71
       +
             fn(timelines, splitters, i) {

     

       72
       72
       +
               echo i

     

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

     

       74
       74
       +
               timelines

     

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

     

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

     

       77
       77
       +
                   False -> timelines

     

       78
       78
       +
                   True -> {

     

       79
       79
       +
                     timelines

     

       80
       80
       +
                     |> dict.delete(timeline)

     

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

     

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

     

       83
       83
       +
                   }

     

       84
       84
       +
                 }

     

       85
       85
       +
               })

     

       86
       86
       +
             },

     

       87
       87
       +
           )

     

       88
       88
       +
         echo timelines

     

       89
       89
       +
         timelines

     

       90
       90
       +
         |> dict.size

     

       91
       91
       +
         |> int.to_string

     

       92
       92
       +
         |> io.println

     

       93
       93
       +
       }

2025/7/rust/Cargo.lock

···

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

     

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

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "rust"

     

       7
       7
       +
       version = "0.1.0"

2025/7/rust/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rust"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+62

2025/7/rust/src/main.rs

···

       1
       1
       +
       use std::{

     

       2
       2
       +
           collections::{HashMap, HashSet},

     

       3
       3
       +
           mem::swap,

     

       4
       4
       +
       };

     

       5
       5
       +
       

     

       6
       6
       +
       fn main() {

     

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

     

       8
       8
       +
       

     

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

     

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

     

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

     

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

     

       13
       13
       +
               .iter()

     

       14
       14
       +
               .enumerate()

     

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

     

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

     

       17
       17
       +
               .map(|line| {

     

       18
       18
       +
                   line.chars()

     

       19
       19
       +
                       .enumerate()

     

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

     

       21
       21
       +
                           if char == '^' {

     

       22
       22
       +
                               s.insert(i as u64);

     

       23
       23
       +
                           }

     

       24
       24
       +
                           s

     

       25
       25
       +
                       })

     

       26
       26
       +
               })

     

       27
       27
       +
               .collect();

     

       28
       28
       +
       

     

       29
       29
       +
           let timelines = {

     

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

     

       31
       31
       +
               timelines.insert(start, 1);

     

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

     

       33
       33
       +
               for splitters in splitters_map {

     

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

     

       35
       35
       +
                       if splitters.contains(&pos) {

     

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

     

       37
       37
       +
                           *m1 += amount;

     

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

     

       39
       39
       +
                           *p1 += amount;

     

       40
       40
       +
                       } else {

     

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

     

       42
       42
       +
                           *e += amount;

     

       43
       43
       +
                       }

     

       44
       44
       +
                   }

     

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

     

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

     

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

     

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

     

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

     

       50
       50
       +
                   //     } else {

     

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

     

       52
       52
       +
                   //     }

     

       53
       53
       +
                   // }

     

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

     

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

     

       56
       56
       +
                   timelines_new.clear();

     

       57
       57
       +
               }

     

       58
       58
       +
               timelines

     

       59
       59
       +
           };

     

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

     

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

     

       62
       62
       +
       }

rustfmt.toml

···

       1
       1
       +
       edition = "2024"

     

       2
       2
       +
       max_width = 80

+1 -1

template/rust/src/main.rs

···

       1
       1
        
       fn main() {

     

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

     

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

     

       3
       3
        
       

     

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

     

       5
       5
        
       }

+2 -88

template/zig/build.zig

···

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

     

       2
       2
        
       

     

       3
       3
       -
       // Although this function looks imperative, it does not perform the build

     

       4
       4
       -
       // directly and instead it mutates the build graph (`b`) that will be then

     

       5
       5
       -
       // executed by an external runner. The functions in `std.Build` implement a DSL

     

       6
       6
       -
       // for defining build steps and express dependencies between them, allowing the

     

       7
       7
       -
       // build runner to parallelize the build automatically (and the cache system to

     

       8
       8
       -
       // know when a step doesn't need to be re-run).

     

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

     

       10
       10
       -
           // Standard target options allow the person running `zig build` to choose

     

       11
       11
       -
           // what target to build for. Here we do not override the defaults, which

     

       12
       12
       -
           // means any target is allowed, and the default is native. Other options

     

       13
       13
       -
           // for restricting supported target set are available.

     

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

     

       15
       15
       -
           // Standard optimization options allow the person running `zig build` to select

     

       16
       16
       -
           // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not

     

       17
       17
       -
           // set a preferred release mode, allowing the user to decide how to optimize.

     

       5
       5
       +
       

     

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

     

       19
       19
       -
           // It's also possible to define more custom flags to toggle optional features

     

       20
       20
       -
           // of this build script using `b.option()`. All defined flags (including

     

       21
       21
       -
           // target and optimize options) will be listed when running `zig build --help`

     

       22
       22
       -
           // in this directory.

     

       23
       7
        
       

     

       24
       24
       -
           // This creates a module, which represents a collection of source files alongside

     

       25
       25
       -
           // some compilation options, such as optimization mode and linked system libraries.

     

       26
       26
       -
           // Zig modules are the preferred way of making Zig code available to consumers.

     

       27
       27
       -
           // addModule defines a module that we intend to make available for importing

     

       28
       28
       -
           // to our consumers. We must give it a name because a Zig package can expose

     

       29
       29
       -
           // multiple modules and consumers will need to be able to specify which

     

       30
       30
       -
           // module they want to access.

     

       31
       31
       -
       

     

       32
       32
       -
           // Here we define an executable. An executable needs to have a root module

     

       33
       33
       -
           // which needs to expose a `main` function. While we could add a main function

     

       34
       34
       -
           // to the module defined above, it's sometimes preferable to split business

     

       35
       35
       -
           // logic and the CLI into two separate modules.

     

       36
       36
       -
           //

     

       37
       37
       -
           // If your goal is to create a Zig library for others to use, consider if

     

       38
       38
       -
           // it might benefit from also exposing a CLI tool. A parser library for a

     

       39
       39
       -
           // data serialization format could also bundle a CLI syntax checker, for example.

     

       40
       40
       -
           //

     

       41
       41
       -
           // If instead your goal is to create an executable, consider if users might

     

       42
       42
       -
           // be interested in also being able to embed the core functionality of your

     

       43
       43
       -
           // program in their own executable in order to avoid the overhead involved in

     

       44
       44
       -
           // subprocessing your CLI tool.

     

       45
       45
       -
           //

     

       46
       46
       -
           // If neither case applies to you, feel free to delete the declaration you

     

       47
       47
       -
           // don't need and to put everything under a single module.

     

       48
       8
        
           const exe = b.addExecutable(.{

     

       49
       9
        
               .name = "zig",

     

       50
       10
        
               .root_module = b.createModule(.{

     

       51
       51
       -
                   // b.createModule defines a new module just like b.addModule but,

     

       52
       52
       -
                   // unlike b.addModule, it does not expose the module to consumers of

     

       53
       53
       -
                   // this package, which is why in this case we don't have to give it a name.

     

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

     

       55
       55
       -
                   // Target and optimization levels must be explicitly wired in when

     

       56
       56
       -
                   // defining an executable or library (in the root module), and you

     

       57
       57
       -
                   // can also hardcode a specific target for an executable or library

     

       58
       58
       -
                   // definition if desireable (e.g. firmware for embedded devices).

     

       12
       12
       +
       

     

       59
       13
        
                   .target = target,

     

       60
       14
        
                   .optimize = optimize,

     

       61
       61
       -
                   // List of modules available for import in source files part of the

     

       62
       62
       -
                   // root module.

     

       63
       15
        
               }),

     

       64
       16
        
           });

     

       65
       17
        
       

     

       66
       66
       -
           // This declares intent for the executable to be installed into the

     

       67
       67
       -
           // install prefix when running `zig build` (i.e. when executing the default

     

       68
       68
       -
           // step). By default the install prefix is `zig-out/` but can be overridden

     

       69
       69
       -
           // by passing `--prefix` or `-p`.

     

       70
       18
        
           b.installArtifact(exe);

     

       71
       19
        
       

     

       72
       72
       -
           // This creates a top level step. Top level steps have a name and can be

     

       73
       73
       -
           // invoked by name when running `zig build` (e.g. `zig build run`).

     

       74
       74
       -
           // This will evaluate the `run` step rather than the default step.

     

       75
       75
       -
           // For a top level step to actually do something, it must depend on other

     

       76
       76
       -
           // steps (e.g. a Run step, as we will see in a moment).

     

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

     

       78
       21
        
       

     

       79
       79
       -
           // This creates a RunArtifact step in the build graph. A RunArtifact step

     

       80
       80
       -
           // invokes an executable compiled by Zig. Steps will only be executed by the

     

       81
       81
       -
           // runner if invoked directly by the user (in the case of top level steps)

     

       82
       82
       -
           // or if another step depends on it, so it's up to you to define when and

     

       83
       83
       -
           // how this Run step will be executed. In our case we want to run it when

     

       84
       84
       -
           // the user runs `zig build run`, so we create a dependency link.

     

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

     

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

     

       87
       24
        
       

     

       88
       88
       -
           // By making the run step depend on the default step, it will be run from the

     

       89
       89
       -
           // installation directory rather than directly from within the cache directory.

     

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

     

       91
       26
        
       

     

       92
       92
       -
           // This allows the user to pass arguments to the application in the build

     

       93
       93
       -
           // command itself, like this: `zig build run -- arg1 arg2 etc`

     

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

     

       95
       28
        
               run_cmd.addArgs(args);

     

       96
       29
        
           }

     

       97
       30
        
       

     

       98
       98
       -
           // Creates an executable that will run `test` blocks from the executable's

     

       99
       99
       -
           // root module. Note that test executables only test one module at a time,

     

       100
       100
       -
           // hence why we have to create two separate ones.

     

       101
       31
        
           const exe_tests = b.addTest(.{

     

       102
       32
        
               .root_module = exe.root_module,

     

       103
       33
        
           });

     

       104
       34
        
       

     

       105
       105
       -
           // A run step that will run the second test executable.

     

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

     

       107
       36
        
       

     

       108
       108
       -
           // A top level step for running all tests. dependOn can be called multiple

     

       109
       109
       -
           // times and since the two run steps do not depend on one another, this will

     

       110
       110
       -
           // make the two of them run in parallel.

     

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

     

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

     

       113
       113
       -
       

     

       114
       114
       -
           // Just like flags, top level steps are also listed in the `--help` menu.

     

       115
       115
       -
           //

     

       116
       116
       -
           // The Zig build system is entirely implemented in userland, which means

     

       117
       117
       -
           // that it cannot hook into private compiler APIs. All compilation work

     

       118
       118
       -
           // orchestrated by the build system will result in other Zig compiler

     

       119
       119
       -
           // subcommands being invoked with the right flags defined. You can observe

     

       120
       120
       -
           // these invocations when one fails (or you pass a flag to increase

     

       121
       121
       -
           // verbosity) to validate assumptions and diagnose problems.

     

       122
       122
       -
           //

     

       123
       123
       -
           // Lastly, the Zig build system is relatively simple and self-contained,

     

       124
       124
       -
           // and reading its source code will allow you to master it.

     

       125
       39
        
       }

Compare changes