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.

• Day 7, part 1
• Day 7, part 1 second attempt
• Day 7, 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.nim

Part 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