commit 2c3e306b8833a564fd7f0480ab60bd0837661e8d · aylac.top/advent_of_code

.gitignore

+41 -4

2025/4/rust/src/main.rs

···

       1
       1
       -
       use std::mem::swap;

     

       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.extend(if warehouse.get(i).unwrap() == &1_u8 {

     

       14
       14
       +
                       [1]

     

       15
       15
       +
                   } else {

     

       16
       16
       +
                       [0]

     

       17
       17
       +
                   });

     

       18
       18
       +
                   i += 1;

     

       19
       19
       +
               }

     

       20
       20
       +
               i += 2;

     

       21
       21
       +
           }

     

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

     

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

     

       24
       24
       +
       }

     

       2
       25
        
       

     

       3
       3
       -
       fn solve(mut warehouse: Vec<u8>, size: usize, part_2: bool) -> u32 {

     

       26
       26
       +
       fn solve(

     

       27
       27
       +
           mut warehouse: Vec<u8>,

     

       28
       28
       +
           size: usize,

     

       29
       29
       +
           part_2: bool,

     

       30
       30
       +
           visualise: bool,

     

       31
       31
       +
       ) -> u32 {

     

       32
       32
       +
           if visualise {

     

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

     

       34
       34
       +
           }

     

       35
       35
       +
       

     

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

     

       5
       37
        
       

     

       6
       38
        
           let sizep = size + 1;

     
···

       9
       41
        
       

     

       10
       42
        
           let mut rolls = 0;

     

       11
       43
        
       

     

       44
       44
       +
           let mut i = 0;

     

       12
       45
        
           loop {

     

       13
       46
        
               for yo in 1..sizep {

     

       14
       47
        
                   let ym = yo - 1;

     
···

       45
       78
        
               }

     

       46
       79
        
       

     

       47
       80
        
               swap(&mut warehouse, &mut new_warehouse);

     

       81
       81
       +
               i += 1;

     

       82
       82
       +
               if visualise {

     

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

     

       84
       84
       +
               }

     

       48
       85
        
           }

     

       49
       86
        
           rolls

     

       50
       87
        
       }

     
···

       65
       102
        
               .flatten()

     

       66
       103
        
               .collect();

     

       67
       104
        
       

     

       68
       68
       -
           let part_1 = solve(input.clone(), size, false);

     

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

     

       69
       106
        
           println!("Part 1: {}", part_1);

     

       70
       107
        
       

     

       71
       71
       -
           let part_2 = solve(input.clone(), size, true);

     

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

     

       72
       109
        
           println!("Part 2: {}", part_2);

     

       73
       110
        
       }