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

84.44

/adv2020/src/day9.rs

use itertools::Itertools;

pub fn find_weak_number_25(input: &str) -> usize {
    let input: Vec<usize> = parse_input(input);

    find_weak_number(&input, 25).unwrap_or((0, 0)).0
}

pub fn find_sum_of_any_numbers(input: &str) -> usize {
    let input: Vec<usize> = parse_input(input);

    if let Some((weak_number, weak_number_pos)) = find_weak_number(&input, 25) {
        (3..weak_number_pos)
            .find_map(|window_size| {
                find_possible_sum(&input[0..weak_number_pos], window_size, weak_number)
            })
            .unwrap_or_default()
    } else {
        0
    }
}

fn parse_input(input: &str) -> Vec<usize> {
    input
        .lines()
        .map(&str::trim)
        .map(&str::parse::<usize>)
        .filter_map(Result::ok)
        .collect()
}

fn find_weak_number(input: &Vec<usize>, preamble: usize) -> Option<(usize, usize)> {
    for num in preamble..input.len() {
        let last_numbers = &input[num.saturating_sub(preamble)..num];

        if last_numbers
            .into_iter()
            .combinations(2)
            .find(|pair| pair.iter().map(|n| *n).sum::<usize>() == input[num])
            .is_none()
        {
            return Some((input[num], num));
        }
    }

    None
}

fn find_possible_sum(numbers: &[usize], window_size: usize, weak_number: usize) -> Option<usize> {
    numbers
        .windows(window_size)
        .filter_map(|window| {
            let sum = window.iter().sum::<usize>();
            let min = window.iter().min();
            let max = window.iter().max();

            if sum == weak_number && min.is_some() && max.is_some() {
                Some(min.unwrap() + max.unwrap())
            } else {
                None
            }
        })
        .next()
}

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

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

    #[test]
    fn test_parse_input() {
        let result = parse_input("  1   \n2   ");
        assert_eq!(result.len(), 2);
        assert_eq!(result[0], 1);
        assert_eq!(result[1], 2);
    }

    #[test]
    fn test_find_weak_number() {
        assert_eq!(
            find_weak_number(
                &vec![
                    35, 20, 15, 25, 47, 40, 62, 55, 65, 95, 102, 117, 150, 182, 127, 219, 299, 277,
                    309, 57
                ],
                5
            ),
            Some((127, 14))
        );

        assert_eq!(find_weak_number(&vec![35, 20, 15, 25, 47, 40, 62], 5), None);
    }

    #[test]
    fn test_find_possible_sum() {
        assert_eq!(
            find_possible_sum(
                &vec![35, 20, 15, 25, 47, 40, 62, 55, 65, 95, 102, 117, 150, 182],
                4,
                127
            ),
            Some(62)
        );

        assert_eq!(
            find_possible_sum(
                &vec![35, 20, 15, 25, 47, 40, 62, 55, 65, 95, 102, 117, 150, 182],
                3,
                127
            ),
            None
        );
    }
}

1	use itertools::Itertools;
2
3	pub fn find_weak_number_25(input: &str) -> usize {	2✔
4	let input: Vec<usize> = parse_input(input);	2✔
5
6	find_weak_number(&input, 25).unwrap_or((0, 0)).0	2✔
7	}	2✔
8
9	pub fn find_sum_of_any_numbers(input: &str) -> usize {	2✔
10	let input: Vec<usize> = parse_input(input);	2✔
11
12	if let Some((weak_number, weak_number_pos)) = find_weak_number(&input, 25) {	2!
13	(3..weak_number_pos)	×
14	.find_map(\|window_size\| {	×
15	find_possible_sum(&input[0..weak_number_pos], window_size, weak_number)	×
16	})	×
17	.unwrap_or_default()
18	} else {
19	0	2✔
20	}
21	}	2✔
22
23	fn parse_input(input: &str) -> Vec<usize> {	5✔
24	input	5✔
25	.lines()
26	.map(&str::trim)
27	.map(&str::parse::<usize>)
28	.filter_map(Result::ok)
29	.collect()
30	}	5✔
31
32	fn find_weak_number(input: &Vec<usize>, preamble: usize) -> Option<(usize, usize)> {	6✔
33	for num in preamble..input.len() {	17✔
34	let last_numbers = &input[num.saturating_sub(preamble)..num];	12✔
35
36	if last_numbers	36✔
37	.into_iter()
38	.combinations(2)
39	.find(\|pair\| pair.iter().map(\|n\| *n).sum::<usize>() == input[num])	180✔
40	.is_none()	12✔
41	{
42	return Some((input[num], num));	1✔
43	}
44	}
45
46	None	5✔
47	}	6✔
48
49	fn find_possible_sum(numbers: &[usize], window_size: usize, weak_number: usize) -> Option<usize> {	2✔
50	numbers	4✔
51	.windows(window_size)
52	.filter_map(\|window\| {	17✔
53	let sum = window.iter().sum::<usize>();	15✔
54	let min = window.iter().min();	15✔
55	let max = window.iter().max();	15✔
56
57	if sum == weak_number && min.is_some() && max.is_some() {	15✔
58	Some(min.unwrap() + max.unwrap())	1✔
59	} else {
60	None	14✔
61	}
62	})	15✔
63	.next()
64	}	2✔
65
66	#[cfg(test)]
67	mod tests {
68	use super::*;
69
70	#[test]
71	fn test_empty_answers() {	2✔
72	assert_eq!(find_weak_number_25(""), 0);	1!
73	assert_eq!(find_sum_of_any_numbers(""), 0);	1!
74	}	2✔
75
76	#[test]
77	fn test_parse_input() {	2✔
78	let result = parse_input(" 1 \n2 ");	1✔
79	assert_eq!(result.len(), 2);	1!
80	assert_eq!(result[0], 1);	1!
81	assert_eq!(result[1], 2);	1!
82	}	2✔
83
84	#[test]
85	fn test_find_weak_number() {	2✔
86	assert_eq!(	1✔
87	find_weak_number(	1✔
88	&vec![	1!
89	35, 20, 15, 25, 47, 40, 62, 55, 65, 95, 102, 117, 150, 182, 127, 219, 299, 277,
90	309, 57
91	],
92	5
93	),
94	Some((127, 14))
95	);
96
97	assert_eq!(find_weak_number(&vec![35, 20, 15, 25, 47, 40, 62], 5), None);	1!
98	}	2✔
99
100	#[test]
101	fn test_find_possible_sum() {	2✔
102	assert_eq!(	1✔
103	find_possible_sum(	1✔
104	&vec![35, 20, 15, 25, 47, 40, 62, 55, 65, 95, 102, 117, 150, 182],	1!
105	4,
106	127
107	),
108	Some(62)
109	);
110
111	assert_eq!(	1✔
112	find_possible_sum(	1✔
113	&vec![35, 20, 15, 25, 47, 40, 62, 55, 65, 95, 102, 117, 150, 182],	1!
114	3,
115	127
116	),
117	None
118	);
119	}	2✔
120	}

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