commit 0194f0b016b78a4a6754f91ba6bb817143720428 · aylac.top/advent_of_code

+54 -18

2015/19/rust/src/main.rs

···

       1
       1
       -
       struct Combination {

     

       2
       2
       -
           original: String,

     

       3
       3
       -
           target: String,

     

       4
       4
       -
       }

     

       1
       1
       +
       use std::collections::{HashMap, HashSet};

     

       5
       2
        
       

     

       6
       3
        
       fn main() {

     

       7
       7
       -
           let input: String = std::fs::read_to_string("../input.txt").expect("invalid input!!");

     

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

     

       9
       9
       -
           let combinations: Vec<Combination> = &input[..input.len() - 2].iter().map(|v| {

     

       10
       10
       -
               let v: Vec<&str> = v.split(" ").collect();

     

       11
       11
       -
               match v[..] {

     

       12
       12
       -
                   [original, _, target] => Combination {

     

       13
       13
       -
                       original: original.to_string(),

     

       14
       14
       -
                       target: target.to_string(),

     

       15
       15
       -
                   },

     

       16
       16
       -
                   _ => Combination {

     

       17
       17
       -
                       original: "".to_string(),

     

       18
       18
       -
                       target: "".to_string(),

     

       19
       19
       -
                   },

     

       4
       4
       +
           let input = include_str!("../../input.txt");

     

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

     

       6
       6
       +
       

     

       7
       7
       +
           let combinations: HashMap<String, Vec<String>> = {

     

       8
       8
       +
               let mut combinations = HashMap::new();

     

       9
       9
       +
               input[..input.len() - 2].iter().for_each(|v| {

     

       10
       10
       +
                   let v: Vec<&str> = v.split(" ").collect();

     

       11
       11
       +
                   match v[..] {

     

       12
       12
       +
                       [original, "=>", target] => {

     

       13
       13
       +
                           let entry = combinations

     

       14
       14
       +
                               .entry(original.to_string())

     

       15
       15
       +
                               .or_insert(Vec::with_capacity(1));

     

       16
       16
       +
                           entry.push(target.to_string());

     

       17
       17
       +
                       }

     

       18
       18
       +
                       _ => panic!("{:?}", v),

     

       19
       19
       +
                   }

     

       20
       20
       +
               });

     

       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);

     

       36
       36
       +
       

     

       37
       37
       +
           // part 1

     

       38
       38
       +
           {

     

       39
       39
       +
               let mol_len = medicine_mol.len();

     

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

     

       46
       46
       +
                           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("")

     

       51
       51
       +
                           ));

     

       52
       52
       +
                       }),

     

       53
       53
       +
                       _ => {}

     

       54
       54
       +
                   }

     

       20
       55
        
               }

     

       21
       21
       -
           }).

     

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

     

       57
       57
       +
           }

     

       22
       58
        
       }

+1 -1

template/rust/src/main.rs

···

       1
       1
        
       fn main() {

     

       2
       2
       -
           let input = include_str!("../../input.txt");

     

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

     

       3
       3
        
       

     

       4
       4
        
           println!("{}", &input);

     

       5
       5
        
       }