JonathanGupton

Advent of Code 2022 - Day 2

Dec 2nd, 2022
101
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Rust 4.45 KB | None | 0 0
  1. use std::collections::HashMap;
  2.  
  3. #[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)]
  4. enum Outcome {
  5.     Win,
  6.     Draw,
  7.     Lose,
  8. }
  9.  
  10. #[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)]
  11. enum Shape {
  12.     Rock,
  13.     Paper,
  14.     Scissor,
  15. }
  16.  
  17. fn evaluate_play(player: Shape, elf: Shape) -> Outcome {
  18.     let player_outcomes: HashMap<(Shape, Shape), Outcome> = HashMap::from([
  19.         ((Shape::Rock, Shape::Paper), Outcome::Lose),
  20.         ((Shape::Rock, Shape::Scissor), Outcome::Win),
  21.         ((Shape::Paper, Shape::Scissor), Outcome::Lose),
  22.         ((Shape::Paper, Shape::Rock), Outcome::Win),
  23.         ((Shape::Scissor, Shape::Paper), Outcome::Win),
  24.         ((Shape::Scissor, Shape::Rock), Outcome::Lose),
  25.     ]);
  26.  
  27.     if player == elf {
  28.         Outcome::Draw
  29.     } else {
  30.         player_outcomes
  31.             .get(&(player, elf))
  32.             .expect("Play should be found.")
  33.             .clone()
  34.     }
  35. }
  36.  
  37. fn score_play(
  38.     play: &str,
  39.     player_map: &HashMap<char, Shape>,
  40.     elf_map: &HashMap<char, Shape>,
  41.     shape_values: &HashMap<Shape, u32>,
  42.     outcome_values: &HashMap<Outcome, u32>,
  43. ) -> u32 {
  44.     let mut split = play.trim().chars();
  45.     let elf = elf_map
  46.         .get(&split.next().unwrap())
  47.         .expect("Should get elf shape")
  48.         .clone();
  49.     split.next();
  50.     let player = player_map
  51.         .get(&split.next().unwrap())
  52.         .expect("Should get player shape")
  53.         .clone();
  54.     let outcome = evaluate_play(player, elf);
  55.  
  56.     let outcome_score = outcome_values.get(&outcome).unwrap();
  57.     let play_score = shape_values.get(&player).unwrap();
  58.     outcome_score + play_score
  59.  
  60. }
  61.  
  62. fn score_guide(
  63.     input: &str,
  64.     player_map: &HashMap<char, Shape>,
  65.     elf_map: &HashMap<char, Shape>,
  66.     shape_values: &HashMap<Shape, u32>,
  67.     outcome_values: &HashMap<Outcome, u32>,
  68. ) -> u32 {
  69.     input
  70.         .lines()
  71.         .map(|l| score_play(l, player_map, elf_map, shape_values, outcome_values))
  72.         .sum()
  73. }
  74.  
  75. pub fn part_one(input: &str) -> Option<u32> {
  76.     let elf_map: HashMap<char, Shape> = HashMap::from([
  77.         ('A', Shape::Rock),
  78.         ('B', Shape::Paper),
  79.         ('C', Shape::Scissor),
  80.     ]);
  81.  
  82.     let player_map: HashMap<char, Shape> = HashMap::from([
  83.         ('X', Shape::Rock),
  84.         ('Y', Shape::Paper),
  85.         ('Z', Shape::Scissor),
  86.     ]);
  87.     let shape_values: HashMap<Shape, u32> = HashMap::from([
  88.         (Shape::Rock, 1),
  89.         (Shape::Paper, 2),
  90.         (Shape::Scissor, 3),
  91.  
  92.     ]);
  93.     let outcome_values: HashMap<Outcome, u32> = HashMap::from([
  94.         (Outcome::Win, 6),
  95.         (Outcome::Draw, 3),
  96.         (Outcome::Lose, 0),
  97.     ]);
  98.  
  99.     Some(score_guide(input, &player_map, &elf_map, &shape_values, &outcome_values))
  100. }
  101.  
  102. pub fn part_two(input: &str) -> Option<u32> {
  103.     let mut score: u32 = 0;
  104.     let elf_map: HashMap<char, Shape> = HashMap::from([
  105.         ('A', Shape::Rock),
  106.         ('B', Shape::Paper),
  107.         ('C', Shape::Scissor),
  108.     ]);
  109.     let outcome_map: HashMap<char, Outcome> = HashMap::from([
  110.         ('X', Outcome::Lose),
  111.         ('Y', Outcome::Draw),
  112.         ('Z', Outcome::Win),
  113.     ]);
  114.     let shape_values: HashMap<Shape, u32> = HashMap::from([
  115.         (Shape::Rock, 1),
  116.         (Shape::Paper, 2),
  117.         (Shape::Scissor, 3),
  118.  
  119.     ]);
  120.  
  121.     for line in input.lines() {
  122.         let mut split = line.trim().chars();
  123.         let elf = elf_map
  124.             .get(&split.next().unwrap())
  125.             .expect("Should get elf shape")
  126.             .clone();
  127.         split.next();
  128.         let outcome = outcome_map
  129.             .get(&split.next().unwrap())
  130.             .expect("Should get player outcome")
  131.             .clone();
  132.  
  133.  
  134.         if outcome == Outcome::Draw {
  135.             score += 3;
  136.             score += shape_values.get(&elf).unwrap();
  137.         } else if outcome == Outcome::Win {
  138.             match elf {
  139.                 Shape::Paper => {
  140.                     score += 9;
  141.                 },
  142.                 Shape::Scissor => {
  143.                     score += 7;
  144.                 }
  145.                 Shape::Rock => {
  146.                     score += 8;
  147.                 }
  148.             }
  149.         } else {
  150.             match elf {
  151.                 Shape::Paper => {
  152.                     score += 1;
  153.                 },
  154.                 Shape::Scissor => {
  155.                     score += 2;
  156.                 }
  157.                 Shape::Rock => {
  158.                     score += 3;
  159.                 }
  160.             }
  161.         }
  162.     }
  163.     Some(score)
  164. }
  165.  
Advertisement
Add Comment
Please, Sign In to add comment