Day 01

Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "executor"
+version = "0.0.0"
+authors = ["Anthony Cicchetti <anthony@anthonycicchetti.com>"]
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+clap = "2.33.3"
+day_01 = { path = "./day_01" }
+
+[workspace]
+members = [
+    'day_01',
+]

day_01/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "day_01"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+itertools = "*"

day_01/src/lib.rs

@@ -0,0 +1,110 @@
+use itertools::Itertools;
+
+fn input_parse(input: &str) -> Vec<u32> {
+    input
+        .split_whitespace()
+        .map(|t|
+            t.parse::<u32>()
+                .expect(&format!("Could not parse {} into u32", &t))
+        )
+        .collect::<Vec<_>>()
+}
+
+/// As the submarine drops below the surface of the ocean, it automatically performs a sonar sweep of the nearby sea floor. On a small screen, the sonar sweep report (your puzzle input) appears: each line is a measurement of the sea floor depth as the sweep looks further and further away from the submarine.
+///
+/// For example, suppose you had the following report:
+///
+/// 199
+/// 200
+/// 208
+/// 210
+/// 200
+/// 207
+/// 240
+/// 269
+/// 260
+/// 263
+///
+/// This report indicates that, scanning outward from the submarine, the sonar sweep found depths of 199, 200, 208, 210, and so on.
+///
+/// The first order of business is to figure out how quickly the depth increases, just so you know what you're dealing with - you never know if the keys will get carried into deeper water by an ocean current or a fish or something.
+///
+/// To do this, count the number of times a depth measurement increases from the previous measurement. (There is no measurement before the first measurement.) In the example above, the changes are as follows:
+///
+/// > 199 (N/A - no previous measurement)
+/// >
+/// > 200 (**increased**)
+/// >
+/// > 208 (**increased**)
+/// >
+/// > 210 (**increased**)
+/// >
+/// > 200 (decreased)
+/// >
+/// > 207 (**increased**)
+/// >
+/// > 240 (**increased**)
+/// >
+/// > 269 (**increased**)
+/// >
+/// > 260 (decreased)
+/// >
+/// > 263 (**increased**)
+///
+/// In this example, there are 7 measurements that are larger than the previous measurement.
+///
+pub fn part1(input: &str) -> u32 {
+    let input = input_parse(input);
+
+    input.iter()
+        .tuple_windows::<(_,_)>()
+        .fold(0, |acc, inp| { if inp.0 < inp.1 { acc + 1 } else { acc }})
+}
+
+///
+/// Considering every single measurement isn't as useful as you expected: there's just too much noise in the data.
+///
+/// Instead, consider sums of a three-measurement sliding window. Again considering the above example:
+///
+/// ```text
+/// 199  A
+/// 200  A B
+/// 208  A B C
+/// 210    B C D
+/// 200  E   C D
+/// 207  E F   D
+/// 240  E F G
+/// 269    F G H
+/// 260      G H
+/// 263        H
+/// ```
+///
+/// Start by comparing the first and second three-measurement windows. The measurements in the first window are marked A (199, 200, 208); their sum is 199 + 200 + 208 = 607. The second window is marked B (200, 208, 210); its sum is 618. The sum of measurements in the second window is larger than the sum of the first, so this first comparison increased.
+///
+/// Your goal now is to count the number of times the sum of measurements in this sliding window increases from the previous sum. So, compare A with B, then compare B with C, then C with D, and so on. Stop when there aren't enough measurements left to create a new three-measurement sum.
+///
+/// In the above example, the sum of each three-measurement window is as follows:
+///
+/// ```text
+/// A: 607 (N/A - no previous sum)
+/// B: 618 (increased)
+/// C: 618 (no change)
+/// D: 617 (decreased)
+/// E: 647 (increased)
+/// F: 716 (increased)
+/// G: 769 (increased)
+/// H: 792 (increased)
+/// ```
+///
+/// In this example, there are 5 sums that are larger than the previous sum.
+///
+/// Consider sums of a three-measurement sliding window. How many sums are larger than the previous sum?
+///
+pub fn part2(input: &str) -> u32 {
+    let input = input_parse(input);
+    input.iter()
+        .tuple_windows::<(_,_,_)>()
+        .map(|(a,b,c) | a + b + c)
+        .tuple_windows::<(_,_)>()
+        .fold(0, |acc, inp| if inp.0 < inp.1 { acc + 1 } else { acc } )
+}

src/main.rs

@@ -0,0 +1,52 @@
+extern crate clap;
+
+use std::error::Error;
+use std::fs::File;
+use std::io::{BufReader, Read};
+use clap::{arg_enum, clap_app, value_t};
+
+arg_enum! {
+    #[derive(Debug)]
+    enum DaysImplemented {
+        Day1,
+    }
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let matches = clap_app!(AdventOfCode2021 =>
+        (author: "Anthony Cicchetti")
+        (@setting ArgRequiredElseHelp)
+        (@arg day_to_execute: -d --day * +takes_value possible_values(&DaysImplemented::variants()))
+        (@arg part: -p --part * +takes_value possible_values(&["1", "2"]))
+        (@arg input_file: -f --file {file_exists} * conflicts_with[input_string] +takes_value "Input file")
+        (@arg input_string: required_unless[input_file] "Input string")
+    ).get_matches();
+    let day: DaysImplemented =
+        value_t!(matches.value_of("day_to_execute"), DaysImplemented).unwrap(); // Safe unwrap because value is required
+    let part = value_t!(matches.value_of("part"), u8).unwrap();
+    let input = match matches.value_of("input_file") {
+        None => value_t!(matches.value_of("input_string"), String).unwrap(),
+        Some(path) => {
+            let mut s = String::new();
+            let _ = BufReader::new(File::open(path)?).read_to_string(&mut s);
+            s
+        }
+    };
+
+    println!("Executing {}, Part {}", day, part);
+    match (day, part) {
+        (DaysImplemented::Day1, 1) => println!("{}", day_01::part1(&input)),
+        (DaysImplemented::Day1, 2) => println!("{}", day_01::part2(&input)),
+        _ => {unimplemented!()}
+    };
+
+    Ok(())
+}
+
+fn file_exists(val: String) -> Result<(), String> {
+    if std::fs::metadata(&val).is_ok() {
+        Ok(())
+    } else {
+        Err(String::from(format!("File at {} doesn't exist", &val)))
+    }
+}