···

       
1
       
 
       
use std::{

     

       
2
       
-
       
    char,

     

       
3
       
 
       
    collections::{HashMap, HashSet},

     

       
4
       
 
       
    mem::swap,

     

       
5
       
 
       
};

     
···

       
7
       
 
       
fn main() {

     

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

     

       
9
       
 
       


     

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

     

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

     

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

     

       
0
       
 
       

     

       
13
       
 
       
        .iter()

     

       
14
       
 
       
        .enumerate()

     

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

     
···

       
19
       
 
       
                .enumerate()

     

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

     

       
21
       
 
       
                    if char == '^' {

     

       
22
       
-
       
                        s.insert(i as u32);

     

       
23
       
 
       
                    }

     

       
24
       
 
       
                    s

     

       
25
       
 
       
                })

     
···

       
27
       
 
       
        .collect();

     

       
28
       
 
       


     

       
29
       
 
       
    let timelines = {

     

       
30
       
-
       
        let mut timelines: HashMap<String, u32> = HashMap::new();

     

       
31
       
-
       
        timelines.insert("".to_string(), start);

     

       
32
       
-
       
        let mut timelines_new: HashMap<String, u32> = HashMap::new();

     

       
33
       
-
       
        for (i, splitters) in splitters_map.iter().enumerate() {

     

       
34
       
-
       
            println!("at: {}", i);

     

       
35
       
-
       
            for (timeline, pos) in &timelines {

     

       
36
       
 
       
                if splitters.contains(&pos) {

     

       
37
       
-
       
                    timelines_new.insert(format!("{timeline}+"), pos + 1);

     

       
38
       
-
       
                    timelines_new.insert(format!("{timeline}-"), pos - 1);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
39
       
 
       
                } else {

     

       
40
       
-
       
                    timelines_new.insert(format!("{timeline}|"), *pos);

     

       
0
       
 
       

     

       
41
       
 
       
                }

     

       
42
       
 
       
            }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
43
       
 
       
            swap(&mut timelines, &mut timelines_new);

     

       
44
       
 
       
            timelines_new.clear();

     

       
45
       
 
       
        }

     

       
46
       
 
       
        timelines

     

       
47
       
 
       
    };

     

       
48
       
-
       
    println!("{}", timelines.len());

     

       
0
       
 
       

     

       
49
       
 
       
}

     

···

       
1
       
 
       
use std::{

     

       
0
       
 
       

     

       
2
       
 
       
    collections::{HashMap, HashSet},

     

       
3
       
 
       
    mem::swap,

     

       
4
       
 
       
};

     
···

       
6
       
 
       
fn main() {

     

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

     

       
8
       
 
       


     

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

     

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

     

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

     

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

     

       
13
       
 
       
        .iter()

     

       
14
       
 
       
        .enumerate()

     

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

     
···

       
19
       
 
       
                .enumerate()

     

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

     

       
21
       
 
       
                    if char == '^' {

     

       
22
       
+
       
                        s.insert(i as u64);

     

       
23
       
 
       
                    }

     

       
24
       
 
       
                    s

     

       
25
       
 
       
                })

     
···

       
27
       
 
       
        .collect();

     

       
28
       
 
       


     

       
29
       
 
       
    let timelines = {

     

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

     

       
31
       
+
       
        timelines.insert(start, 1);

     

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

     

       
33
       
+
       
        for splitters in splitters_map {

     

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

     

       
0
       
 
       

     

       
35
       
 
       
                if splitters.contains(&pos) {

     

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

     

       
37
       
+
       
                    *m1 += amount;

     

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

     

       
39
       
+
       
                    *p1 += amount;

     

       
40
       
 
       
                } else {

     

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

     

       
42
       
+
       
                    *e += amount;

     

       
43
       
 
       
                }

     

       
44
       
 
       
            }

     

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

     

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

     

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

     

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

     

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

     

       
50
       
+
       
            //     } else {

     

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

     

       
52
       
+
       
            //     }

     

       
53
       
+
       
            // }

     

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

     

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

     

       
56
       
 
       
            timelines_new.clear();

     

       
57
       
 
       
        }

     

       
58
       
 
       
        timelines

     

       
59
       
 
       
    };

     

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

     

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

     

       
62
       
 
       
}