Day 7: Camel Cards

The first important thing we see is that you can distinguish almost all the hands using the most frequent card in that hand (5 of a kind > 4 of a kind > (full house/3 of a kind) > (two-pair/pair) > high card).
Then, (full house/3 of a kind) and (two-pair/pair) can be distinguished using a variety of methods (e.g. second most frequent card). I used "number of distinct card ranks in hand" which sounds ridiculous but is surprisingly simple when expressed in code.

Then, the tiebreaker is just comparing the hands in lexicographic order according to card strength (but without initially sorting by card strength, since I think poker does do that).

Once we have a way of getting hand strength, the rest of the problem is just sorting the list of hands according to (hand strength, the actual cards in the hand) and then multiplying each hand's bet by the index of that hand (+1 if your arrays start at 0, or reversed if you sorted by descending rank). In this case I just used a C++ custom comparator (wrapped in a custom struct) since the standard sort function will happily take your < function if you provide one.

#include <bits/stdc++.h>
using namespace std;
unordered_map<char,int> ranks = {
	{'A',0},
	{'K',1},
	{'Q',2},
	{'J',3},
	{'T',4},
	{'9',5},
	{'8',6},
	{'7',7},
	{'6',8},
	{'5',9},
	{'4',10},
	{'3',11},
	{'2',12},
};

// Assigns a numeric value to each hand, where lower = better
// This does NOT account for tiebreakers.
int evaluate_hand(const vector<int>& hand) {
	map<int,int> card_count;
	for(const auto& c: hand) {
		card_count[c]++;
	}
	vector<int> rank_freqs;
	for(const auto& it: card_count) {
		rank_freqs.push_back(it.second);
	}
	sort(rank_freqs.begin(),rank_freqs.end());

	if(rank_freqs.back() == 5) {
		return 0;
	} else if(rank_freqs.back() == 4) {
		return 1;
	} else if(rank_freqs.back() == 3) {
		// There are only 2 partitions of 2:
		// 1+1, 2
		// so we only need to look at the size to determine if
		// the hand is a full house (3+2) or a three-of-a-kind (3+1+1)
		if(rank_freqs.size() == 2) {
			return 2;
		} else {
			return 3;
		}
	} else if(rank_freqs.back() == 2) {
		// Similarly there are only 3 partitions of 3:
		// 1+1+1, 1+2, 3
		// The last one is "impossible" by our construction so again we 
		// only need size to distinguish between two-pair (1+2+2) and 
		// pair (1+1+1+2)
		if(rank_freqs.size() == 3) {
			return 4;
		} else {
			return 5;
		}
	} else {
		return 6;
	}
}

// A Camel hand, annotated with its value.
struct CamelHand {
	int quality,val;
	string hand;
	CamelHand(const vector<int>& ranked_hand, int val): quality(evaluate_hand(ranked_hand)), val(val) {
		for(const auto& card: ranked_hand) {
			hand.push_back(card);
		}
	}
	bool operator<(const CamelHand& ot) const {
		if(quality != ot.quality) {return quality < ot.quality;}
		// Why write a comparator for arrays in lexicographic order when
		// you can convert it to a string and get that for free?
		return hand < ot.hand;
	}

};
int main() {
	vector<CamelHand> hands;
	string string_hand;
	int hand_value;
	while(cin >> string_hand >> hand_value) {
		vector<int> ranked_hand;
		for(const auto& c: string_hand) {
			ranked_hand.push_back(ranks[c]);
		}
		hands.emplace_back(ranked_hand,hand_value);
	}
	sort(hands.begin(),hands.end());
	long long ans = 0;
	for(int i=0;i<hands.size();i++) {
		ans += hands[i].val*(hands.size()-i);
	}
	cout << ans << '\n';
}

Funnily enough, you can brute force the transformation of the Jokers into every possible card (despite how awful that sounds, assuming each hand is distinct you can prove that you'll only have to evaluate at most 24⁵ = 7962624 hands, which is merely kind of bad and runs in <1 second on my machine).

But we can be smarter than that. Stealing our observation of distinguishing hands by their most frequent cards from before, we realize that a Joker always does best by converting to the most frequent card in the hand. Since my implementation already converts a hand into a list of card frequencies, this is almost* as simple as adding the number of jokers to the most frequent hand.

^{*almost, of course, because the problem writers knew you would think of this and likely threw a hand of all Jokers at you.}

#include <bits/stdc++.h>
using namespace std;
unordered_map<char,int> ranks = {
	{'A',0},
	{'K',1},
	{'Q',2},
	{'T',3},
	{'9',4},
	{'8',5},
	{'7',6},
	{'6',7},
	{'5',8},
	{'4',9},
	{'3',10},
	{'2',11},
	{'J',12}
};
const int JOKER = 12;

int evaluate_hand(const vector<int>& hand) {
	map<int,int> card_count;
	int joker_count = 0;
	for(const auto& c: hand) {
		if(c == JOKER) {
			joker_count++;
		} else {
			card_count[c]++;
		}
	}
	vector<int> rank_freqs;
	for(const auto& it: card_count) {
		rank_freqs.push_back(it.second);
	}
	sort(rank_freqs.begin(),rank_freqs.end());

	// We love those all-joker hands!
	if(rank_freqs.empty()) {
		rank_freqs.push_back(joker_count);
	} else {
		rank_freqs.back() += joker_count;
	}

	if(rank_freqs.back() == 5) {
		return 0;
	} else if(rank_freqs.back() == 4) {
		return 1;
	} else if(rank_freqs.back() == 3) {
		if(rank_freqs.size() == 2) {
			return 2;
		} else {
			return 3;
		}
	} else if(rank_freqs.back() == 2) {
		if(rank_freqs.size() == 3) {
			return 4;
		} else {
			return 5;
		}
	} else {
		return 6;
	}
}

struct CamelHand {
	int quality,val;
	string hand;
	CamelHand(const vector<int>& ranked_hand, int val): quality(evaluate_hand(ranked_hand)), val(val) {
		for(const auto& card: ranked_hand) {
			hand.push_back(card);
		}
	}
	bool operator<(const CamelHand& ot) const {
		if(quality != ot.quality) {return quality < ot.quality;}
		return hand < ot.hand;
	}

};
int main() {
	vector<CamelHand> hands;
	string string_hand;
	int hand_value;
	while(cin >> string_hand >> hand_value) {
		vector<int> ranked_hand;
		for(const auto& c: string_hand) {
			ranked_hand.push_back(ranks[c]);
		}
		hands.emplace_back(ranked_hand,hand_value);
	}
	sort(hands.begin(),hands.end());
	long long ans = 0;
	for(int i=0;i<hands.size();i++) {
		ans += hands[i].val*(hands.size()-i);
	}
	cout << ans << '\n';
}

# Advent of Code 2023
# Day 7: Camel Cards

from copy import deepcopy
from functools import cmp_to_key

special_cards = {
    "T": 10,
    "J": 11,
    "Q": 12,
    "K": 13,
    "A": 14
}

hands_part_1 = []

with open("inputs/day_7.txt") as file:
    for line in file:
        halves = line.split(" ")
        hands_part_1.append({
            "cards": [
                int(card) if card in "123456789" else special_cards[card]
                for card in halves[0]
            ],
            "bid": int(halves[1])
        })

hands_part_2 = deepcopy(hands_part_1)

for hand in hands_part_2:
    hand["cards"] = [0 if card == 11 else card for card in hand["cards"]]

def find_type(cards):
    set_ = set(cards)
    unique_cards = len(set_)

    if unique_cards == 1:
        return 0
    elif unique_cards == 2:
        if cards.count(cards[0]) in (1, 4):
            return 1
        else:
            return 2
    elif unique_cards == 3:
        if any(cards.count(card) == 3 for card in set_):
            return 3
        elif any(cards.count(card) == 2 for card in set_):
            return 4
    elif unique_cards == 4:
        return 5
    else:
        return 6

for hand in hands_part_1:
    hand["type"] = find_type(hand["cards"])

for hand in hands_part_2:
    if 0 in hand["cards"]:
        hand["type"] = None

        for new_card in range(15):
            if new_card != 0:
                modified_cards = [
                    new_card if card == 0 else card for card in hand["cards"]
                ]

                type_ = find_type(modified_cards)

                if hand["type"] is None or type_ < hand["type"]:
                    hand["type"] = type_
    else:
        hand["type"] = find_type(hand["cards"])

def compare_hands(hand_1, hand_2):
    if hand_1["type"] < hand_2["type"]:
        return 1
    elif hand_2["type"] < hand_1["type"]:
        return -1
    else:
        for card_1, card_2 in zip(hand_1["cards"], hand_2["cards"]):
            if card_1 > card_2:
                return 1
            elif card_2 > card_1:
                return -1

        return 0

key = cmp_to_key(compare_hands)
hands_part_1.sort(key=key)
hands_part_2.sort(key=key)

print(f"""Part 1: {
    sum(hand['bid'] * (i + 1) for i, hand in enumerate(hands_part_1))
}""")

print(f"""Part 2: {
    sum(hand['bid'] * (i + 1) for i, hand in enumerate(hands_part_2))
}""")

This was pretty straightforward: create a histogram of the cards in each hand to determine their type, and if there is a tie-breaker, compare each card pairwise. I use the Counter class from collections to do the counting, and then had a dictionary/table to convert labels to numeric values for comparison. I used a very OOP approach and wrote a magic method for comparing hands and used that with Python's builtin sort. I even got to use Enum!

LABELS = {l: v for v, l in enumerate('23456789TJQKA', 2)}

class HandType(IntEnum):
    FIVE_OF_A_KIND  = 6
    FOUR_OF_A_KIND  = 5
    FULL_HOUSE      = 4
    THREE_OF_A_KIND = 3
    TWO_PAIR        = 2
    ONE_PAIR        = 1
    HIGH_CARD       = 0

class Hand:
    def __init__(self, cards=str, bid=str):
        self.cards  = cards
        self.bid    = int(bid)
        counts      = Counter(self.cards)
        self.type   = (
            HandType.FIVE_OF_A_KIND  if len(counts) == 1 else
            HandType.FOUR_OF_A_KIND  if len(counts) == 2 and any(l for l, count in counts.items() if count == 4) else
            HandType.FULL_HOUSE      if len(counts) == 2 and any(l for l, count in counts.items() if count == 3) else
            HandType.THREE_OF_A_KIND if len(counts) == 3 and any(l for l, count in counts.items() if count == 3) else
            HandType.TWO_PAIR        if len(counts) == 3 and any(l for l, count in counts.items() if count == 2) else
            HandType.ONE_PAIR        if len(counts) == 4 and any(l for l, count in counts.items() if count == 2) else
            HandType.HIGH_CARD
        )

    def __lt__(self, other):
        if self.type == other.type:
            for s_label, o_label in zip(self.cards, other.cards):
                if LABELS[s_label] == LABELS[o_label]:
                    continue
                return LABELS[s_label] < LABELS[o_label]
            return False
        return self.type < other.type

    def __repr__(self):
        return f'Hand(cards={self.cards},bid={self.bid},type={self.type})'

def read_hands(stream=sys.stdin) -> list[Hand]:
    return [Hand(*line.split()) for line in stream]

def main(stream=sys.stdin) -> None:
    hands    = sorted(read_hands(stream))
    winnings = sum(rank * hand.bid for rank, hand in enumerate(hands, 1))
    print(winnings)

For the second part, I just had to add some post-processing code to convert the jokers into actual cards. The key insight is to find the highest and most numerous non-Joker card and convert all the Jokers to that card label.

This had two edge cases that tripped me up:

1. 'JJJJJ': There is no other non-Joker here, so I messed up and ranked this the lowest because I ended up removing all counts.

2. 'JJJ12': This also messed me up b/c the Joker was the most numerous card, and I didn't handle that properly.

Once I fixed the post-processing code though, everything else remained the same. Below, I only show the parts that changed from Part A.

LABELS = {l: v for v, l in enumerate('J23456789TQKA', 1)}

...

class Hand:
    def __init__(self, cards=str, bid=str):
        self.cards  = cards
        self.bid    = int(bid)
        counts      = Counter(self.cards)

        if 'J' in counts and len(counts) > 1:
            max_label = max(set(counts) - {'J'}, key=lambda l: (counts[l], LABELS[l]))
            counts[max_label] += counts['J']
            del counts['J']

        self.type   = (...)

use std::collections::HashMap;

#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Debug, Hash)]
pub enum Card {
    Ace = 14,
    King = 13,
    Queen = 12,
    JackOrJoker = 11,
    Ten = 10,
    Nine = 9,
    Eight = 8,
    Seven = 7,
    Six = 6,
    Five = 5,
    Four = 4,
    Three = 3,
    Two = 2,
}

impl From<char> for Card {
    fn from(c: char) -> Self {
        match c {
            'A' => Card::Ace,
            'K' => Card::King,
            'Q' => Card::Queen,
            'J' => Card::JackOrJoker,
            'T' => Card::Ten,
            '9' => Card::Nine,
            '8' => Card::Eight,
            '7' => Card::Seven,
            '6' => Card::Six,
            '5' => Card::Five,
            '4' => Card::Four,
            '3' => Card::Three,
            '2' => Card::Two,
            _ => panic!("Invalid card"),
        }
    }
}

#[derive(PartialEq, Eq, Clone, Debug)]
pub struct Hand {
    pub cards: [Card; 5],
    pub bid: usize,
}

impl Ord for Hand {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        (self.classify(), self.cards).cmp(&(other.classify(), other.cards))
    }
}

impl PartialOrd for Hand {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

#[derive(PartialEq, Eq, Clone, Copy, Debug, PartialOrd, Ord)]
pub enum HandType {
    FiveOfAKind = 6,
    FourOfAKind = 5,
    FullHouse = 4,
    ThreeOfAKind = 3,
    TwoPair = 2,
    OnePair = 1,
    HighCard = 0,
}

impl Hand {
    pub fn classify(&self) -> HandType {
        let c = &self.cards;
        let mut s = HashMap::new();

        for card in c.iter() {
            let count = s.entry(card).or_insert(0);
            *count += 1;
        }

        match s.len() {
            // AAAAA
            1 => HandType::FiveOfAKind,

            2 => {
                // AAAAB
                if s.values().any(|&x| x == 4) {
                    return HandType::FourOfAKind;
                }

                // AAABB
                HandType::FullHouse
            }

            3 => {
                // AAABC
                if s.values().any(|&x| x == 3) {
                    return HandType::ThreeOfAKind;
                }

                // AABBC
                HandType::TwoPair
            }

            // AABCD
            4 => HandType::OnePair,
            // ABCDE
            5 => HandType::HighCard,

            _ => unreachable!("Only five cards to a hand."),
        }
    }
}

use nom::{
    character::complete::{newline, space1},
    IResult,
};

use super::ds::{Card, Hand};

pub fn parse(input: &str) -> IResult<&str, Vec<Hand>> {
    let (input, hands) = nom::multi::many1(parse_line)(input)?;

    Ok((input, hands))
}

fn parse_line(input: &str) -> IResult<&str, Hand> {
    let (input, cards) = nom::multi::count(parse_card, 5)(input)?;
    let (input, _) = space1(input)?;
    let (input, bid) = parse_usize(input)?;
    let (input, _) = newline(input)?;

    let cards = cards.clone();

    Ok((
        input,
        Hand {
            cards: [cards[0], cards[1], cards[2], cards[3], cards[4]],
            bid,
        },
    ))
}

fn parse_card(input: &str) -> IResult<&str, Card> {
    let (input, card) = nom::character::complete::one_of("AKQJT98765432")(input)?;
    let card = Card::from(card);

    Ok((input, card))
}

fn parse_usize(input: &str) -> IResult<&str, usize> {
    let (input, num) = nom::character::complete::digit1(input)?;
    let num = num.parse::<usize>().unwrap();

    Ok((input, num))
}

use super::parser;

pub fn part1(input: &str) -> usize {
    let mut hands = parser::parse(input).unwrap().1;

    hands.sort();

    hands
        .iter()
        .enumerate()
        .fold(0, |acc, (i, hand)| acc + (i + 1) * hand.bid)
}

I should probably have used a brute-force solution here, because going through
the rules multiple-times to figure out what to classify each hand took a bit of time.

use std::collections::HashMap;

use crate::{ds::HandType, parser};

use super::ds::{Card, Hand};

pub fn part2(input: &str) -> usize {
    let hands = parser::parse(input).unwrap().1;

    let mut hands2 = hands.into_iter().map(Part2Hand).collect::<Vec<_>>();

    hands2.sort();

    hands2
        .iter()
        .enumerate()
        .fold(0, |acc, (i, hand)| acc + (i + 1) * hand.0.bid)
}

#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Part2Card(Card);

impl Ord for Part2Card {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        match (self.0, other.0) {
            (Card::JackOrJoker, Card::JackOrJoker) => std::cmp::Ordering::Equal,
            (Card::JackOrJoker, _) => std::cmp::Ordering::Less,
            (_, Card::JackOrJoker) => std::cmp::Ordering::Greater,
            _ => self.0.cmp(&other.0),
        }
    }
}

impl PartialOrd for Part2Card {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct Part2Hand(Hand);

impl Part2Hand {
    pub fn classify(&self) -> HandType {
        let c = &self.0.cards;
        let mut s = HashMap::new();

        for card in c.iter() {
            let count = s.entry(card).or_insert(0);
            *count += 1;
        }

        let num_jokers = *s.get(&Card::JackOrJoker).unwrap_or(&0);

        if num_jokers == 0 {
            return self.0.classify();
        }

        match s.len() {
            // AAAAA
            1 => HandType::FiveOfAKind,
            2 => HandType::FiveOfAKind,
            3 => {
                // AAABC
                if s.values().any(|&x| x == 3) {
                    return HandType::FourOfAKind;
                }

                // AABBC
                if num_jokers == 1 {
                    return HandType::FullHouse;
                }

                HandType::FourOfAKind
            }
            4 => {
                // AABCD
                if s.values().filter(|&x| *x == 2).count() == 1 {
                    if num_jokers == 1 || num_jokers == 2 {
                        return HandType::ThreeOfAKind;
                    }

                    return HandType::TwoPair;
                }

                // AABBC
                if num_jokers == 1 {
                    return HandType::FullHouse;
                }

                HandType::FourOfAKind
            }
            5 => HandType::OnePair,
            _ => unreachable!("Only five cards to a hand."),
        }
    }
}

impl Ord for Part2Hand {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        (
            self.classify(),
            self.0
                .cards
                .iter()
                .map(|c| Part2Card(*c))
                .collect::<Vec<_>>(),
        )
            .cmp(&(
                other.classify(),
                other
                    .0
                    .cards
                    .iter()
                    .map(|c| Part2Card(*c))
                    .collect::<Vec<_>>(),
            ))
    }
}

impl PartialOrd for Part2Hand {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

Benchmark 1: target/release/day-07
  Time (mean ± σ):      11.3 ms ±   1.7 ms    [User: 10.7 ms, System: 1.3 ms]
  Range (min … max):     6.4 ms …  16.8 ms    288 runs

use std::collections::HashMap;

#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
enum Card1 {
    Two,
    Three,
    Four,
    Five,
    Six,
    Seven,
    Eight,
    Nine,
    Ten,
    Jack,
    Queen,
    King,
    Ace,
}

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
enum Hand {
    High,
    OnePair,
    TwoPair,
    Three,
    Full,
    Four,
    Five,
}

fn hand_type_part1(cards: &[Card1]) -> Hand {
    use Hand::*;
    let mut hand: HashMap<Card1, usize> = HashMap::new();
    for card in cards {
        *hand.entry(*card).or_default() += 1;
    }
    match hand.len() {
        5 => High,
        4 => OnePair,
        3 if *hand.values().max().unwrap() == 2 => TwoPair,
        3 if *hand.values().max().unwrap() == 3 => Three,
        2 if *hand.values().max().unwrap() == 3 => Full,
        2 if *hand.values().max().unwrap() == 4 => Four,
        1 => Five,
        _ => unreachable!(),
    }
}

#[aoc(day7, part1)]
fn part1(input: &str) -> usize {
    let mut hands: Vec<(Hand, Vec<Card1>, usize)> = input
        .lines()
        .map(|line| {
            let mut parts = line.split(" ");
            let cards: Vec<Card1> = parts
                .next()
                .unwrap()
                .chars()
                .map(|c| {
                    use Card1::*;
                    match c {
                        '2' => Two,
                        '3' => Three,
                        '4' => Four,
                        '5' => Five,
                        '6' => Six,
                        '7' => Seven,
                        '8' => Eight,
                        '9' => Nine,
                        'T' => Ten,
                        'J' => Jack,
                        'Q' => Queen,
                        'K' => King,
                        'A' => Ace,
                        _ => unreachable!(),
                    }
                })
                .collect();

            let hand = hand_type_part1(&cards);
            let bid: usize = parts.next().unwrap().parse().unwrap();
            (hand, cards, bid)
        })
        .collect();

    hands.sort();

    hands
        .into_iter()
        .enumerate()
        .map(|(i, (_, _, bid))| (i + 1) * bid)
        .sum()
}

#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
enum Card2 {
    Joker,
    Two,
    Three,
    Four,
    Five,
    Six,
    Seven,
    Eight,
    Nine,
    Ten,
    Queen,
    King,
    Ace,
}

fn hand_type_part2(cards: &[Card2]) -> Hand {
    use Hand::*;
    let mut hand: HashMap<Card2, usize> = HashMap::new();
    for card in cards {
        *hand.entry(*card).or_default() += 1;
    }

    let jokers = *hand.get(&Card2::Joker).unwrap_or(&0);

    let max = *hand.values().max().unwrap();

    match hand.len() {
        // 0, 1
        5 if jokers == 0 => High,
        5 => OnePair,
        // 0, 1, 2
        4 if jokers == 0 => OnePair,
        4 if jokers == 1 => Three,
        4 if jokers == 2 => Three,
        // 0, 1, 2
        3 if max == 2 && jokers == 0 => TwoPair,
        3 if max == 2 && jokers == 1 => Full,
        3 if max == 2 && jokers == 2 => Four,
        // 0, 1, 3
        3 if max == 3 && jokers == 0 => Three,
        3 if max == 3 && jokers == 1 => Four,
        3 if max == 3 && jokers == 3 => Four,
        // 0, 2, 3
        2 if max == 3 && jokers == 0 => Full,
        2 if max == 3 && jokers == 2 => Five,
        2 if max == 3 && jokers == 3 => Five,
        // 0, 1, 4
        2 if max == 4 && jokers == 0 => Four,
        2 if max == 4 && jokers == 1 => Five,
        2 if max == 4 && jokers == 4 => Five,
        // 0, 5
        1 => Five,
        _ => unreachable!(),
    }
}

#[aoc(day7, part2)]
fn part2(input: &str) -> usize {
    let mut hands: Vec<(Hand, Vec<Card2>, usize)> = input
        .lines()
        .map(|line| {
            let mut parts = line.split(" ");
            let cards: Vec<Card2> = parts
                .next()
                .unwrap()
                .chars()
                .map(|c| {
                    use Card2::*;
                    match c {
                        'J' => Joker,
                        '2' => Two,
                        '3' => Three,
                        '4' => Four,
                        '5' => Five,
                        '6' => Six,
                        '7' => Seven,
                        '8' => Eight,
                        '9' => Nine,
                        'T' => Ten,
                        'Q' => Queen,
                        'K' => King,
                        'A' => Ace,
                        _ => unreachable!(),
                    }
                })
                .collect();

            let hand = hand_type_part2(&cards);
            let bid: usize = parts.next().unwrap().parse().unwrap();
            (hand, cards, bid)
        })
        .collect();

    hands.sort();

    hands
        .into_iter()
        .enumerate()
        .map(|(i, (_, _, bid))| (i + 1) * bid)
        .sum()
}

use std::env;
use std::io::{self, prelude::*, BufReader};
use std::fs::File;
use std::collections::HashMap;
use std::cmp::Ordering;

#[derive(PartialEq,Eq)]
struct Hand {
    cards: Vec<usize>,
    bid: usize,
}
impl From<&String> for Hand {
    fn from(s: &String) -> Self {
        let parts: Vec<_> = s.split_whitespace().collect();
        Self {
            cards: card_values(parts[0]),
            bid: parts[1].parse().unwrap(),
        }
    }
}
impl Hand {
    pub fn hand_type(&self) -> HandType {
        // Generate card counts
        let mut card_counts: HashMap<usize,usize> = HashMap::new();
        for card in &self.cards {
            *card_counts.entry(*card).or_insert(0) += 1;
        }

        // Determine type
        let mut counts: Vec<_> = card_counts.iter().map(|(_,ct)| ct).collect();
        counts.sort_by(|a,b| b.cmp(a));
        let max_kind = counts[0];

        if *max_kind  == 5usize { return HandType::FiveOfAKind; }
        if *max_kind  == 4usize { return HandType::FourOfAKind; }
        if *max_kind  == 3usize
        && *counts[1] == 2usize { return HandType::FullHouse; }
        if *max_kind  == 3usize { return HandType::ThreeOfAKind; }
        if *max_kind  == 2usize
        && *counts[1] == 2usize { return HandType::TwoPair; }
        if *max_kind  == 2usize { return HandType::OnePair; }
        return HandType::HighCard;
    }
}
impl Ord for Hand {
    fn cmp(&self, other: &Self) -> Ordering {
        if self.hand_type() != other.hand_type() {
            return (self.hand_type() as usize).cmp(&(other.hand_type() as usize));
        }
        // Hand kinds are equal
        for (card_self,card_other) in self.cards.iter().zip(other.cards.iter()) {
            if card_self != card_other { return card_self.cmp(card_other); }
        }
        panic!("Unable to sort cards");
    }
}
impl PartialOrd for Hand {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

fn value_from_char(c: char) -> usize {
    match c.to_digit(10) {
        Some(num) => num as usize,
        None => match c {
            'T' => 10,
            'J' => 11,
            'Q' => 12,
            'K' => 13,
            'A' => 14,
            other => panic!("Unexpected card: {other}"),
        }
    }
}

fn card_values(cards: &str) -> Vec<usize> {
    cards.chars().map(|c| value_from_char(c)).collect()
}

#[derive(Debug,Eq,PartialEq)]
enum HandType {
    FiveOfAKind = 7,
    FourOfAKind = 6,
    FullHouse = 5,
    ThreeOfAKind = 4,
    TwoPair = 3,
    OnePair = 2,
    HighCard = 1,
}

fn solve(input: &str) -> io::Result<()> {
    let file = File::open(input).expect("Input file not found.");
    let reader = BufReader::new(file);

    // Input
    let input: Vec<String> = match reader.lines().collect() {
        Err(err) => panic!("Unknown error reading input: {}", err),
        Ok(result) => result,
    };
    let mut hands: Vec<_> = input.iter().map(Hand::from).collect();
    hands.sort();

    // Part 1
    let part1: usize = hands.iter().enumerate().map(|(rank,hand)| (rank+1) * hand.bid).sum();
    println!("Part 1: {part1}"); // 251136060

    Ok(())
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let filename = &args[1];
    solve(&filename).unwrap();
}

use std::env;
use std::io::{self, prelude::*, BufReader};
use std::fs::File;
use std::collections::HashMap;
use std::cmp::Ordering;

#[derive(PartialEq,Eq)]
struct Hand {
    cards: Vec<usize>,
    bid: usize,
    card_str: String,
}
impl From<&String> for Hand {
    fn from(s: &String) -> Self {
        let parts: Vec<_> = s.split_whitespace().collect();
        Self {
            cards: card_values(parts[0]),
            bid: parts[1].parse().unwrap(),
            card_str: s.to_string(),
        }
    }
}
impl Hand {
    pub fn hand_type(&self) -> HandType {
        // Generate card counts
        let mut card_counts: HashMap<usize,usize> = HashMap::new();
        for card in &self.cards {
            *card_counts.entry(*card).or_insert(0) += 1;
        }

        // Determine type
        let mut counts: Vec<_> = card_counts.iter().filter(|&(c,_)| *c != 0usize).map(|(_,ct)| ct).collect();
        let jokers = card_counts.get(&0).unwrap_or(&0);
        counts.sort_by(|a,b| b.cmp(a));
        let max_kind = if counts.len() != 0 { counts[0] + jokers } else { *jokers };

        if  max_kind  == 5usize { return HandType::FiveOfAKind; }
        if  max_kind  == 4usize { return HandType::FourOfAKind; }
        if  max_kind  == 3usize
        && *counts[1] == 2usize { return HandType::FullHouse; }
        if  max_kind  == 3usize { return HandType::ThreeOfAKind; }
        if  max_kind  == 2usize
        && *counts[1] == 2usize { return HandType::TwoPair; }
        if  max_kind  == 2usize { return HandType::OnePair; }
        return HandType::HighCard;
    }
}
impl Ord for Hand {
    fn cmp(&self, other: &Self) -> Ordering {
        if self.hand_type() != other.hand_type() {
            return (self.hand_type() as usize).cmp(&(other.hand_type() as usize));
        }
        // Hand kinds are equal
        for (card_self,card_other) in self.cards.iter().zip(other.cards.iter()) {
            if card_self != card_other { return card_self.cmp(card_other); }
        }
        panic!("Unable to sort cards");
    }
}
impl PartialOrd for Hand {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

fn value_from_char(c: char) -> usize {
    match c.to_digit(10) {
        Some(num) => num as usize,
        None => match c {
            'T' => 10,
            'J' =>  0,
            'Q' => 12,
            'K' => 13,
            'A' => 14,
            other => panic!("Unexpected card: {other}"),
        }
    }
}

fn card_values(cards: &str) -> Vec<usize> {
    cards.chars().map(|c| value_from_char(c)).collect()
}

#[derive(Debug,Eq,PartialEq)]
enum HandType {
    FiveOfAKind = 7,
    FourOfAKind = 6,
    FullHouse = 5,
    ThreeOfAKind = 4,
    TwoPair = 3,
    OnePair = 2,
    HighCard = 1,
}

fn solve(input: &str) -> io::Result<()> {
    let file = File::open(input).expect("Input file not found.");
    let reader = BufReader::new(file);

    // Input
    let input: Vec<String> = match reader.lines().collect() {
        Err(err) => panic!("Unknown error reading input: {}", err),
        Ok(result) => result,
    };
    let mut hands: Vec<_> = input.iter().map(Hand::from).collect();
    hands.sort();

    // Part 2
    let part2: usize = hands.iter().enumerate().map(|(rank,hand)| (rank+1) * hand.bid).sum();
    println!("Part 2: {part2}"); // 249400220

    Ok(())
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let filename = &args[1];
    solve(&filename).unwrap();
}