advent-of-code/2022/day2/src/main.rs

147 lines
3.4 KiB
Rust

#[derive(Debug, Copy, Clone)]
enum Calculation {
ByMove,
ByOutcome,
}
use Calculation::*;
// ----------------------------------------------------------------------------
#[derive(Debug, Copy, Clone)]
enum Outcome {
Win,
Draw,
Lose,
}
use Outcome::*;
impl From<char> for Outcome {
fn from(c: char) -> Self {
match c {
'X' => Lose,
'Y' => Draw,
'Z' => Win,
_ => panic!("Invalid char: {}", c),
}
}
}
impl Outcome {
fn get_score(self) -> u32 {
match self {
Lose => 0,
Draw => 3,
Win => 6,
}
}
}
// ----------------------------------------------------------------------------
#[derive(Debug, Copy, Clone)]
enum Shape {
Rock,
Paper,
Scissors,
}
use Shape::*;
impl From<char> for Shape {
fn from(c: char) -> Self {
match c {
'A' | 'X' => Rock,
'B' | 'Y' => Paper,
'C' | 'Z' => Scissors,
_ => panic!("Invalid char: {}", c),
}
}
}
impl Shape {
fn get_score(self) -> u32 {
match self {
Rock => 1,
Paper => 2,
Scissors => 3,
}
}
fn get_outcome(self, outcome: char) -> Shape {
let outcome = Outcome::from(outcome);
match self {
Rock => match outcome {
Win => Paper,
Draw => Rock,
Lose => Scissors,
},
Paper => match outcome {
Win => Scissors,
Draw => Paper,
Lose => Rock,
},
Scissors => match outcome {
Win => Rock,
Draw => Scissors,
Lose => Paper,
},
}
}
}
// ----------------------------------------------------------------------------
fn get_outcome_score(them: Shape, you: Shape) -> u32 {
match (them, you) {
(Rock, Scissors) | (Paper, Rock) | (Scissors, Paper) => Lose,
(Rock, Rock) | (Paper, Paper) | (Scissors, Scissors) => Draw,
(Rock, Paper) | (Paper, Scissors) | (Scissors, Rock) => Win,
}
.get_score()
}
fn get_round_score(them: char, you: char, score_type: Calculation) -> u32 {
let them = Shape::from(them);
let you = match score_type {
ByMove => Shape::from(you),
ByOutcome => them.get_outcome(you),
};
let shape_score = you.get_score();
let outcome_score = get_outcome_score(them, you);
shape_score + outcome_score
}
fn get_scores(lines: Vec<&str>, score_type: Calculation) -> Vec<u32> {
lines
.into_iter()
.map(|line| {
// This is trying to be too clever
let [them, _, you]: [char; 3] = line.chars().collect::<Vec<char>>().try_into().unwrap();
get_round_score(them, you, score_type)
})
.collect()
}
fn get_total(lines: &Vec<&str>, score_type: Calculation) -> u32 {
get_scores(lines.clone(), score_type)
.into_iter()
.reduce(|accum, item| accum + item)
.unwrap()
}
fn main() {
let file_str = include_str!("input.txt");
let lines: Vec<&str> = file_str.lines().collect();
let part1_total = get_total(&lines, ByMove);
let part2_total = get_total(&lines, ByOutcome);
println!("Part 1: Final score: {}", part1_total);
println!("Part 2: Final score: {}", part2_total);
}