defmodule Poker do @doc """ Given a list of poker hands, return a list containing the highest scoring hand. If two or more hands tie, return the list of tied hands in the order they were received. The basic rules and hand rankings for Poker can be found at: https://en.wikipedia.org/wiki/List_of_poker_hands For this exercise, we'll consider the game to be using no Jokers, so five-of-a-kind hands will not be tested. We will also consider the game to be using multiple decks, so it is possible for multiple players to have identical cards. Aces can be used in low (A 2 3 4 5) or high (10 J Q K A) straights, but do not count as a high card in the former case. For example, (A 2 3 4 5) will lose to (2 3 4 5 6). You can also assume all inputs will be valid, and do not need to perform error checking when parsing card values. All hands will be a list of 5 strings, containing a number (or letter) for the rank, followed by the suit. Ranks (lowest to highest): 2 3 4 5 6 7 8 9 10 J Q K A Suits (order doesn't matter): C D H S Example hand: ~w(4S 5H 4C 5D 4H) # Full house, 5s over 4s """ @spec best_hand(list(list(String.t()))) :: list(list(String.t())) def best_hand(hands) do sorted_hands = hands |> Enum.map(&score_hand/1) |> Enum.sort(&sort_scored_hands/2) [{_, highest_score, highest_extra} | _] = sorted_hands highest_args = {highest_score, highest_extra} sorted_hands |> Enum.group_by(fn {_hand, score, extra} -> {score, extra} end) |> Map.get(highest_args) |> Enum.map(fn {hand, _score, _extra} -> hand end) end @ranks ~w(2 3 4 5 6 7 8 9 10 J Q K A) @suits ~w(clubs diamonds hearts spades)a @scores ~w(straight_flush four_of_a_kind full_house flush straight three_of_a_kind two_pair pair high_card)a for {rank, value} <- Enum.with_index(@ranks, 2), suit <- @suits do suit_char = suit |> to_string |> String.upcase() |> String.first() defp card(<>), do: {unquote(value), unquote(suit)} end defp score_hand(hand) do {ranks, suits} = hand |> Enum.map(&card/1) |> Enum.sort(&sort_rank_asc/2) |> Enum.unzip() flush = suits |> Enum.uniq() |> length |> Kernel.==(1) ranks |> Enum.group_by(fn x -> x end) |> Enum.into(%{}, fn {k, v} -> {k, length(v)} end) |> Enum.sort(&sort_count_then_rank_asc/2) |> score_hand(ranks, flush) |> Tuple.insert_at(0, hand) end defp score_hand(_, [2, 3, 4, 5, 14], true), do: {:straight_flush, {5}} defp score_hand(_, [2, 3, 4, 5, 14], _), do: {:straight, {5}} defp score_hand(counts, [low, _, _, _, high], true) when length(counts) == 5 and high - low == 4, do: {:straight_flush, {high}} defp score_hand(counts, [low, _, _, _, high], _) when length(counts) == 5 and high - low == 4, do: {:straight, {high}} defp score_hand(_, ranks, true), do: {:flush, {ranks |> Enum.sort() |> Enum.reverse()}} defp score_hand([{kicker, 1}, {high, 4}], _, _), do: {:four_of_a_kind, {high, kicker}} defp score_hand([{pair, 2}, {triplet, 3}], _, _), do: {:full_house, {triplet, pair}} defp score_hand([{kicker1, 1}, {kicker2, 1}, {triplet, 3}], _, _), do: {:three_of_a_kind, {triplet, [kicker1, kicker2] |> Enum.sort() |> Enum.reverse()}} defp score_hand([{kicker, 1}, {low_pair, 2}, {high_pair, 2}], _, _), do: {:two_pair, {high_pair, low_pair, kicker}} defp score_hand([{kicker1, 1}, {kicker2, 1}, {kicker3, 1}, {pair, 2}], _, _), do: {:pair, {pair, [kicker1, kicker2, kicker3] |> Enum.sort() |> Enum.reverse()}} defp score_hand(_, ranks, _), do: {:high_card, {ranks |> Enum.sort() |> Enum.reverse()}} defp sort_rank_asc({rank1, _}, {rank2, _}), do: rank1 <= rank2 defp sort_count_then_rank_asc({rank1, count1}, {rank2, count2}), do: count1 <= count2 and rank1 <= rank2 # Compare different scores against each other first for {score, index} <- @scores |> Enum.with_index(1) do for other_score <- @scores |> Enum.drop(index) do defp sort_scored_hands({_, unquote(score), _}, {_, unquote(other_score), _}), do: true defp sort_scored_hands({_, unquote(other_score), _}, {_, unquote(score), _}), do: false end end # Additional rules for tiebreakers # Straight flush tie determined by high card defp sort_scored_hands({_, :straight_flush, {high_a}}, {_, :straight_flush, {high_b}}), do: high_a >= high_b # 4-of-a-kind tie determined by rank, then by kicker defp sort_scored_hands({_, :four_of_a_kind, {rank_a, _}}, {_, :four_of_a_kind, {rank_b, _}}) when rank_a > rank_b, do: true defp sort_scored_hands({_, :four_of_a_kind, {rank_a, _}}, {_, :four_of_a_kind, {rank_b, _}}) when rank_a < rank_b, do: false defp sort_scored_hands( {_, :four_of_a_kind, {_, kicker_a}}, {_, :four_of_a_kind, {_, kicker_b}} ), do: kicker_a >= kicker_b # Full house tie determined by triplet, then pair defp sort_scored_hands({_, :full_house, {triplet_a, _}}, {_, :full_house, {triplet_b, _}}) when triplet_a > triplet_b, do: true defp sort_scored_hands({_, :full_house, {triplet_a, _}}, {_, :full_house, {triplet_b, _}}) when triplet_a < triplet_b, do: false defp sort_scored_hands({_, :full_house, {_, pair_a}}, {_, :full_house, {_, pair_b}}), do: pair_a >= pair_b # Flush tie determined by high card, comparing all 5 if necessary defp sort_scored_hands({_, :flush, {ranks_a}}, {_, :flush, {ranks_b}}), do: ranks_a >= ranks_b # Straight tie determined by high card defp sort_scored_hands({_, :straight, {high_a}}, {_, :straight, {high_b}}), do: high_a >= high_b # 3-of-a-kind tie determined by triplet, then by high card, comparing both if necessary defp sort_scored_hands( {_, :three_of_a_kind, {triplet_a, _}}, {_, :three_of_a_kind, {triplet_b, _}} ) when triplet_a > triplet_b, do: true defp sort_scored_hands( {_, :three_of_a_kind, {triplet_a, _}}, {_, :three_of_a_kind, {triplet_b, _}} ) when triplet_a < triplet_b, do: false defp sort_scored_hands( {_, :three_of_a_kind, {_, ranks_a}}, {_, :three_of_a_kind, {_, ranks_b}} ), do: ranks_a >= ranks_b # Two-pair tie determined by high pair, then low pair, then by kicker defp sort_scored_hands({_, :two_pair, {high_a, _, _}}, {_, :two_pair, {high_b, _, _}}) when high_a > high_b, do: true defp sort_scored_hands({_, :two_pair, {high_a, _, _}}, {_, :two_pair, {high_b, _, _}}) when high_a < high_b, do: false defp sort_scored_hands({_, :two_pair, {_, low_a, _}}, {_, :two_pair, {_, low_b, _}}) when low_a > low_b, do: true defp sort_scored_hands({_, :two_pair, {_, low_a, _}}, {_, :two_pair, {_, low_b, _}}) when low_a < low_b, do: false defp sort_scored_hands({_, :two_pair, {_, _, kicker_a}}, {_, :two_pair, {_, _, kicker_b}}), do: kicker_a >= kicker_b # Pair tie determined by pair rank, then by high card, comparing all 3 if necessary defp sort_scored_hands({_, :pair, {pair_a, _}}, {_, :pair, {pair_b, _}}) when pair_a > pair_b, do: true defp sort_scored_hands({_, :pair, {pair_a, _}}, {_, :pair, {pair_b, _}}) when pair_a < pair_b, do: false defp sort_scored_hands({_, :pair, {_, kickers_a}}, {_, :pair, {_, kickers_b}}), do: kickers_a >= kickers_b # High-card tie determined by high card, comparing all 5 if necessary defp sort_scored_hands({_, :high_card, {ranks_a}}, {_, :high_card, {ranks_b}}), do: ranks_a >= ranks_b end