Love all the pattern matching solutions in this thread! I did not do that 
I tried writing out all the different joker cases for each type of hand and ended up hard-coding them since there weren’t that many.
https://github.com/midouest/advent-of-code-2023/blob/main/notebooks/day07.livemd
My beginner’s solution, Day 7 part 1
defmodule Day07 do
def part1(input) do
parse(input)
|> Enum.sort_by(&(&1.hand), &compare/2)
|> Enum.map(&(&1.bid))
|> Enum.with_index(1)
|> Enum.map(fn {bid, rank} -> bid * rank end)
|> Enum.sum
end
def compare(hand1, hand2) do
l1 = [hand_type(hand1) | hand1]
l2 = [hand_type(hand2) | hand2]
l1 <= l2
end
def hand_type(hand) do
hand
|> Enum.frequencies
|> Map.values
|> Enum.sort(:desc)
|> case do
[5] -> 6 # Five of a kind
[4, 1] -> 5 # Four of a kind
[3, 2] -> 4 # Full house
[3, 1, 1] -> 3 # Three of a kind
[2, 2, 1] -> 2 # Two pair
[2, 1, 1, 1] -> 1 # One Pair
[1, 1, 1, 1, 1] -> 0 # High card
end
end
def parse(raw_list) do
for raw_line <- String.split(raw_list, "\n") do
[raw_hand, raw_bid] = String.split(raw_line)
bid = String.to_integer(raw_bid)
hand = raw_hand
|> String.graphemes
|> Enum.map(fn raw_card ->
case raw_card do
"A" -> 14
"K" -> 13
"Q" -> 12
"J" -> 11
"T" -> 10
x -> String.to_integer(x)
end
end)
%{hand: hand, bid: bid}
end
end
end
My strategy for part 2 was to count the jokers in each hand, remove them from the hand, then count up the other cards. The most frequent card would then get its quantity increased by the joker count:
joker_count = Enum.count(hand, fn card -> part_2? and card == "J" end)
freqs =
hand
|> Enum.reject(fn card -> part_2? and card == "J" end)
|> Enum.frequencies()
|> Enum.sort_by(fn {_k, v} -> v end, :desc)
|> List.update_at(0, fn {card, count} -> {card, count + joker_count} end)
Full solution here on Github
Nothing special about my solution to this one. Felt like it was pretty straight-forward. I’m still running couple days behind and unlikely to catch up due to my day job this weekend. I wanted to do some clever binary pattern matching on parsing the input but it just didn’t seem to warrant the effort. Had the same approach to part 2 as @APB9785
defmodule Day7 do
@moduledoc """
Day7 AoC Solutions
"""
alias AocToolbox.Input
def input(:test),
do: """
32T3K 765
T55J5 684
KK677 28
KTJJT 220
QQQJA 483
"""
def input(:real), do: Input.load(__DIR__ <> "/input.txt")
def solve(1, mode) do
Day7.Part1.solve(input(mode))
end
def solve(2, mode) do
Day7.Part2.solve(input(mode))
end
def high_card(), do: 1
def one_pair(), do: 2
def two_pair(), do: 3
def three_of_a_kind(), do: 4
def full_house(), do: 5
def four_of_a_kind(), do: 6
def yahtzee(), do: 7
defmodule Part1 do
@face_card_map %{"T" => ":", "J" => ";", "Q" => "<", "K" => "=", "A" => ">"}
def solve(input) do
input
|> parse()
|> rank_hands()
|> calc_winnings()
end
def parse(input, face_card_map \\ @face_card_map) do
input
|> replace_face_cards(face_card_map)
|> String.trim()
|> String.split("\n")
|> Enum.map(&String.split/1)
|> Enum.map(fn [hand, bid] -> [hand, String.to_integer(bid)] end)
end
defp replace_face_cards(input, face_card_map) do
input
|> String.graphemes()
|> Enum.map(fn g ->
case Map.fetch(face_card_map, g) do
{:ok, c} -> c
_ -> g
end
end)
|> Enum.join()
end
defp rank_hands(hands) when is_list(hands) do
hands
|> Enum.map(&hand_value/1)
|> Enum.sort()
end
defp hand_value([hand, bid]) when is_binary(hand) do
hand
|> String.graphemes()
|> Enum.group_by(&Function.identity/1)
|> apply_value(hand, bid)
end
defp apply_value(groups, hand, bid) when is_map(groups) do
sets = map_size(groups)
cond do
sets == 1 -> {{7, hand}, bid}
sets == 2 -> {{four_of_a_kind_or_full_house(groups), hand}, bid}
sets == 3 -> {{three_of_a_kind_or_two_pair(groups), hand}, bid}
sets == 4 -> {{2, hand}, bid}
sets == 5 -> {{1, hand}, bid}
end
end
defp four_of_a_kind_or_full_house(groups) do
groups
|> Map.values()
|> Enum.map(&length/1)
|> Enum.max()
|> maybe_full_house()
end
defp maybe_full_house(4), do: 6
defp maybe_full_house(3), do: 5
defp three_of_a_kind_or_two_pair(groups) do
groups
|> Map.values()
|> Enum.map(&length/1)
|> Enum.max()
|> maybe_two_pair()
end
defp maybe_two_pair(3), do: 4
defp maybe_two_pair(2), do: 3
defp calc_winnings(ranked_hands) do
ranked_hands
|> Enum.with_index(1)
|> Enum.reduce(0, fn {{_, bid}, ndx}, acc -> acc + bid * ndx end)
end
end
defmodule Part2 do
@face_card_map %{"T" => ":", "J" => "0", "Q" => "<", "K" => "=", "A" => ">"}
def solve(input) do
input
|> parse()
|> rank_hands()
|> calc_winnings()
end
defp parse(input) do
Part1.parse(input, @face_card_map)
end
defp rank_hands(hands) when is_list(hands) do
hands
|> Enum.map(fn [hand, bid] -> {{set_rank(hand), hand}, bid} end)
|> Enum.sort()
end
defp set_rank(hand) when is_binary(hand) do
hand
|> String.graphemes()
|> Enum.group_by(&Function.identity/1)
|> calc_rank()
end
defp calc_rank(groups) when is_map(groups) do
sets = map_size(groups)
jokers = Map.get(groups, "0", []) |> length()
cond do
sets == 1 -> Day7.yahtzee()
sets == 2 and jokers > 0 -> Day7.yahtzee()
sets == 2 -> four_of_a_kind_or_full_house(groups)
# two singles plus 3 jokers to make a 4 of a kind
sets == 3 and jokers == 3 -> Day7.four_of_a_kind()
sets == 3 and jokers > 0 -> four_of_a_kind_or_full_house_bc_joker(groups, jokers)
sets == 3 -> three_of_a_kind_or_two_pair(groups)
sets == 4 and jokers > 0 -> Day7.three_of_a_kind()
sets == 4 -> Day7.one_pair()
sets == 5 and jokers == 1 -> Day7.one_pair()
sets == 5 -> Day7.high_card()
true -> raise "cheater"
end
end
defp four_of_a_kind_or_full_house(groups) do
set_sizes = groups |> Map.values() |> Enum.map(&length/1) |> MapSet.new()
if set_sizes == MapSet.new([3, 2]) do
Day7.full_house()
else
Day7.four_of_a_kind()
end
end
defp four_of_a_kind_or_full_house_bc_joker(groups, jokers) when map_size(groups) == 3 do
set_sizes = groups |> Map.drop(["0"]) |> Map.values() |> Enum.map(&length/1) |> MapSet.new()
cond do
MapSet.member?(set_sizes, 3) and jokers == 1 ->
# if you have 3 of a kind and one joker you get 4 of a kind
Day7.four_of_a_kind()
jokers == 1 ->
# 3 sets, 1 joker, means two pairs of non-jokers, use joker to make full house
Day7.full_house()
jokers == 2 ->
# pair of jokers, 3 sets, means one pair of non-jokers, use jokers to make 4 of a kind
Day7.four_of_a_kind()
# this covers all conditions because only called for groups == 3
end
end
defp three_of_a_kind_or_two_pair(groups) do
set_sizes = groups |> Map.values() |> Enum.map(&length/1) |> MapSet.new()
if MapSet.member?(set_sizes, 3) do
Day7.three_of_a_kind()
else
Day7.two_pair()
end
end
defp calc_winnings(ranked_hands) do
ranked_hands
|> Enum.with_index(1)
|> Enum.reduce(0, fn {{_, bid}, ndx}, acc -> acc + bid * ndx end)
end
end
end
For this one, the part I most liked about my code was the way to identify the hand type, where I counted each letter of a hand, then I got the counts and sorted them and the final step was a pattern matching to identify the hand type.
def get_hand_type(hand) do
hand
|> String.graphemes()
|> Enum.reduce(%{}, fn char, acc -> Map.update(acc, char, 1, &(&1 + 1)) end)
|> Map.values()
|> Enum.sort()
|> Enum.join()
|> do_get_hand_type()
end
defp do_get_hand_type("5"), do: :five_of_a_kind
defp do_get_hand_type("14"), do: :four_of_a_kind
defp do_get_hand_type("23"), do: :full_house
defp do_get_hand_type("113"), do: :three_of_a_kind
defp do_get_hand_type("122"), do: :two_pairs
defp do_get_hand_type("1112"), do: :one_pair
defp do_get_hand_type("11111"), do: :high_card
Full solution:
https://github.com/tiagoavila/advent_of_code_2023/blob/main/lib/day_seven.ex