AdventOfCode2023/src/solutions/day07.rs

use std::collections::HashMap;

use super::Solution;

pub struct Day07 {}

#[derive(Debug, Eq, PartialEq)]
enum Hands {
    HC = 1,
    OP,
    TP,
    ThreeOAK,
    FH,
    FourOAK,
    FiveOAK,
}

impl Solution for Day07 {
    fn part1(
        &self,
        input: &mut Vec<String>,
    ) -> Result<Box<dyn std::fmt::Display + Sync>, Box<dyn std::error::Error>> {
        let hands = self.get_hands_from_string(input, false)?;
        let mut totals = vec![];

        for hand in hands.iter() {
            totals.push((hand.0.clone(), hand.1, self.get_hand_type(&hand.0)? as u32));
        }

        totals.sort_by(|a, b| {
            if a.2 == b.2 {
                a.0.partial_cmp(&b.0).unwrap()
            } else {
                (a.2 as u32).cmp(&(b.2 as u32))
            }
        });

        let mut score: u64 = 0;
        for (i, cards) in totals.iter().enumerate() {
            score += (cards.1 * (i + 1) as u32) as u64;
        }
        Ok(Box::new(score))
    }

    fn part2(
        &self,
        input: &mut Vec<String>,
    ) -> Result<Box<dyn std::fmt::Display + Sync>, Box<dyn std::error::Error>> {
        let hands = self.get_hands_from_string(input, true)?;
        let mut totals = vec![];

        for hand in hands.iter() {
            let adapted_hand = self.replace_wildcard(&hand.0)?;
            totals.push((
                hand.0.clone(),
                hand.1,
                self.get_hand_type(&adapted_hand)? as u32,
            ));
            println!("{:?}", hand);
        }

        totals.sort_by(|a, b| {
            if a.2 == b.2 {
                a.0.partial_cmp(&b.0).unwrap()
            } else {
                (a.2 as u32).cmp(&(b.2 as u32))
            }
        });

        let mut score: u64 = 0;
        for (i, cards) in totals.iter().enumerate() {
            score += (cards.1 * (i + 1) as u32) as u64;
        }
        Ok(Box::new(score))
    }

    fn get_day(&self) -> u8 {
        7
    }
}

impl Day07 {
    fn get_hands_from_string(
        &self,
        input: &mut Vec<String>,
        wildcard: bool,
    ) -> Result<Vec<(Vec<u32>, u32)>, Box<dyn std::error::Error>> {
        let mut hands = vec![];

        // Get the string from each line and split into hand and stake
        for hand in input {
            let (card, mut stake) = hand.split_at(5);
            stake = stake.trim();

            let mut hand = vec![];
            for i in card.chars() {
                hand.push(match i {
                    'T' => 10,
                    'J' => {
                        if wildcard {
                            0
                        } else {
                            11
                        }
                    }
                    'Q' => 12,
                    'K' => 13,
                    'A' => 14,
                    _ => i.to_digit(10).unwrap(),
                });
            }

            hands.push((hand, stake.parse()?));
            // hands.push((hand.iter().rev().map(|c| *c).collect(), stake.parse()?));
        }
        Ok(hands)
    }

    fn get_hand_type(&self, hand: &Vec<u32>) -> Result<Hands, Box<dyn std::error::Error>> {
        let mut map_cards = HashMap::new();

        for c in hand {
            map_cards.entry(c).and_modify(|c| *c += 1).or_insert(1u32);
        }

        let mut counts: Vec<&u32> = map_cards.values().into_iter().collect();
        counts.sort();

        // If there is a single key in the map we have 5OAK
        if map_cards.len() == 1 {
            return Ok(Hands::FiveOAK);
        }

        // 4OAK
        // Full House
        if map_cards.len() == 2 {
            // 4OAK
            if *counts[1] == 4u32 {
                return Ok(Hands::FourOAK);
            }
            return Ok(Hands::FH);
        }

        if map_cards.len() == 3 {
            // 3OAK
            if *counts[2] == 3 {
                return Ok(Hands::ThreeOAK);
            }

            // Two Pair
            return Ok(Hands::TP);
        }

        // One Pair
        if map_cards.len() == 4 {
            return Ok(Hands::OP);
        }

        // High Card
        Ok(Hands::HC)
    }

    fn replace_wildcard<'a>(
        &self,
        input: &Vec<u32>,
    ) -> Result<Vec<u32>, Box<dyn std::error::Error>> {
        let mut map_cards = HashMap::new();

        for c in input.iter() {
            map_cards.entry(c).and_modify(|c| *c += 1).or_insert(1u32);
        }

        // Get the wildcard count from the map and replace with the most common card
        let wc_count = *map_cards.get(&0).unwrap_or(&0);

        // Remove wildcards as we have already
        map_cards.remove_entry(&0);

        // Find the maximum frequency
        let max_frequency = map_cards.values().cloned().max().unwrap_or(0);

        // Filter numbers with the maximum frequency
        let most_frequenct_cards: Vec<u32> = map_cards
            .clone()
            .into_iter()
            .filter(|&(_, frequency)| frequency == max_frequency)
            .map(|(number, _)| *number)
            .collect::<Vec<u32>>();

        if most_frequenct_cards.len() == 0 {
            return Ok(input.clone());
        }

        map_cards.entry(&most_frequenct_cards[0]).and_modify(|v| {
            *v += wc_count;
        });

        let result: Vec<u32> = map_cards
            .into_iter()
            .flat_map(|(key, count)| vec![*key; count as usize])
            .collect();

        println!("Replaced: {:?}", result);

        Ok(result)
    }
}

/// Test from puzzle input
#[cfg(test)]
mod test {
    use super::*;
    use crate::*;

    #[test]
    fn part1() {
        let challenge = day07::Day07 {};

        //Complete the Challenge
        let answer = challenge
            .part1(
                utils::get_input(challenge.get_day(), utils::InputType::Test1)
                    .unwrap()
                    .as_mut(),
            )
            .unwrap()
            .to_string();

        assert_eq!(answer, "6440");
    }

    #[test]
    fn part2() {
        let challenge = day07::Day07 {};

        //Complete the Challenge
        let answer = challenge
            .part2(
                utils::get_input(challenge.get_day(), utils::InputType::Test2)
                    .unwrap()
                    .as_mut(),
            )
            .unwrap()
            .to_string();

        assert_eq!(answer, "5905");
    }
}