···

       
21
       
21
       
 
       
        combinations

     

       
22
       
22
       
 
       
    };

     

       
23
       
23
       
 
       


     

       
24
       
24
       
-
       
    let medicine_mol: Vec<String> = {

     

       
25
       
25
       
-
       
        let mut mol = Vec::new();

     

       
26
       
26
       
-
       
        input.last().unwrap().chars().for_each(|letter| {

     

       
27
       
27
       
-
       
            if letter.is_lowercase() {

     

       
28
       
28
       
-
       
                mol.push(format!("{}{}", mol.last().unwrap(), letter));

     

       
29
       
29
       
-
       
            } else {

     

       
30
       
30
       
-
       
                mol.push(format!("{}", letter))

     

       
31
       
31
       
-
       
            }

     

       
32
       
32
       
-
       
        });

     

       
33
       
33
       
-
       
        mol

     

       
34
       
34
       
-
       
    };

     

       
35
       
35
       
-
       
    println!("{:?}", medicine_mol);

     

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

     

       
36
       
25
       
 
       


     

       
37
       
26
       
 
       
    // part 1

     

       
38
       
27
       
 
       
    {

     

       
39
       
28
       
 
       
        let mol_len = medicine_mol.len();

     

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

     

       
41
       
41
       
-
       
        for (k, element) in medicine_mol.iter().enumerate() {

     

       
42
       
42
       
-
       
            let of_element = combinations.get(element);

     

       
43
       
43
       
-
       


     

       
44
       
44
       
-
       
            match of_element {

     

       
45
       
45
       
-
       
                Some(of_element) => of_element.iter().for_each(|new_element| {

     

       
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| {

     

       
46
       
34
       
 
       
                    possibilities.insert(format!(

     

       
47
       
47
       
-
       
                        "{}{}{}",

     

       
48
       
48
       
-
       
                        medicine_mol[0..k].join(""),

     

       
49
       
49
       
-
       
                        new_element,

     

       
50
       
50
       
-
       
                        medicine_mol[k + 1..mol_len].join("")

     

       
35
       
35
       
+
       
                        "{}{}",

     

       
36
       
36
       
+
       
                        a,

     

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

     

       
51
       
38
       
 
       
                    ));

     

       
52
       
52
       
-
       
                }),

     

       
53
       
53
       
-
       
                _ => {}

     

       
54
       
54
       
-
       
            }

     

       
39
       
39
       
+
       
                })

     

       
40
       
40
       
+
       
            });

     

       
55
       
41
       
 
       
        }

     

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

     

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

     

       
57
       
43
       
 
       
    }

     

       
58
       
44
       
 
       
}