Solved day 17 of 2021

Author: marcdejonge

2021/input/day17.txt

@@ -0,0 +1 @@
+target area: x=240..292, y=-90..-57

2021/input/day17_example.txt

@@ -0,0 +1 @@
+target area: x=20..30, y=-10..-5

2021/src/bin/day17.rs

@@ -0,0 +1,85 @@
+#![feature(test)]
+
+use advent_lib::{parsing::range_inclusive, *};
+use fxhash::{FxHashMap, FxHashSet};
+use nom_parse_macros::parse_from;
+use std::{cmp::max, ops::RangeInclusive};
+
+#[parse_from(preceded("target area: ", (preceded("x=", range_inclusive(i32, "..")), preceded(", y=", range_inclusive(i32, "..")))))]
+struct Input {
+    x_range: RangeInclusive<i32>,
+    y_range: RangeInclusive<i32>,
+}
+
+fn calculate_part1(input: &Input) -> i32 {
+    let dy = -input.y_range.start() - 1;
+    (dy * (dy + 1)) / 2
+}
+
+fn calculate_part2(input: &Input) -> usize {
+    let mut vx_start_times = FxHashMap::<i32, RangeInclusive<i32>>::default();
+
+    for vx_start in 1..=*input.x_range.end() {
+        let mut vx = vx_start;
+        let mut x = 0;
+        let mut min_time = None;
+        for time in 1.. {
+            x += vx;
+            vx = max(0, vx - 1);
+            if x < *input.x_range.start() {
+                if vx == 0 {
+                    break;
+                } else {
+                    continue;
+                }
+            } else if x > *input.x_range.end() {
+                if let Some(min_time) = min_time {
+                    vx_start_times.insert(vx_start, min_time..=(time - 1));
+                }
+                break;
+            } else if min_time.is_none() {
+                min_time = Some(time);
+            } else if vx == 0 {
+                if let Some(min_time) = min_time {
+                    vx_start_times.insert(vx_start, min_time..=i32::MAX);
+                }
+                break;
+            }
+        }
+    }
+
+    let mut speeds = FxHashSet::<(i32, i32)>::default();
+    for vy_start in *input.y_range.start()..(-*input.y_range.start()) {
+        // This is time spend in the air before crossing crossing the 0 line again
+        let (mut y, mut vy, extra_time) = if vy_start > 0 {
+            (0, -vy_start - 1, vy_start * 2 + 1)
+        } else {
+            (0, vy_start, 0)
+        };
+
+        for time in (extra_time + 1).. {
+            y += vy;
+            vy -= 1;
+            if y > *input.y_range.end() {
+                continue;
+            } else if y < *input.y_range.start() {
+                break; // We passed the area, no use looking further
+            } else {
+                // Found a time that works, now find the related vx_start values
+                vx_start_times
+                    .iter()
+                    .filter(|(_, range)| range.contains(&time))
+                    .for_each(|(vx_start, _)| {
+                        speeds.insert((*vx_start, vy_start));
+                    });
+            }
+        }
+    }
+
+    speeds.len()
+}
+
+day_main!(Input);
+
+day_test!( 17, example => 45, 112 );
+day_test!( 17 => 4005, 2953 );

shared/src/parsing.rs

@@ -9,6 +9,7 @@ use nom::{AsBytes, AsChar, Compare, Err, Finish, IResult, Input, Parser};
 use nom_parse_trait::ParseFrom;
 use smallvec::SmallVec;
 use std::hash::Hash;
+use std::ops::RangeInclusive;
 
 pub fn handle_parser_error<T>(input: &[u8]) -> T
 where
@@ -49,16 +50,16 @@ pub fn find_many_skipping_unknown<I: Input, E: ParseError<I>, T: ParseFrom<I, E>
     }
 }
 
-pub fn many_1_n<const MAX: usize, Input, Output, Error, ParserFunction>(
+pub fn many_1_n<const MAX: usize, I, Output, E, ParserFunction>(
     mut parser: ParserFunction,
-) -> impl FnMut(Input) -> IResult<Input, SmallVec<[Output; MAX]>, Error>
+) -> impl Parser<I, Output = SmallVec<[Output; MAX]>, Error = E>
 where
-    Input: nom::Input,
-    ParserFunction: Parser<Input, Output = Output, Error = Error>,
-    Error: ParseError<Input>,
+    I: Input,
+    ParserFunction: Parser<I, Output = Output, Error = E>,
+    E: ParseError<I>,
     [Output; MAX]: smallvec::Array<Item = Output>,
 {
-    move |mut input: Input| {
+    move |mut input: I| {
         let mut result = SmallVec::new();
         while result.len() < MAX {
             let input_len_before = input.input_len();
@@ -68,10 +69,10 @@ where
                 Ok((next_input, output)) => {
                     // infinite loop check: the parser must always consume
                     if next_input.input_len() == input_len_before {
-                        return Err(Err::Error(Error::from_error_kind(input, ErrorKind::Many1)));
+                        return Err(Err::Error(E::from_error_kind(input, ErrorKind::Many1)));
                     }
                     if result.len() == MAX {
-                        return Err(Err::Error(Error::from_error_kind(input, ErrorKind::ManyMN)));
+                        return Err(Err::Error(E::from_error_kind(input, ErrorKind::ManyMN)));
                     }
 
                     input = next_input;
@@ -355,3 +356,19 @@ fn hex_decode(c: char) -> Option<u8> {
         _ => None,
     }
 }
+
+pub fn range_inclusive<I, E: ParseError<I>, T, F, G>(
+    value: F,
+    separator: G,
+) -> impl Parser<I, Output = RangeInclusive<T>, Error = E>
+where
+    F: Parser<I, Output = T, Error = E> + Clone,
+    G: Parser<I, Error = E>,
+    I: Input,
+    <I as Input>::Item: AsChar,
+    for<'a> I: Compare<&'a [u8]>,
+{
+    map(separated_pair(value.clone(), separator, value), |(l, r)| {
+        l..=r
+    })
+}