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


🔒 Thread is locked until there’s at least 100 2 star entries on the global leaderboard

🔓 Thread has been unlocked after around 20 mins

  • cacheson@kbin.social
    link
    fedilink
    arrow-up
    1
    ·
    11 months ago

    Nim

    I wrote some nice code for sorting poker hands, just defining the < and == operations for my CardSet and Hand 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.

  • janAkali@lemmy.one
    link
    fedilink
    English
    arrow-up
    1
    ·
    edit-2
    11 months ago

    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.nim

  • capitalpb@programming.dev
    link
    fedilink
    English
    arrow-up
    1
    ·
    11 months ago

    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()
        }
    }
    
  • Andy@programming.dev
    link
    fedilink
    arrow-up
    1
    ·
    edit-2
    11 months ago

    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 ;
    
  • hades@lemm.ee
    link
    fedilink
    arrow-up
    1
    ·
    edit-2
    3 months ago

    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