4005027531

Build Type

github

Committed by GitHub

Commit Message

Merge 74f46dcbf into 0e0e3157b

Pull Request Pull Request #19: Updated versions

Run Details

2556 of 3992 branches covered (64.03%)

Branch coverage included in aggregate %.

1560 of 1560 new or added lines in 44 files covered. (100.0%)

5981 of 6247 relevant lines covered (95.74%)

624811.64 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

22.64

/adv2020/src/day7.rs

use itertools::Itertools;
use std::collections::HashMap;

pub fn find_answer1(input: &str) -> usize {
    let mut rules: HashMap<String, HashMap<String, usize>> = HashMap::new();

    input.lines().for_each(|line| {
        let line_split: Vec<&str> = line.split("contain").collect();
        let what = line_split[0].split_whitespace().take(2).join(" ");
        let mut map: HashMap<String, usize> = HashMap::new();
        let bags_split: Vec<&str> = line_split[1].split(", ").collect();
        if !bags_split.contains(&"no other") {
            for bag in bags_split {
                let bag = bag.split_whitespace().take(3).join(" ");
                let num = bag
                    .split_whitespace()
                    .next()
                    .unwrap()
                    .parse::<usize>()
                    .unwrap_or_default();
                let color = bag.split_whitespace().skip(1).take(2).join(" ");
                map.insert(color, num);
            }
        }

        rules.insert(what, map);
    });

    let mut result = 0;

    for (key, _) in rules.iter() {
        if contains(&rules, key, &String::from("shiny gold")) {
            result += 1;
        }
    }
    result
}

fn contains(rules: &HashMap<String, HashMap<String, usize>>, key: &String, what: &String) -> bool {
    if rules.contains_key(key) {
        let nested_bags = rules.get(key).unwrap();
        if nested_bags.is_empty() {
            return false;
        } else {
            let mut result = false;

            for (k, _) in nested_bags {
                if nested_bags.contains_key(what) {
                    return true;
                }

                result = result | contains(rules, k, what);

                if result {
                    return true;
                }
            }

            return result;
        }
    }

    false
}

fn count_bags(rules: &HashMap<String, HashMap<String, usize>>, what: &String) -> usize {
    if !rules.contains_key(what) {
        return 0;
    }

    let bags = rules.get(what).unwrap();
    if bags.is_empty() {
        return 0;
    }

    let mut result = 0usize;
    for (small_bag, count) in bags {
        result += count_bags(rules, small_bag) * count + count;
    }

    result
}

pub fn find_answer2(input: &str) -> usize {
    let mut rules: HashMap<String, HashMap<String, usize>> = HashMap::new();

    input.lines().for_each(|line| {
        let line_split: Vec<&str> = line.split("contain").collect();
        let what = line_split[0].split_whitespace().take(2).join(" ");
        let mut map: HashMap<String, usize> = HashMap::new();
        let bags_split: Vec<&str> = line_split[1].split(", ").collect();
        if !bags_split.contains(&"no other") {
            for bag in bags_split {
                let bag = bag.split_whitespace().take(3).join(" ");
                let num = bag
                    .split_whitespace()
                    .next()
                    .unwrap()
                    .parse::<usize>()
                    .unwrap_or_default();
                let color = bag.split_whitespace().skip(1).take(2).join(" ");
                map.insert(color, num);
            }
        }

        rules.insert(what, map);
    });

    count_bags(&rules, &String::from("shiny gold"))
}
/*
fn parse_input<'a>(input: &'a str) -> impl Iterator<Item=Seat> + 'a {
    input.lines()
        .map(&str::trim)
        .map(parse_seat)
}
*/

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_empty_answers() {
        assert_eq!(find_answer1(""), 0);
        assert_eq!(find_answer2(""), 0);
    }
}

1	use itertools::Itertools;	2✔
2	use std::collections::HashMap;
3
4	pub fn find_answer1(input: &str) -> usize {	2✔
5	let mut rules: HashMap<String, HashMap<String, usize>> = HashMap::new();	2✔
6
7	input.lines().for_each(\|line\| {	2✔
8	let line_split: Vec<&str> = line.split("contain").collect();	×
9	let what = line_split[0].split_whitespace().take(2).join(" ");	×
10	let mut map: HashMap<String, usize> = HashMap::new();	×
11	let bags_split: Vec<&str> = line_split[1].split(", ").collect();	×
12	if !bags_split.contains(&"no other") {	×
13	for bag in bags_split {	×
14	let bag = bag.split_whitespace().take(3).join(" ");	×
15	let num = bag	×
16	.split_whitespace()
17	.next()
18	.unwrap()
19	.parse::<usize>()
20	.unwrap_or_default();
21	let color = bag.split_whitespace().skip(1).take(2).join(" ");	×
22	map.insert(color, num);	×
23	}	×
24	}
25
26	rules.insert(what, map);	×
27	});	×
28
29	let mut result = 0;	2✔
30
31	for (key, _) in rules.iter() {	2!
32	if contains(&rules, key, &String::from("shiny gold")) {	×
33	result += 1;	×
34	}
35	}
36	result
37	}	2✔
38
39	fn contains(rules: &HashMap<String, HashMap<String, usize>>, key: &String, what: &String) -> bool {	×
40	if rules.contains_key(key) {	×
41	let nested_bags = rules.get(key).unwrap();	×
42	if nested_bags.is_empty() {	×
43	return false;	×
44	} else {
45	let mut result = false;	×
46
47	for (k, _) in nested_bags {	×
48	if nested_bags.contains_key(what) {	×
49	return true;	×
50	}
51
52	result = result \| contains(rules, k, what);	×
53
54	if result {	×
55	return true;	×
56	}
57	}
58
59	return result;	×
60	}
61	}
62
63	false	×
64	}	×
65
66	fn count_bags(rules: &HashMap<String, HashMap<String, usize>>, what: &String) -> usize {	2✔
67	if !rules.contains_key(what) {	2!
68	return 0;	2✔
69	}
70
71	let bags = rules.get(what).unwrap();	×
72	if bags.is_empty() {	×
73	return 0;	×
74	}
75
76	let mut result = 0usize;	×
77	for (small_bag, count) in bags {	×
78	result += count_bags(rules, small_bag) * count + count;	×
79	}
80
81	result	×
82	}	2✔
83
84	pub fn find_answer2(input: &str) -> usize {	2✔
85	let mut rules: HashMap<String, HashMap<String, usize>> = HashMap::new();	2✔
86
87	input.lines().for_each(\|line\| {	2✔
88	let line_split: Vec<&str> = line.split("contain").collect();	×
89	let what = line_split[0].split_whitespace().take(2).join(" ");	×
90	let mut map: HashMap<String, usize> = HashMap::new();	×
91	let bags_split: Vec<&str> = line_split[1].split(", ").collect();	×
92	if !bags_split.contains(&"no other") {	×
93	for bag in bags_split {	×
94	let bag = bag.split_whitespace().take(3).join(" ");	×
95	let num = bag	×
96	.split_whitespace()
97	.next()
98	.unwrap()
99	.parse::<usize>()
100	.unwrap_or_default();
101	let color = bag.split_whitespace().skip(1).take(2).join(" ");	×
102	map.insert(color, num);	×
103	}	×
104	}
105
106	rules.insert(what, map);	×
107	});	×
108
109	count_bags(&rules, &String::from("shiny gold"))	2✔
110	}	2✔
111	/*
112	fn parse_input<'a>(input: &'a str) -> impl Iterator<Item=Seat> + 'a {
113	input.lines()
114	.map(&str::trim)
115	.map(parse_seat)
116	}
117	*/
118
119	#[cfg(test)]
120	mod tests {
121	use super::*;
122
123	#[test]
124	fn test_empty_answers() {	2✔
125	assert_eq!(find_answer1(""), 0);	1!
126	assert_eq!(find_answer2(""), 0);	1!
127	}	2✔
128	}

Vest / aoc-rust / 4005027531

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous