Initial Commit

.gitignore

@@ -0,0 +1,95 @@
+### Rust template
+# Generated by Cargo
+# will have compiled files and executables
+debug/
+target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
+Cargo.lock
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb
+
+### JetBrains template
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/advent_of_code_2022.iml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="CPP_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/cli/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/common/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/day_01/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/day_02/src" isTestSource="false" />
+      <excludeFolder url="file://$MODULE_DIR$/target" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/git_toolbox_prj.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GitToolBoxProjectSettings">
+    <option name="commitMessageIssueKeyValidationOverride">
+      <BoolValueOverride>
+        <option name="enabled" value="true" />
+      </BoolValueOverride>
+    </option>
+    <option name="commitMessageValidationEnabledOverride">
+      <BoolValueOverride>
+        <option name="enabled" value="true" />
+      </BoolValueOverride>
+    </option>
+  </component>
+</project>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="RsExperimentalChecks" enabled="true" level="ERROR" enabled_by_default="true" />
+  </profile>
+</component>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/advent_of_code_2022.iml" filepath="$PROJECT_DIR$/.idea/advent_of_code_2022.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

Cargo.toml

@@ -0,0 +1,2 @@
+[workspace]
+members = ['common', 'cli', 'day_01', 'day_02']

cli/.gitignore

@@ -0,0 +1 @@
+/target

cli/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "cli"
+version = "0.0.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+clap = { version = "4.0", features = ["derive"] }
+day_01 = { path = "../day_01"}
+day_02 = { path = "../day_02"}
+common = { path = "../common"}

cli/src/main.rs

@@ -0,0 +1,65 @@
+use std::error::Error;
+use std::fs;
+use std::path::Path;
+
+use clap::{ArgGroup, Parser};
+use common::{Day, Part};
+
+#[derive(Parser, Debug)]
+#[command(about)]
+#[command(group(
+ArgGroup::new("input")
+.required(true)
+.args(["input_file", "input_str"])
+))]
+struct Args {
+    #[arg(short, long)]
+    day: Day,
+
+    #[arg(short, long)]
+    part: Part,
+
+    #[arg(short = 'f', long)]
+    input_file: Option<String>,
+
+    input_str: Option<String>,
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli = Args::parse();
+
+    let input_str = if let Some(inp) = cli.input_file.as_deref() {
+        fs::read_to_string(Path::new(inp))?
+    } else {
+        cli.input_str.unwrap()
+    };
+
+    match (cli.day, cli.part) {
+        (day @ Day::One, part @ Part::One) => {
+            println!("{}", day_01::run_day_and_part(day, part, input_str));
+            Ok(())
+        }
+        (day @ Day::One, part @ Part::Two) => {
+            println!("{}", day_01::run_day_and_part(day, part, input_str));
+            Ok(())
+        }
+        (day @ Day::Two, part @ Part::One) => {
+            println!(
+                "{}",
+                day_02::run_day_and_part(day, part, input_str.as_str())
+            );
+            Ok(())
+        }
+        (day @ Day::Two, part @ Part::Two) => {
+            println!(
+                "{}",
+                day_02::run_day_and_part(day, part, input_str.as_str())
+            );
+            Ok(())
+        }
+
+        (_, _) => {
+            unimplemented!()
+        }
+    }
+}

common/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "common"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+clap = { version = "4.0.29", features = ["derive", "unicode"] }

common/src/lib.rs

@@ -0,0 +1,13 @@
+use clap::ValueEnum;
+
+#[derive(ValueEnum, Clone, Copy, Debug)]
+pub enum Day {
+    One,
+    Two,
+}
+
+#[derive(ValueEnum, Copy, Clone, Debug)]
+pub enum Part {
+    One,
+    Two,
+}

day_01/.gitignore

@@ -0,0 +1,2 @@
+/target
+/Cargo.lock

day_01/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "day_01"
+version = "0.0.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+common = {path = "../common"}
+nom = "7.1.1"

day_01/src/lib.rs

@@ -0,0 +1,18 @@
+mod parser;
+
+use common::{Day, Part};
+
+use parser::parse;
+
+pub fn run_day_and_part(day: Day, part: Part, inp: String) -> usize {
+    match (day, part) {
+        (Day::One, Part::One) => *parse(inp).iter().max().unwrap(),
+        (Day::One, Part::Two) => {
+            let mut res = parse(inp);
+            res.sort();
+            res.reverse();
+            res[..3].iter().sum()
+        }
+        (_, _) => 0,
+    }
+}

day_01/src/parser.rs

@@ -0,0 +1,61 @@
+use nom::character::complete::{digit1, line_ending};
+use nom::combinator::map_res;
+use nom::multi::{count, separated_list0, separated_list1};
+use nom::IResult;
+
+fn elf_parser(s: &str) -> IResult<&str, usize> {
+    let (rest, matched): (&str, Vec<usize>) = separated_list0(line_ending, get_digits)(s)?;
+    Ok((rest, matched.iter().sum()))
+}
+
+fn get_digits(s: &str) -> IResult<&str, usize> {
+    map_res(digit1, str::parse::<usize>)(s)
+}
+
+fn all_elf_parse(inp: &str) -> IResult<&str, Vec<usize>> {
+    separated_list1(count(line_ending, 2), elf_parser)(inp)
+}
+
+pub fn parse(inp: String) -> Vec<usize> {
+    if let Ok((_, elves)) = all_elf_parse(&inp) {
+        elves.clone()
+    } else {
+        panic!()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_digits() {
+        assert_eq!(Ok(("", 123)), get_digits("123"));
+    }
+
+    #[test]
+    fn test_one_line_make_elf() {
+        assert_eq!(Ok(("", 123)), elf_parser("123"))
+    }
+
+    #[test]
+    fn test_multiline_make_elf() {
+        assert_eq!(Ok(("", 1368)), elf_parser("123\n456\n789"))
+    }
+
+    #[test]
+    fn test_multiple_elf() {
+        assert_eq!(
+            Ok(("\n\n123\n123", 1368)),
+            elf_parser("123\n456\n789\n\n123\n123")
+        )
+    }
+
+    #[test]
+    fn test_multiple_elf_parsed() {
+        assert_eq!(
+            Ok(("", vec![1368, 246])),
+            all_elf_parse("123\n456\n789\n\n123\n123")
+        )
+    }
+}

day_02/.gitignore

@@ -0,0 +1,2 @@
+/target
+/Cargo.lock

day_02/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "day_02"
+version = "0.0.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+nom = "7.1.1"
+common = { path = '../common' }

day_02/src/lib.rs

@@ -0,0 +1,21 @@
+mod parser;
+
+use common::{Day, Part};
+
+pub fn run_day_and_part(day: Day, part: Part, inp: &str) -> usize {
+    match (day, part) {
+        (Day::Two, Part::One) => parser::part_01::parse(inp).iter().sum(),
+        (Day::Two, Part::Two) => parser::part_02::parse(inp).iter().sum(),
+        (_, _) => unimplemented!(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn example_score_is_correct() {
+        assert_eq!(15, run_day_and_part(Day::Two, Part::One, "A Y\nB X\nC Z"))
+    }
+}

day_02/src/parser.rs

@@ -0,0 +1,211 @@
+use nom::branch::alt;
+use nom::character::complete::char;
+use nom::IResult;
+
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)]
+pub struct Trick {
+    thrown: Hand,
+    against: Hand,
+}
+
+impl From<(Hand, Hand)> for Trick {
+    fn from(value: (Hand, Hand)) -> Self {
+        Self {
+            thrown: value.1,
+            against: value.0,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)]
+enum Hand {
+    Rock,
+    Paper,
+    Scissors,
+}
+
+const WIN: usize = 6;
+const TIE: usize = 3;
+const LOSS: usize = 0;
+
+impl Trick {
+    fn score(&self) -> usize {
+        let mut score = 0;
+        match &self.thrown {
+            Hand::Rock => score += 1,
+            Hand::Paper => score += 2,
+            Hand::Scissors => score += 3,
+        };
+        match (&self.thrown, &self.against) {
+            (Hand::Rock, Hand::Rock) => score += TIE,
+            (Hand::Rock, Hand::Paper) => score += LOSS,
+            (Hand::Rock, Hand::Scissors) => score += WIN,
+            (Hand::Paper, Hand::Rock) => score += WIN,
+            (Hand::Paper, Hand::Paper) => score += TIE,
+            (Hand::Paper, Hand::Scissors) => score += LOSS,
+            (Hand::Scissors, Hand::Rock) => score += LOSS,
+            (Hand::Scissors, Hand::Paper) => score += WIN,
+            (Hand::Scissors, Hand::Scissors) => score += TIE,
+        }
+        score
+    }
+}
+
+fn rock_against(s: &str) -> IResult<&str, Hand> {
+    let (rest, _) = char('A')(s)?;
+    Ok((rest, Hand::Rock))
+}
+
+fn paper_against(s: &str) -> IResult<&str, Hand> {
+    let (rest, _) = char('B')(s)?;
+    Ok((rest, Hand::Paper))
+}
+fn scissors_against(s: &str) -> IResult<&str, Hand> {
+    let (rest, _) = char('C')(s)?;
+    Ok((rest, Hand::Scissors))
+}
+
+fn against_hand_parser(s: &str) -> IResult<&str, Hand> {
+    alt((rock_against, paper_against, scissors_against))(s)
+}
+
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)]
+enum ResultExpected {
+    Win,
+    Lose,
+    Draw,
+}
+
+fn loss_expected(s: &str) -> IResult<&str, ResultExpected> {
+    let (rest, _) = char('X')(s)?;
+    Ok((rest, ResultExpected::Lose))
+}
+fn draw_expected(s: &str) -> IResult<&str, ResultExpected> {
+    let (rest, _) = char('Y')(s)?;
+    Ok((rest, ResultExpected::Draw))
+}
+fn win_expected(s: &str) -> IResult<&str, ResultExpected> {
+    let (rest, _) = char('Z')(s)?;
+    Ok((rest, ResultExpected::Win))
+}
+
+fn result_expected_parser(s: &str) -> IResult<&str, ResultExpected> {
+    alt((loss_expected, draw_expected, win_expected))(s)
+}
+
+impl From<(Hand, ResultExpected)> for Trick {
+    fn from(value: (Hand, ResultExpected)) -> Self {
+        match value.1 {
+            ResultExpected::Win => match value.0 {
+                against @ Hand::Rock => Trick {
+                    against,
+                    thrown: Hand::Paper,
+                },
+                against @ Hand::Paper => Trick {
+                    against,
+                    thrown: Hand::Scissors,
+                },
+                against @ Hand::Scissors => Trick {
+                    against,
+                    thrown: Hand::Rock,
+                },
+            },
+            ResultExpected::Lose => match value.0 {
+                against @ Hand::Rock => Trick {
+                    against,
+                    thrown: Hand::Scissors,
+                },
+                against @ Hand::Paper => Trick {
+                    against,
+                    thrown: Hand::Rock,
+                },
+                against @ Hand::Scissors => Trick {
+                    against,
+                    thrown: Hand::Paper,
+                },
+            },
+            ResultExpected::Draw => match value.0 {
+                against @ Hand::Rock => Trick {
+                    against,
+                    thrown: against,
+                },
+                against @ Hand::Paper => Trick {
+                    against,
+                    thrown: against,
+                },
+                against @ Hand::Scissors => Trick {
+                    against,
+                    thrown: against,
+                },
+            },
+        }
+    }
+}
+
+pub(crate) mod part_02 {
+    use crate::parser::{against_hand_parser, result_expected_parser, Hand, ResultExpected, Trick};
+    use nom::character::complete::{char, line_ending};
+    use nom::multi::separated_list1;
+    use nom::sequence::separated_pair;
+    use nom::IResult;
+
+    fn trick_parser(s: &str) -> IResult<&str, Trick> {
+        let (rest, hands): (&str, (Hand, ResultExpected)) =
+            separated_pair(against_hand_parser, char(' '), result_expected_parser)(s)?;
+        Ok((rest, hands.into()))
+    }
+
+    fn sequence_parser(s: &str) -> IResult<&str, Vec<Trick>> {
+        separated_list1(line_ending, trick_parser)(s)
+    }
+
+    pub(crate) fn parse(inp: &str) -> Vec<usize> {
+        todo!()
+    }
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+        use crate::parser::{draw_expected, loss_expected, win_expected};
+
+        #[test]
+        fn win_expected_parsed() {
+            assert_eq!(Ok(("", ResultExpected::Win)), win_expected("Z"))
+        }
+        #[test]
+        fn draw_expected_parsed() {
+            assert_eq!(Ok(("", ResultExpected::Draw)), draw_expected("Y"))
+        }
+        #[test]
+        fn loss_expected_parsed() {
+            assert_eq!(Ok(("", ResultExpected::Lose)), loss_expected("X"))
+        }
+
+        macro_rules! param_test {
+            ($name:ident, $input:literal, $against:expr, $result:expr, $thrown:expr) => {
+                #[test]
+                fn $name() {
+                    assert_eq!(
+                        Ok((
+                            "",
+                            Trick {
+                                thrown: $thrown,
+                                against: $against
+                            }
+                        )),
+                        trick_parser($input)
+                    )
+                }
+            };
+        }
+
+        param_test!(
+            rock_thrown_loss_expected,
+            "A X",
+            Hand::Rock,
+            ResultExpected::Lose,
+            Hand::Scissors
+        );
+    }
+}
+
+pub(crate) mod part_01;

day_02/src/parser/part_01.rs

@@ -0,0 +1,136 @@
+use crate::parser::{
+    against_hand_parser, paper_against, rock_against, scissors_against, Hand, Trick,
+};
+use nom::branch::alt;
+use nom::character::complete::{char, line_ending};
+use nom::multi::separated_list1;
+use nom::sequence::separated_pair;
+use nom::IResult;
+
+fn rock_thrown(s: &str) -> IResult<&str, Hand> {
+    let (rest, _) = char('X')(s)?;
+    Ok((rest, Hand::Rock))
+}
+
+fn paper_thrown(s: &str) -> IResult<&str, Hand> {
+    let (rest, _) = char('Y')(s)?;
+    Ok((rest, Hand::Paper))
+}
+
+fn scissors_thrown(s: &str) -> IResult<&str, Hand> {
+    let (rest, _) = char('Z')(s)?;
+    Ok((rest, Hand::Scissors))
+}
+
+fn thrown_hand_parser(s: &str) -> IResult<&str, Hand> {
+    alt((rock_thrown, paper_thrown, scissors_thrown))(s)
+}
+
+fn trick_parser(s: &str) -> IResult<&str, Trick> {
+    let (rest, hands): (&str, (Hand, Hand)) =
+        separated_pair(against_hand_parser, char(' '), thrown_hand_parser)(s)?;
+    Ok((rest, hands.into()))
+}
+
+fn sequence_parser(s: &str) -> IResult<&str, Vec<Trick>> {
+    separated_list1(line_ending, trick_parser)(s)
+}
+
+pub(crate) fn parse(inp: &str) -> Vec<usize> {
+    let (_, tricks): (&str, Vec<Trick>) = sequence_parser(inp).expect("Couldn't parse input");
+    tricks.iter().map(|trick| trick.score()).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn against_rock_parsed() {
+        assert_eq!(Ok(("", Hand::Rock)), rock_against("A"))
+    }
+    #[test]
+    fn thrown_rock_parsed() {
+        assert_eq!(Ok(("", Hand::Rock)), rock_thrown("X"))
+    }
+
+    // Idea stolen from https://stackoverflow.com/a/34666891
+    macro_rules! param_test {
+        ($name:ident, $input:literal, $against:expr, $thrown:expr) => {
+            #[test]
+            fn $name() {
+                assert_eq!(
+                    Ok((
+                        "",
+                        Trick {
+                            thrown: $thrown,
+                            against: $against
+                        }
+                    )),
+                    trick_parser($input)
+                )
+            }
+        };
+    }
+
+    param_test!(rock_against_rock_thrown, "A X", Hand::Rock, Hand::Rock);
+    param_test!(rock_against_paper_thrown, "A Y", Hand::Rock, Hand::Paper);
+    param_test!(
+        rock_against_scissors_thrown,
+        "A Z",
+        Hand::Rock,
+        Hand::Scissors
+    );
+
+    param_test!(paper_against_rock_thrown, "B X", Hand::Paper, Hand::Rock);
+    param_test!(paper_against_paper_thrown, "B Y", Hand::Paper, Hand::Paper);
+    param_test!(
+        paper_against_scissors_thrown,
+        "B Z",
+        Hand::Paper,
+        Hand::Scissors
+    );
+
+    param_test!(
+        scissors_against_rock_thrown,
+        "C X",
+        Hand::Scissors,
+        Hand::Rock
+    );
+    param_test!(
+        scissors_against_paper_thrown,
+        "C Y",
+        Hand::Scissors,
+        Hand::Paper
+    );
+    param_test!(
+        scissors_against_scissors_thrown,
+        "C Z",
+        Hand::Scissors,
+        Hand::Scissors
+    );
+
+    #[test]
+    fn example_sequence_parsed() {
+        assert_eq!(
+            Ok((
+                "",
+                vec![
+                    Trick {
+                        thrown: Hand::Paper,
+                        against: Hand::Rock
+                    },
+                    Trick {
+                        against: Hand::Paper,
+                        thrown: Hand::Rock
+                    },
+                    Trick {
+                        against: Hand::Scissors,
+                        thrown: Hand::Scissors
+                    }
+                ]
+            )),
+            sequence_parser("A Y\nB X\nC Z")
+        )
+    }
+}