Day 7: Camel Cards
Megathread guidelines
- Keep top level comments as only solutions, if you want to say something other than a solution put it in a new post. (replies to comments can be whatever)
- Code block support is not fully rolled out yet but likely will be in the middle of the event. Try to share solutions as both code blocks and using something such as https://topaz.github.io/paste/ , pastebin, or github (code blocks to future proof it for when 0.19 comes out and since code blocks currently function in some apps and some instances as well if they are running a 0.19 beta)
FAQ
- What is this?: Here is a post with a large amount of details: https://programming.dev/post/6637268
- Where do I participate?: https://adventofcode.com/
- Is there a leaderboard for the community?: We have a programming.dev leaderboard with the info on how to join in this post: https://programming.dev/post/6631465
🔒 Thread is locked until there’s at least 100 2 star entries on the global leaderboard
🔓 Thread has been unlocked after around 20 mins
Nim
I wrote some nice code for sorting poker hands, just defining the
<
and==
operations for myCardSet
andHand
types, and letting the standard library’s sort function handle the rest.It was quite frustrating to be told that my answer was wrong, though. I dumped the full sorted hand list and checked it manually to make sure everything was working properly, and it was. Wasted a few hours trying to figure out what was wrong. Ended up grabbing someone else’s code and running it in order to compare the resulting hand list. Theirs was clearly ordered wrong, but somehow ended up with the correct answer?
Turns out that Camel Cards isn’t Poker. -_-
Rather than rewrite my code entirely, I settled on some slightly ugly hacks to make it work for Camel Cards, and to handle the wildcards in part 2.
Nim
Part 1 is just a sorting problem. Nim’s standard library supports sorting with custom compare functions, so I only had to implement cmp() for my custom type and I was done in no time.
To get the star in Part 2 I was generating every possible combination of card hands with Jokers replaced by other cards. It was pretty fast, under a second. Didn’t figure out the deterministic method by myself, but coded it after couple hints from Nim Discord people.
Didn’t expect an easy challenge for today, but was pleasantly surprised. No weird edge cases, no hidden traps, puzzle text was easy to understand and input parsing is painless.Total runtime: 1 ms
Puzzle rating: Almost Pefect 9/10
Code: day_07/solution.nimPart 1, in C. This took me way too long, there were so many bugs and problems I overlooked. So it’s very long.
https://git.sr.ht/~aidenisik/aoc23/tree/master/item/day7
EDIT: And part 2
Two days, a few failed solutions, some misread instructions, and a lot of manually parsing output data and debugging silly tiny mistakes… but it’s finally done. I don’t really wanna talk about it.
https://github.com/capitalpb/advent_of_code_2023/blob/main/src/solvers/day07.rs
use crate::Solver; use itertools::Itertools; use std::cmp::Ordering; #[derive(Clone, Copy)] enum JType { Jokers = 1, Jacks = 11, } #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)] enum HandType { HighCard, OnePair, TwoPair, ThreeOfAKind, FullHouse, FourOfAKind, FiveOfAKind, } #[derive(Debug, Eq, PartialEq)] struct CardHand { hand: Vec, bid: u64, hand_type: HandType, } impl CardHand { fn from(input: &str, j_type: JType) -> CardHand { let (hand, bid) = input.split_once(' ').unwrap(); let hand = hand .chars() .map(|card| match card { '2'..='9' => card.to_digit(10).unwrap() as u64, 'T' => 10, 'J' => j_type as u64, 'Q' => 12, 'K' => 13, 'A' => 14, _ => unreachable!("malformed input"), }) .collect::>(); let bid = bid.parse::().unwrap(); let counts = hand.iter().counts(); let hand_type = match counts.len() { 1 => HandType::FiveOfAKind, 2 => { if hand.contains(&1) { HandType::FiveOfAKind } else { if counts.values().contains(&4) { HandType::FourOfAKind } else { HandType::FullHouse } } } 3 => { if counts.values().contains(&3) { if hand.contains(&1) { HandType::FourOfAKind } else { HandType::ThreeOfAKind } } else { if counts.get(&1) == Some(&2) { HandType::FourOfAKind } else if counts.get(&1) == Some(&1) { HandType::FullHouse } else { HandType::TwoPair } } } 4 => { if hand.contains(&1) { HandType::ThreeOfAKind } else { HandType::OnePair } } _ => { if hand.contains(&1) { HandType::OnePair } else { HandType::HighCard } } }; CardHand { hand, bid, hand_type, } } } impl PartialOrd for CardHand { fn partial_cmp(&self, other: &Self) -> Option { Some(self.cmp(other)) } } impl Ord for CardHand { fn cmp(&self, other: &Self) -> Ordering { let hand_type_cmp = self.hand_type.cmp(&other.hand_type); if hand_type_cmp != Ordering::Equal { return hand_type_cmp; } else { for i in 0..5 { let value_cmp = self.hand[i].cmp(&other.hand[i]); if value_cmp != Ordering::Equal { return value_cmp; } } } Ordering::Equal } } pub struct Day07; impl Solver for Day07 { fn star_one(&self, input: &str) -> String { input .lines() .map(|line| CardHand::from(line, JType::Jacks)) .sorted() .enumerate() .map(|(index, hand)| hand.bid * (index as u64 + 1)) .sum::() .to_string() } fn star_two(&self, input: &str) -> String { input .lines() .map(|line| CardHand::from(line, JType::Jokers)) .sorted() .enumerate() .map(|(index, hand)| hand.bid * (index as u64 + 1)) .sum::() .to_string() } }
Factor on github (with comments and imports):
! hand: "A23A4" ! card: 'Q' ! hand-bid: { "A23A4" 220 } : card-key ( ch -- n ) "23456789TJQKA" index ; : five-kind? ( hand -- ? ) cardinality 1 = ; : four-kind? ( hand -- ? ) sorted-histogram last last 4 = ; : full-house? ( hand -- ? ) sorted-histogram { [ last last 3 = ] [ length 2 = ] } && ; : three-kind? ( hand -- ? ) sorted-histogram { [ last last 3 = ] [ length 3 = ] } && ; : two-pair? ( hand -- ? ) sorted-histogram { [ last last 2 = ] [ length 3 = ] } && ; : one-pair? ( hand -- ? ) sorted-histogram { [ last last 2 = ] [ length 4 = ] } && ; : high-card? ( hand -- ? ) cardinality 5 = ; : type-key ( hand -- n ) [ 0 ] dip { [ high-card? ] [ one-pair? ] [ two-pair? ] [ three-kind? ] [ full-house? ] [ four-kind? ] [ five-kind? ] } [ dup empty? ] [ unclip pick swap call( h -- ? ) [ drop f ] [ [ 1 + ] 2dip ] if ] until 2drop ; :: (hand-compare) ( hand1 hand2 type-key-quot card-key-quot -- <=> ) hand1 hand2 type-key-quot compare dup +eq+ = [ drop hand1 hand2 [ card-key-quot compare ] { } 2map-as { +eq+ } without ?first dup [ drop +eq+ ] unless ] when ; inline : hand-compare ( hand1 hand2 -- <=> ) [ type-key ] [ card-key ] (hand-compare) ; : input>hand-bids ( -- hand-bids ) "vocab:aoc-2023/day07/input.txt" utf8 file-lines [ " " split1 string>number 2array ] map ; : solve ( hand-compare-quot -- ) '[ [ first ] bi@ @ ] input>hand-bids swap sort-with [ 1 + swap last * ] map-index sum . ; inline : part1 ( -- ) [ hand-compare ] solve ; : card-key-wilds ( ch -- n ) "J23456789TQKA" index ; : type-key-wilds ( hand -- n ) [ type-key ] [ "J" within length ] bi 2array { { { 0 1 } [ 1 ] } { { 1 1 } [ 3 ] } { { 1 2 } [ 3 ] } { { 2 1 } [ 4 ] } { { 2 2 } [ 5 ] } { { 3 1 } [ 5 ] } { { 3 3 } [ 5 ] } { { 4 2 } [ 6 ] } { { 4 3 } [ 6 ] } { { 5 1 } [ 6 ] } { { 5 4 } [ 6 ] } [ first ] } case ; : hand-compare-wilds ( hand1 hand2 -- <=> ) [ type-key-wilds ] [ card-key-wilds ] (hand-compare) ; : part2 ( -- ) [ hand-compare-wilds ] solve ;
Python
import collections from .solver import Solver _FIVE_OF_A_KIND = 0x100000 _FOUR_OF_A_KIND = 0x010000 _FULL_HOUSE = 0x001000 _THREE_OF_A_KIND = 0x000100 _TWO_PAIR = 0x000010 _ONE_PAIR = 0x000001 _CARD_ORDER = '23456789TJQKA' _CARD_ORDER_WITH_JOKER = 'J23456789TQKA' def evaluate_hand(hand: str, joker: bool = False) -> int: card_counts = collections.defaultdict(int) score = 0 for card in hand: card_counts[card] += 1 joker_count = 0 if joker: joker_count = card_counts['J'] del card_counts['J'] counts = sorted(card_counts.values(), reverse=True) top_non_joker_count = counts[0] if counts else 0 if top_non_joker_count + joker_count == 5: score |= _FIVE_OF_A_KIND elif top_non_joker_count + joker_count == 4: score |= _FOUR_OF_A_KIND elif top_non_joker_count + joker_count == 3: match counts, joker_count: case [3, 2], 0: score |= _FULL_HOUSE case [3, 1, 1], 0: score |= _THREE_OF_A_KIND case [2, 2], 1: score |= _FULL_HOUSE case [2, 1, 1], 1: score |= _THREE_OF_A_KIND case [1, 1, 1], 2: score |= _THREE_OF_A_KIND case _: raise RuntimeError(f'Unexpected card counts: {counts} with {joker_count} jokers') elif top_non_joker_count + joker_count == 2: match counts, joker_count: case [2, 2, 1], 0: score |= _TWO_PAIR case [2, 1, 1, 1], 0: score |= _ONE_PAIR case [1, 1, 1, 1], 1: score |= _ONE_PAIR case _: raise RuntimeError(f'Unexpected card counts: {counts} with {joker_count} jokers') card_order = _CARD_ORDER_WITH_JOKER if joker else _CARD_ORDER for card in hand: card_value = card_order.index(card) score <<= 4 score |= card_value return score class Day07(Solver): def __init__(self): super().__init__(7) self.hands: list[tuple[str, str]] = [] def presolve(self, input: str): lines = input.rstrip().split('\n') self.hands = list(map(lambda line: line.split(' '), lines)) def solve_first_star(self): hands = self.hands[:] hands.sort(key=lambda hand: evaluate_hand(hand[0])) total_score = 0 for rank, [_, bid] in enumerate(hands): total_score += (rank + 1) * int(bid) return total_score def solve_second_star(self): hands = self.hands[:] hands.sort(key=lambda hand: evaluate_hand(hand[0], True)) total_score = 0 for rank, [_, bid] in enumerate(hands): total_score += (rank + 1) * int(bid) return total_score