From cc1cb04b337c18d9ccc180ddcc4b5076c9721b89 Mon Sep 17 00:00:00 2001 From: Daniel Seiller Date: Fri, 11 Dec 2020 01:33:19 +0100 Subject: [PATCH] Day 10 + rename old files for proper sorting --- src/{day1.rs => day01.rs} | 0 src/{day2.rs => day02.rs} | 0 src/{day3.rs => day03.rs} | 0 src/{day4.rs => day04.rs} | 0 src/{day5.rs => day05.rs} | 0 src/{day6.rs => day06.rs} | 0 src/{day7.rs => day07.rs} | 3 ++ src/{day8.rs => day08.rs} | 3 ++ src/{day9.rs => day09.rs} | 12 +++-- src/day10.rs | 100 ++++++++++++++++++++++++++++++++++++++ src/lib.rs | 19 ++++---- 11 files changed, 124 insertions(+), 13 deletions(-) rename src/{day1.rs => day01.rs} (100%) rename src/{day2.rs => day02.rs} (100%) rename src/{day3.rs => day03.rs} (100%) rename src/{day4.rs => day04.rs} (100%) rename src/{day5.rs => day05.rs} (100%) rename src/{day6.rs => day06.rs} (100%) rename src/{day7.rs => day07.rs} (97%) rename src/{day8.rs => day08.rs} (98%) rename src/{day9.rs => day09.rs} (84%) create mode 100644 src/day10.rs diff --git a/src/day1.rs b/src/day01.rs similarity index 100% rename from src/day1.rs rename to src/day01.rs diff --git a/src/day2.rs b/src/day02.rs similarity index 100% rename from src/day2.rs rename to src/day02.rs diff --git a/src/day3.rs b/src/day03.rs similarity index 100% rename from src/day3.rs rename to src/day03.rs diff --git a/src/day4.rs b/src/day04.rs similarity index 100% rename from src/day4.rs rename to src/day04.rs diff --git a/src/day5.rs b/src/day05.rs similarity index 100% rename from src/day5.rs rename to src/day05.rs diff --git a/src/day6.rs b/src/day06.rs similarity index 100% rename from src/day6.rs rename to src/day06.rs diff --git a/src/day7.rs b/src/day07.rs similarity index 97% rename from src/day7.rs rename to src/day07.rs index caa0b98..989999d 100644 --- a/src/day7.rs +++ b/src/day07.rs @@ -16,6 +16,7 @@ impl Data { } #[aoc_generator(day7)] +#[inline(always)] pub fn input_generator(input: &str) -> Data { let mut ret = Data::new(); for line in input.lines() { @@ -51,6 +52,7 @@ pub fn input_generator(input: &str) -> Data { } #[aoc(day7, part1)] +#[inline(always)] pub fn solve_part1(input: &Data) -> usize { let mut cnt = 0; let mut q = VecDeque::new(); @@ -65,6 +67,7 @@ pub fn solve_part1(input: &Data) -> usize { } #[aoc(day7, part2)] +#[inline(always)] pub fn solve_part2(input: &Data) -> usize { let mut cnt = 0; let mut q = VecDeque::new(); diff --git a/src/day8.rs b/src/day08.rs similarity index 98% rename from src/day8.rs rename to src/day08.rs index a092b6d..6040944 100644 --- a/src/day8.rs +++ b/src/day08.rs @@ -81,11 +81,13 @@ impl CPU { } #[aoc_generator(day8)] +#[inline(always)] pub fn input_generator(input: &str) -> Vec { input.trim().lines().map(|l| Inst::from(l.trim())).collect() } #[aoc(day8, part1)] +#[inline(always)] pub fn solve_part1(input: &Vec) -> usize { let mut seen = HashSet::new(); let mut cpu = CPU::new(input); @@ -100,6 +102,7 @@ pub fn solve_part1(input: &Vec) -> usize { } #[aoc(day8, part2)] +#[inline(always)] pub fn solve_part2(input: &Vec) -> usize { for (idx, inst) in input.iter().enumerate() { match inst { diff --git a/src/day9.rs b/src/day09.rs similarity index 84% rename from src/day9.rs rename to src/day09.rs index 4e726b5..f1242ac 100644 --- a/src/day9.rs +++ b/src/day09.rs @@ -1,6 +1,7 @@ use aoc_runner_derive::{aoc, aoc_generator}; #[aoc_generator(day9)] +#[inline(always)] pub fn input_generator(input: &str) -> Vec { input .lines() @@ -10,6 +11,7 @@ pub fn input_generator(input: &str) -> Vec { } #[aoc(day9, part1)] +#[inline(always)] pub fn solve_part1(input: &Vec) -> usize { for (n, win) in input.as_slice().windows(25).enumerate() { let n = n + 25; @@ -35,7 +37,8 @@ pub fn solve_part1(input: &Vec) -> usize { panic!("No match found!"); } -#[aoc(day9, part2,bruteforce)] +#[aoc(day9, part2, bruteforce)] +#[inline(always)] pub fn solve_part2(input: &Vec) -> usize { let inv_num = solve_part1(input); for start in 0..input.len() { @@ -49,12 +52,13 @@ pub fn solve_part2(input: &Vec) -> usize { panic!("No match found!"); } -#[aoc(day9, part2,faster)] +#[aoc(day9, part2, faster)] +#[inline(always)] pub fn solve_part2_fast(input: &Vec) -> usize { let target_num = solve_part1(input); for i in 2..=input.len() { - if let Some(w) = input.windows(i).find(|w| target_num==w.iter().sum()) { - return w.iter().max().unwrap()+w.iter().min().unwrap(); + if let Some(w) = input.windows(i).find(|w| target_num == w.iter().sum()) { + return w.iter().max().unwrap() + w.iter().min().unwrap(); } } panic!("No match found!"); diff --git a/src/day10.rs b/src/day10.rs new file mode 100644 index 0000000..27fdbce --- /dev/null +++ b/src/day10.rs @@ -0,0 +1,100 @@ +use aoc_runner_derive::{aoc, aoc_generator}; +use std::iter::FromIterator; +use std::{ + collections::{HashMap, HashSet, VecDeque}, + ops::{Sub, SubAssign}, +}; +#[derive(Debug, Eq, PartialEq, Clone)] +struct SearchState { + available: HashSet, + node: u16, +} + +fn solve_part_2_rec( + node: u16, + goal: u16, + map: &HashMap>, + used: &HashSet, + cache: &mut HashMap<(u16, u16), usize>, +) -> usize { + if node == goal { + return 1; + } + let mut ret = 0; + let mut used = used.clone(); + // println!("+{}", node); + for next in map.get(&node).iter().map(|v| v.iter()).flatten() { + if !used.insert(*next) { + continue; + }; + let value = match cache.get(&(node, *next)) { + Some(value) => *value, + None => { + let value = solve_part_2_rec(*next, goal, map, &used, cache); + cache.insert((node, *next), value); + value + } + }; + ret += value; + used.remove(next); + } + // println!("-{}", node); + ret +} +pub struct Data(pub Vec); +impl Data { + #[inline(always)] + fn count_paths(&self) -> usize { + let mut nodes = self.0.clone(); + nodes.push(0); + nodes.push(nodes.iter().max().unwrap() + 3); + nodes.sort(); + let goal = *nodes.last().unwrap(); + let mut map: HashMap> = HashMap::new(); + for n in &nodes { + for v in &nodes { + let d = v - n; + if d > 0 && d < 4 { + map.entry(*n).or_default().insert(*v); + } + } + } + return solve_part_2_rec(0, goal, &map, &HashSet::new(), &mut HashMap::new()); + } +} + +#[aoc_generator(day10)] +pub fn input_generator(input: &str) -> Data { + let mut numbers = input + .lines() + .map(|l| l.trim().parse()) + .collect::, _>>() + .unwrap(); + numbers.sort_unstable(); + return Data(numbers); +} + +#[aoc(day10, part1)] +#[inline(always)] +pub fn solve_part1(input: &Data) -> usize { + let mut n_1 = 0; + let mut n_3 = 0; + let mut nums = input.0.clone(); + nums.push(0); + nums.push(nums.iter().max().unwrap() + 3); + nums.sort_unstable(); + for w in nums.windows(2) { + match w[1] - w[0] { + 1 => n_1 += 1, + 3 => n_3 += 1, + _ => (), + } + } + return n_1 * n_3; +} + +#[aoc(day10, part2)] +#[inline(always)] +pub fn solve_part2(input: &Data) -> usize { + return input.count_paths(); +} diff --git a/src/lib.rs b/src/lib.rs index 52cb170..c3798d3 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,11 +1,12 @@ use aoc_runner_derive::aoc_lib; -pub mod day1; -pub mod day2; -pub mod day3; -pub mod day4; -pub mod day5; -pub mod day6; -pub mod day7; -pub mod day8; -pub mod day9; +pub mod day01; +pub mod day02; +pub mod day03; +pub mod day04; +pub mod day05; +pub mod day06; +pub mod day07; +pub mod day08; +pub mod day09; +pub mod day10; aoc_lib! { year = 2020 }