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

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 ;

deleted by creator

deleted by creator