trackler 2.0.8.19 → 2.0.8.20

data/tracks/elixir/config.json

@@ -27,6 +27,14 @@
         "string processing"
       ]
     },
+    {
+      "slug": "protein-translation",
+      "difficulty": 2,
+      "topics": [
+        "pattern matching",
+        "string processing"
+      ]
+    },
     {
       "slug": "space-age",
       "difficulty": 2,
@@ -400,6 +408,13 @@
       "topics": [
       ]
     },
+    {
+      "slug": "poker",
+      "difficulty": 7,
+      "topics": [
+        "sorting"
+      ]
+    },
     {
       "slug": "bowling",
       "difficulty": 8,
@@ -442,6 +457,13 @@
         "Strings",
         "Enumerations"
       ]
+    },
+    {
+      "slug": "say",
+      "difficulty": 3,
+      "topics": [
+        "Pattern Matching"
+      ]
     }
   ],
   "deprecated": [

data/tracks/elixir/exercises/poker/example.exs

@@ -0,0 +1,136 @@
+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(<< unquote(rank), unquote(suit_char) >>), 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
+

data/tracks/elixir/exercises/poker/poker.exs

@@ -0,0 +1,34 @@
+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
+  end
+end
+

data/tracks/elixir/exercises/poker/poker_test.exs

@@ -0,0 +1,217 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("poker.exs", __DIR__)
+end
+
+ExUnit.start
+ExUnit.configure exclude: :pending, trace: true
+
+defmodule PokerTest do
+  use ExUnit.Case
+
+  #@tag :pending
+  test "single hand always wins" do
+    high_of_jack = ~w(4S 5S 7H 8D JC)
+    assert Poker.best_hand([high_of_jack]) == [high_of_jack]
+  end
+
+  @tag :pending
+  test "highest card out of all hands wins" do
+    high_of_8 = ~w(4D 5S 6S 8D 3C)
+    high_of_10 = ~w(2S 4C 7S 9H 10H)
+    high_of_jack = ~w(3S 4S 5D 6H JH)
+    assert Poker.best_hand([high_of_8, high_of_10, high_of_jack]) == [high_of_jack]
+  end
+
+  @tag :pending
+  test "a tie has multiple winners" do
+    high_of_8 = ~w(4D 5S 6S 8D 3C)
+    high_of_10 = ~w(2S 4C 7S 9H 10H)
+    high_of_jack = ~w(3S 4S 5D 6H JH)
+    another_high_of_jack = ~w(3H 4H 5C 6C JD)
+
+    hands = [high_of_8, high_of_10, high_of_jack, another_high_of_jack]
+    assert Poker.best_hand(hands) == [high_of_jack, another_high_of_jack]
+  end
+
+  @tag :pending
+  test "multiple hands with the same high cards, tie compares next highest ranked, down to last card" do
+    high_of_8_low_of_3 = ~w(3S 5H 6S 8D 7H)
+    high_of_8_low_of_2 = ~w(2S 5D 6D 8C 7S)
+    assert Poker.best_hand([high_of_8_low_of_3, high_of_8_low_of_2]) == [high_of_8_low_of_3]
+  end
+
+  @tag :pending
+  test "one pair beats high card" do
+    high_of_king = ~w(4S 5H 6C 8D KH)
+    pair_of_4 = ~w(2S 4H 6S 4D JH)
+    assert Poker.best_hand([high_of_king, pair_of_4]) == [pair_of_4]
+  end
+
+  @tag :pending
+  test "highest pair wins" do
+    pair_of_2 = ~w(4S 2H 6S 2D JH)
+    pair_of_4 = ~w(2S 4H 6C 4D JD)
+    assert Poker.best_hand([pair_of_2, pair_of_4]) == [pair_of_4]
+  end
+
+  @tag :pending
+  test "two pairs beats one pair" do
+    pair_of_8 = ~w(2S 8H 6S 8D JH)
+    fives_and_fours = ~w(4S 5H 4C 8C 5C)
+    assert Poker.best_hand([pair_of_8, fives_and_fours]) == [fives_and_fours]
+  end
+
+  @tag :pending
+  test "both hands have two pairs, highest ranked pair wins" do
+    eights_and_twos = ~w(2S 8H 2D 8D 3H)
+    fives_and_fours = ~w(4S 5H 4C 8S 5D)
+    assert Poker.best_hand([eights_and_twos, fives_and_fours]) == [eights_and_twos]
+  end
+
+  @tag :pending
+  test "both hands have two pairs, with the same highest ranked pair, tie goes to low pair" do
+    queens_and_twos = ~w(2S QS 2C QD JH)
+    queens_and_jacks = ~w(JD QH JS 8D QC)
+    assert Poker.best_hand([queens_and_twos, queens_and_jacks]) == [queens_and_jacks]
+  end
+
+  @tag :pending
+  test "both hands have two identically ranked pairs, tie goes to remaining card (kicker)" do
+    queens_jacks_and_8 = ~w(JD QH JS 8D QC)
+    queens_jacks_and_2 = ~w(JS QS JC 2D QD)
+    assert Poker.best_hand([queens_jacks_and_8, queens_jacks_and_2]) == [queens_jacks_and_8]
+  end
+
+  @tag :pending
+  test "three of a kind beats two pair" do
+    eights_and_twos = ~w(2S 8H 2H 8D JH)
+    three_fours = ~w(4S 5H 4C 8S 4H)
+    assert Poker.best_hand([eights_and_twos, three_fours]) == [three_fours]
+  end
+
+  @tag :pending
+  test "both hands have three of a kind, tie goes to highest ranked triplet" do
+    three_twos = ~w(2S 2H 2C 8D JH)
+    three_aces = ~w(4S AH AS 8C AD)
+    assert Poker.best_hand([three_twos, three_aces]) == [three_aces]
+  end
+
+  @tag :pending
+  test "with multiple decks, two players can have same three of a kind, ties go to highest remaining cards" do
+    three_aces_7_high = ~w(4S AH AS 7C AD)
+    three_aces_8_high = ~w(4S AH AS 8C AD)
+    assert Poker.best_hand([three_aces_7_high, three_aces_8_high]) == [three_aces_8_high]
+
+    three_aces_8_high_5_low = ~w(5S AH AS 8C AD)
+    assert Poker.best_hand([three_aces_8_high_5_low, three_aces_8_high]) == [three_aces_8_high_5_low]
+  end
+
+  @tag :pending
+  test "a straight beats three of a kind" do
+    three_fours = ~w(4S 5H 4C 8D 4H)
+    straight = ~w(3S 4D 2S 6D 5C)
+    assert Poker.best_hand([three_fours, straight]) == [straight]
+  end
+
+  @tag :pending
+  test "aces can be end a straight (10 J Q K A)" do
+    three_fours = ~w(4S 5H 4C 8D 4H)
+    straight_to_ace = ~w(10D JH QS KD AC)
+    assert Poker.best_hand([three_fours, straight_to_ace]) == [straight_to_ace]
+  end
+
+  @tag :pending
+  test "aces can be start a straight (A 2 3 4 5)" do
+    three_fours = ~w(4S 5H 4C 8D 4H)
+    straight_to_5 = ~w(4D AH 3S 2D 5C)
+    assert Poker.best_hand([three_fours, straight_to_5]) == [straight_to_5]
+  end
+
+  @tag :pending
+  test "both hands with a straight, tie goes to highest ranked card" do
+    straight_to_8 = ~w(4S 6C 7S 8D 5H)
+    straight_to_9 = ~w(5S 7H 8S 9D 6H)
+    assert Poker.best_hand([straight_to_8, straight_to_9]) == [straight_to_9]
+  end
+
+  @tag :pending
+  test "even though an ace is usually high, a 5-high straight is the lowest-scoring straight" do
+    straight_to_6 = ~w(2H 3C 4D 5D 6H)
+    straight_to_5 = ~w(4S AH 3S 2D 5H)
+    assert Poker.best_hand([straight_to_6, straight_to_5]) == [straight_to_6]
+  end
+
+  @tag :pending
+  test "straight beats a flush" do
+    straight_to_8 = ~w(4C 6H 7D 8D 5H)
+    flush_to_7 = ~w(2S 4S 5S 6S 7S)
+    assert Poker.best_hand([straight_to_8, flush_to_7]) == [flush_to_7]
+  end
+
+  @tag :pending
+  test "both hands have a flush, tie goes to high card, down to the last one if necessary" do
+    flush_to_9 = ~w(4H 7H 8H 9H 6H)
+    flush_to_7 = ~w(2S 4S 5S 6S 7S)
+    assert Poker.best_hand([flush_to_9, flush_to_7]) == [flush_to_9]
+
+    flush_to_9_with_4_matches = ~w(3S 6S 7S 8S 9S)
+    assert Poker.best_hand([flush_to_9, flush_to_9_with_4_matches]) == [flush_to_9]
+  end
+
+  @tag :pending
+  test "full house beats a flush" do
+    flush_to_8 = ~w(3H 6H 7H 8H 5H)
+    full = ~w(4S 5H 4C 5D 4H)
+    assert Poker.best_hand([flush_to_8, full]) == [full]
+  end
+
+  @tag :pending
+  test "both hands have a full house, tie goes to highest-ranked triplet" do
+    full_of_4_by_9 = ~w(4H 4S 4D 9S 9D)
+    full_of_5_by_8 = ~w(5H 5S 5D 8S 8D)
+    assert Poker.best_hand([full_of_4_by_9, full_of_5_by_8]) == [full_of_5_by_8]
+  end
+
+  @tag :pending
+  test "with multiple decks, both hands have a full house with the same triplet, tie goes to the pair" do
+    full_of_5_by_9 = ~w(5H 5S 5D 9S 9D)
+    full_of_5_by_8 = ~w(5H 5S 5D 8S 8D)
+    assert Poker.best_hand([full_of_5_by_9, full_of_5_by_8]) == [full_of_5_by_9]
+  end
+
+  @tag :pending
+  test "four of a kind beats a full house" do
+    full = ~w(4S 5H 4D 5D 4H)
+    four_3s = ~w(3S 3H 2S 3D 3C)
+    assert Poker.best_hand([four_3s, full]) == [four_3s]
+  end
+
+  @tag :pending
+  test "both hands have four of a kind, tie goes to high quad" do
+    four_2s = ~w(2S 2H 2C 8D 2D)
+    four_5s = ~w(4S 5H 5S 5D 5C)
+    assert Poker.best_hand([four_2s, four_5s]) == [four_5s]
+  end
+
+  @tag :pending
+  test "with multiple decks, both hands with identical four of a kind, tie determined by kicker" do
+    four_3s_and_2 = ~w(3S 3H 2S 3D 3C)
+    four_3s_and_4 = ~w(3S 3H 4S 3D 3C)
+    assert Poker.best_hand([four_3s_and_2, four_3s_and_4]) == [four_3s_and_4]
+  end
+
+  @tag :pending
+  test "straight flush beats four of a kind" do
+    four_5s = ~w(4S 5H 5S 5D 5C)
+    straight_flush_to_10 = ~w(7S 8S 9S 6S 10S)
+    assert Poker.best_hand([four_5s, straight_flush_to_10]) == [straight_flush_to_10]
+  end
+
+  @tag :pending
+  test "both hands have straight flush, tie goes to highest-ranked card" do
+    straight_flush_to_8 = ~w(4H 6H 7H 8H 5H)
+    straight_flush_to_9 = ~w(5S 7S 8S 9S 6S)
+    assert Poker.best_hand([straight_flush_to_8, straight_flush_to_9]) == [straight_flush_to_9]
+  end
+end
+

data/tracks/elixir/exercises/protein-translation/example.exs

@@ -0,0 +1,62 @@
+defmodule ProteinTranslation do
+  @doc """
+  Given an RNA string, return a list of proteins specified by codons, in order.
+  """
+  @spec of_rna(String.t()) :: { atom, list(String.t()) }
+  def of_rna(rna) do
+    translate_rna(rna, [])
+  end
+
+  @doc """
+  Given a codon, return the corresponding protein
+
+  UGU -> Cysteine
+  UGC -> Cysteine
+  UUA -> Leucine
+  UUG -> Leucine
+  AUG -> Methionine
+  UUU -> Phenylalanine
+  UUC -> Phenylalanine
+  UCU -> Serine
+  UCC -> Serine
+  UCA -> Serine
+  UCG -> Serine
+  UGG -> Tryptophan
+  UAU -> Tyrosine
+  UAC -> Tyrosine
+  UAA -> STOP
+  UAG -> STOP
+  UGA -> STOP
+  """
+  @spec of_codon(String.t()) :: { atom, String.t() }
+  def of_codon(codon) do
+    translate_codon(codon)
+  end
+
+  @codons %{
+    "Methionine" => ~w(AUG),
+    "Phenylalanine" => ~w(UUU UUC),
+    "Leucine" => ~w(UUA UUG),
+    "Serine" => ~w(UCU UCC UCA UCG),
+    "Tyrosine" => ~w(UAU UAC),
+    "Cysteine" => ~w(UGU UGC),
+    "Tryptophan" => ~w(UGG),
+  }
+  @stop ~w(UAA UAG UGA)
+
+  defp translate_rna("", results), do: { :ok, Enum.reverse(results) }
+
+  for codon <- @stop do
+    defp translate_rna(unquote(codon) <> _rest, results), do: { :ok, Enum.reverse(results) }
+    defp translate_codon(unquote(codon)), do: { :ok, "STOP" }
+  end
+
+  for { protein, codons } <- @codons, codon <- codons do
+    defp translate_rna(unquote(codon) <> rest, results), do: translate_rna(rest, [unquote(protein) | results])
+    defp translate_codon(unquote(codon)), do: { :ok, unquote(protein) }
+  end
+
+  defp translate_rna(_, _), do: { :error, "invalid RNA"}
+  defp translate_codon(_), do: { :error, "invalid codon"}
+end
+