···

       
1
       
 
       
use std::mem::swap;

     

       
2
       
 
       


     

       
3
       
 
       
#[inline]

     

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

     

       
5
       
 
       
    // benefits from the integer overflow to simplify code

     

       
6
       
 
       
    if x >= size || y >= size {

     

       
7
       
 
       
        return 0;

     

       
8
       
 
       
    };

     

       
9
       
 
       
    // this is in known bounds

     

       
10
       
-
       
    unsafe { *world.get_unchecked(y * size + x) as u8 }

     

       
11
       
-
       
}

     

       
12
       
-
       


     

       
13
       
-
       
#[inline]

     

       
14
       
-
       
fn get_at_bool(world: &Vec<bool>, size: usize, x: usize, y: usize) -> bool {

     

       
15
       
-
       
    // this is in known bounds

     

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

     

       
17
       
 
       
}

     

       
18
       
 
       


     

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

     

       
20
       
-
       
    let mut new_world = vec![false; size * size];

     

       
21
       
 
       
    let sizem = size - 1;

     

       
22
       
 
       
    if stuck {

     

       
23
       
-
       
        world[0] = true;

     

       
24
       
-
       
        world[sizem] = true;

     

       
25
       
-
       
        world[(size * size) - 1] = true;

     

       
26
       
-
       
        world[size * sizem] = true;

     

       
27
       
 
       
    }

     

       
28
       
 
       


     

       
29
       
 
       
    for _ in 0..times {

     
···

       
34
       
 
       
                let xm = xo.wrapping_sub(1);

     

       
35
       
 
       
                let xp = xo + 1;

     

       
36
       
 
       


     

       
37
       
-
       
                let was = get_at_bool(&world, size, xo, yo);

     

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

     

       
39
       
 
       
                    + get_at(&world, size, xo, ym)

     

       
40
       
 
       
                    + get_at(&world, size, xp, ym)

     
···

       
43
       
 
       
                    + get_at(&world, size, xm, yp)

     

       
44
       
 
       
                    + get_at(&world, size, xo, yp)

     

       
45
       
 
       
                    + get_at(&world, size, xp, yp);

     

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

     

       
47
       
 
       
            }

     

       
48
       
 
       
        }

     

       
49
       
 
       


     
···

       
51
       
 
       


     

       
52
       
 
       
        // i hate the duplication here :(

     

       
53
       
 
       
        if stuck {

     

       
54
       
-
       
            world[0] = true;

     

       
55
       
-
       
            world[sizem] = true;

     

       
56
       
-
       
            world[(size * size) - 1] = true;

     

       
57
       
-
       
            world[size * sizem] = true;

     

       
58
       
 
       
        }

     

       
59
       
 
       
    }

     

       
60
       
 
       
    world

     
···

       
63
       
 
       
fn main() {

     

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

     

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

     

       
66
       
-
       
    let input: Vec<bool> = input.replace("\n", "").chars().map(|v| v == '#').collect();

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
67
       
 
       


     

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

     

       
69
       
 
       
        .iter()

     

       
70
       
-
       
        .filter(|v| **v)

     

       
71
       
 
       
        .count();

     

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

     

       
73
       
 
       


     

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

     

       
75
       
 
       
        .iter()

     

       
76
       
-
       
        .filter(|v| **v)

     

       
77
       
 
       
        .count();

     

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

     

       
79
       
 
       
}

     

···

       
1
       
 
       
use std::mem::swap;

     

       
2
       
 
       


     

       
3
       
 
       
#[inline]

     

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

     

       
5
       
 
       
    // benefits from the integer overflow to simplify code

     

       
6
       
 
       
    if x >= size || y >= size {

     

       
7
       
 
       
        return 0;

     

       
8
       
 
       
    };

     

       
9
       
 
       
    // this is in known bounds

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
11
       
 
       
}

     

       
12
       
 
       


     

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

     

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

     

       
15
       
 
       
    let sizem = size - 1;

     

       
16
       
 
       
    if stuck {

     

       
17
       
+
       
        world[0] = 1;

     

       
18
       
+
       
        world[sizem] = 1;

     

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

     

       
20
       
+
       
        world[size * sizem] = 1;

     

       
21
       
 
       
    }

     

       
22
       
 
       


     

       
23
       
 
       
    for _ in 0..times {

     
···

       
28
       
 
       
                let xm = xo.wrapping_sub(1);

     

       
29
       
 
       
                let xp = xo + 1;

     

       
30
       
 
       


     

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

     

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

     

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

     

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

     
···

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

     

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

     

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

     

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

     

       
41
       
 
       
            }

     

       
42
       
 
       
        }

     

       
43
       
 
       


     
···

       
45
       
 
       


     

       
46
       
 
       
        // i hate the duplication here :(

     

       
47
       
 
       
        if stuck {

     

       
48
       
+
       
            world[0] = 1;

     

       
49
       
+
       
            world[sizem] = 1;

     

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

     

       
51
       
+
       
            world[size * sizem] = 1;

     

       
52
       
 
       
        }

     

       
53
       
 
       
    }

     

       
54
       
 
       
    world

     
···

       
57
       
 
       
fn main() {

     

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

     

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

     

       
60
       
+
       
    let input: Vec<u8> = input

     

       
61
       
+
       
        .replace("\n", "")

     

       
62
       
+
       
        .chars()

     

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

     

       
64
       
+
       
        .collect();

     

       
65
       
 
       


     

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

     

       
67
       
 
       
        .iter()

     

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

     

       
69
       
 
       
        .count();

     

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

     

       
71
       
 
       


     

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

     

       
73
       
 
       
        .iter()

     

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

     

       
75
       
 
       
        .count();

     

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

     

       
77
       
 
       
}