2022/data/day2.expected

@@ -1,2 +0,0 @@
-12458
-12683

2022/day2/rust/Cargo.toml

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

2022/day2/rust/src/main.rs

@@ -1,130 +0,0 @@
-use core::fmt;
-use std::{
-    io::{stdin, Read},
-    str::FromStr,
-};
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-enum Rps {
-    Rock,
-    Paper,
-    Scissors,
-}
-
-impl Rps {
-    fn outcome_against(&self, other: Rps) -> Outcome {
-        match (self, other) {
-            (Rps::Rock, Rps::Scissors) | (Rps::Paper, Rps::Rock) | (Rps::Scissors, Rps::Paper) => {
-                Outcome::Win
-            }
-            (Rps::Rock, Rps::Rock) | (Rps::Paper, Rps::Paper) | (Rps::Scissors, Rps::Scissors) => {
-                Outcome::Draw
-            }
-            (Rps::Rock, Rps::Paper) | (Rps::Paper, Rps::Scissors) | (Rps::Scissors, Rps::Rock) => {
-                Outcome::Lose
-            }
-        }
-    }
-
-    fn score(&self) -> u64 {
-        match self {
-            Rps::Rock => 1,
-            Rps::Paper => 2,
-            Rps::Scissors => 3,
-        }
-    }
-
-    fn with_outcome(&self, outcome: Outcome) -> Rps {
-        match (self, outcome) {
-            (r, Outcome::Draw) => *r,
-
-            (Rps::Rock, Outcome::Lose) => Rps::Scissors,
-            (Rps::Paper, Outcome::Lose) => Rps::Rock,
-            (Rps::Scissors, Outcome::Lose) => Rps::Paper,
-
-            (Rps::Rock, Outcome::Win) => Rps::Paper,
-            (Rps::Paper, Outcome::Win) => Rps::Scissors,
-            (Rps::Scissors, Outcome::Win) => Rps::Rock,
-        }
-    }
-}
-
-impl FromStr for Rps {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "A" | "X" => Ok(Rps::Rock),
-            "B" | "Y" => Ok(Rps::Paper),
-            "C" | "Z" => Ok(Rps::Scissors),
-            _ => Err(()),
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-enum Outcome {
-    Lose,
-    Draw,
-    Win,
-}
-
-impl Outcome {
-    fn score(&self) -> u64 {
-        match self {
-            Outcome::Lose => 0,
-            Outcome::Draw => 3,
-            Outcome::Win => 6,
-        }
-    }
-}
-
-impl FromStr for Outcome {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "X" => Ok(Outcome::Lose),
-            "Y" => Ok(Outcome::Draw),
-            "Z" => Ok(Outcome::Win),
-            _ => Err(()),
-        }
-    }
-}
-
-fn get_score<F, Rhs>(s: &str, f: F) -> u64
-where
-    F: Fn(Rps, Rhs) -> (Rps, Outcome),
-    Rhs: FromStr,
-    <Rhs as FromStr>::Err: fmt::Debug,
-{
-    s.lines()
-        .map(|line| {
-            let mut parts = line.split_whitespace();
-
-            let other: Rps = parts.next().unwrap().parse().unwrap();
-            let rhs = parts.next().unwrap().parse().unwrap();
-
-            let (me, outcome) = f(other, rhs);
-            me.score() + outcome.score()
-        })
-        .sum()
-}
-
-fn main() {
-    let mut data = String::new();
-    stdin().read_to_string(&mut data).unwrap();
-
-    println!(
-        "{}",
-        get_score(&data, |other, me| (me, me.outcome_against(other)))
-    );
-
-    println!(
-        "{}",
-        get_score(&data, |other, outcome| (
-            other.with_outcome(outcome),
-            outcome
-        ))
-    );
-}

Cargo.lock

@@ -465,10 +465,6 @@ dependencies = [
 name = "rust_2022_01"
 version = "0.1.0"
 
-[[package]]
-name = "rust_2022_02"
-version = "0.1.0"
-
 [[package]]
 name = "ryu"
 version = "1.0.11"

Cargo.toml

@@ -10,5 +10,4 @@ members = [
 	"2021/day16/rust",
 	"2021/day22/rust",
 	"2022/day1/rust",
-	"2022/day2/rust",
 ]