commit d3599df527bfce2c3e8ab546772274df6f50b53e · aylac.top/advent_of_code

+16 -16
2025/4/rust/src/main.rs
···

       1
       1
        
       use std::mem::swap;

     

       2
       2
        
       

     

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

     

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

     

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

     

       5
       5
        
       

     

       6
       6
        
           let sizep = size + 1;

     

       7
       7
        
       

     

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

     

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

     

       9
       9
        
       

     

       10
       10
        
           let mut rolls = 0;

     

       11
       11
        
       

     
···

       18
       18
        
                       let xp = xo + 1;

     

       19
       19
        
       

     

       20
       20
        
                       unsafe {

     

       21
       21
       -
                           let was = *world.get_unchecked(pos(xo, yo)) == 1;

     

       22
       22
       -
                           let neighbours = world.get_unchecked(pos(xm, ym))

     

       23
       23
       -
                               + world.get_unchecked(pos(xo, ym))

     

       24
       24
       -
                               + world.get_unchecked(pos(xp, ym))

     

       25
       25
       -
                               + world.get_unchecked(pos(xm, yo))

     

       26
       26
       -
                               + world.get_unchecked(pos(xp, yo))

     

       27
       27
       -
                               + world.get_unchecked(pos(xm, yp))

     

       28
       28
       -
                               + world.get_unchecked(pos(xo, yp))

     

       29
       29
       -
                               + world.get_unchecked(pos(xp, yp));

     

       30
       30
       -
                           *new_world.get_unchecked_mut(pos(xo, yo)) =

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       31
       31
        
                               match (was, neighbours < 4) {

     

       32
       32
        
                                   (true, true) => {

     

       33
       33
        
                                       rolls += 1;

     
···

       40
       40
        
                   }

     

       41
       41
        
               }

     

       42
       42
        
       

     

       43
       43
       -
               if !part_2 || world == new_world {

     

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

     

       44
       44
        
                   break;

     

       45
       45
        
               }

     

       46
       46
        
       

     

       47
       47
       -
               swap(&mut world, &mut new_world);

     

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

     

       48
       48
        
           }

     

       49
       49
        
           rolls

     

       50
       50
        
       }

     
···

       65
       65
        
               .flatten()

     

       66
       66
        
               .collect();

     

       67
       67
        
       

     

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

     

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

     

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

     

       70
       70
        
       

     

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

     

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

     

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

     

       73
       73
        
       }