trackler 2.2.1.109 → 2.2.1.110

data/tracks/elixir/exercises/phone-number/phone_number.exs

@@ -22,7 +22,7 @@ defmodule Phone do
   iex> Phone.number("867.5309")
   "0000000000"
   """
-  @spec number(String.t) :: String.t
+  @spec number(String.t()) :: String.t()
   def number(raw) do
   end
 
@@ -46,7 +46,7 @@ defmodule Phone do
   iex> Phone.area_code("867.5309")
   "000"
   """
-  @spec area_code(String.t) :: String.t
+  @spec area_code(String.t()) :: String.t()
   def area_code(raw) do
   end
 
@@ -70,7 +70,7 @@ defmodule Phone do
   iex> Phone.pretty("867.5309")
   "(000) 000-0000"
   """
-  @spec pretty(String.t) :: String.t
+  @spec pretty(String.t()) :: String.t()
   def pretty(raw) do
   end
 end

data/tracks/elixir/exercises/phone-number/phone_number_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("phone_number.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule PhoneTest do
   use ExUnit.Case

data/tracks/elixir/exercises/pig-latin/pig_latin.exs

@@ -17,4 +17,3 @@ defmodule PigLatin do
   def translate(phrase) do
   end
 end
-

data/tracks/elixir/exercises/pig-latin/pig_latin_test.exs

@@ -2,14 +2,14 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("pig_latin.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule PigLatinTest do
   use ExUnit.Case
 
   describe "ay is added to words that start with vowels" do
-    #@tag :pending
+    # @tag :pending
     test "word beginning with a" do
       assert PigLatin.translate("apple") == "appleay"
     end

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

@@ -29,9 +29,10 @@ defmodule Poker do
   """
   @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)
+    sorted_hands =
+      hands
+      |> Enum.map(&score_hand/1)
+      |> Enum.sort(&sort_scored_hands/2)
 
     [{_, highest_score, highest_extra} | _] = sorted_hands
 
@@ -47,19 +48,21 @@ defmodule Poker do
   @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
+  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)}
+    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
+    {ranks, suits} =
+      hand
+      |> Enum.map(&card/1)
+      |> Enum.sort(&sort_rank_asc/2)
+      |> Enum.unzip()
 
-    flush = suits |> Enum.uniq |> length |> Kernel.==(1)
+    flush = suits |> Enum.uniq() |> length |> Kernel.==(1)
 
     ranks
     |> Enum.group_by(fn x -> x end)
@@ -71,41 +74,70 @@ defmodule Poker do
 
   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(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 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
+
+  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
+      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
+  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
+  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
+  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
@@ -114,23 +146,54 @@ defmodule Poker do
   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
+  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
+  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
+  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
+  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

@@ -31,4 +31,3 @@ defmodule Poker do
   def best_hand(hands) do
   end
 end
-

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

@@ -2,13 +2,13 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("poker.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule PokerTest do
   use ExUnit.Case
 
-  #@tag :pending
+  # @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]
@@ -103,7 +103,10 @@ defmodule PokerTest do
     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]
+
+    assert Poker.best_hand([three_aces_8_high_5_low, three_aces_8_high]) == [
+             three_aces_8_high_5_low
+           ]
   end
 
   @tag :pending
@@ -214,4 +217,3 @@ defmodule PokerTest do
     assert Poker.best_hand([straight_flush_to_8, straight_flush_to_9]) == [straight_flush_to_9]
   end
 end
-

data/tracks/elixir/exercises/prime-factors/example.exs

@@ -4,12 +4,8 @@ defmodule PrimeFactors do
     do_factors(number, 2, [])
   end
 
-  defp do_factors(1, _, acc),
-    do: Enum.reverse(acc)
-  defp do_factors(n, i, acc) when n < i * i,
-    do: Enum.reverse(acc, [n])
-  defp do_factors(n, i, acc) when rem(n, i) == 0,
-    do: do_factors(div(n, i), i, [i | acc])
-  defp do_factors(n, i, acc),
-    do: do_factors(n, i + 1, acc)
+  defp do_factors(1, _, acc), do: Enum.reverse(acc)
+  defp do_factors(n, i, acc) when n < i * i, do: Enum.reverse(acc, [n])
+  defp do_factors(n, i, acc) when rem(n, i) == 0, do: do_factors(div(n, i), i, [i | acc])
+  defp do_factors(n, i, acc), do: do_factors(n, i + 1, acc)
 end

data/tracks/elixir/exercises/prime-factors/prime_factors.exs

@@ -9,6 +9,5 @@ defmodule PrimeFactors do
   """
   @spec factors_for(pos_integer) :: [pos_integer]
   def factors_for(number) do
-
   end
 end

data/tracks/elixir/exercises/prime-factors/prime_factors_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("prime_factors.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule PrimeFactorsTest do
   use ExUnit.Case
@@ -55,12 +55,12 @@ defmodule PrimeFactorsTest do
 
   @tag :pending
   test "901255" do
-    assert PrimeFactors.factors_for(901255) == [5, 17, 23, 461]
+    assert PrimeFactors.factors_for(901_255) == [5, 17, 23, 461]
   end
 
   @tag :pending
   test "93819012551" do
-    assert PrimeFactors.factors_for(93819012551) == [11, 9539, 894119]
+    assert PrimeFactors.factors_for(93_819_012_551) == [11, 9539, 894_119]
   end
 
   @tag :pending
@@ -70,6 +70,6 @@ defmodule PrimeFactorsTest do
   # in under two sconds. Uncomment it if you want to test the efficiency of your
   # solution.
   test "10000000055" do
-    assert PrimeFactors.factors_for(10000000055) == [5, 2000000011]
+    assert PrimeFactors.factors_for(10_000_000_055) == [5, 2_000_000_011]
   end
 end

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

@@ -2,7 +2,7 @@ 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()) }
+  @spec of_rna(String.t()) :: {atom, list(String.t())}
   def of_rna(rna) do
     translate_rna(rna, [])
   end
@@ -28,7 +28,7 @@ defmodule ProteinTranslation do
   UAG -> STOP
   UGA -> STOP
   """
-  @spec of_codon(String.t()) :: { atom, String.t() }
+  @spec of_codon(String.t()) :: {atom, String.t()}
   def of_codon(codon) do
     translate_codon(codon)
   end
@@ -40,23 +40,25 @@ defmodule ProteinTranslation do
     "Serine" => ~w(UCU UCC UCA UCG),
     "Tyrosine" => ~w(UAU UAC),
     "Cysteine" => ~w(UGU UGC),
-    "Tryptophan" => ~w(UGG),
+    "Tryptophan" => ~w(UGG)
   }
   @stop ~w(UAA UAG UGA)
 
-  defp translate_rna("", results), do: { :ok, Enum.reverse(results) }
+  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" }
+    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) }
+  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"}
+  defp translate_rna(_, _), do: {:error, "invalid RNA"}
+  defp translate_codon(_), do: {:error, "invalid codon"}
 end
-

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

@@ -2,7 +2,7 @@ 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()) }
+  @spec of_rna(String.t()) :: {atom, list(String.t())}
   def of_rna(rna) do
   end
 
@@ -27,8 +27,7 @@ defmodule ProteinTranslation do
   UAG -> STOP
   UGA -> STOP
   """
-  @spec of_codon(String.t()) :: { atom, String.t() }
+  @spec of_codon(String.t()) :: {atom, String.t()}
   def of_codon(codon) do
   end
 end
-

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

@@ -2,91 +2,91 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("protein_translation.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule ProteinTranslationTest do
   use ExUnit.Case
 
-  #@tag :pending
+  # @tag :pending
   test "AUG translates to methionine" do
-    assert ProteinTranslation.of_codon("AUG") == { :ok, "Methionine" }
+    assert ProteinTranslation.of_codon("AUG") == {:ok, "Methionine"}
   end
 
   @tag :pending
   test "identifies Phenylalanine codons" do
-    assert ProteinTranslation.of_codon("UUU") == { :ok, "Phenylalanine" }
-    assert ProteinTranslation.of_codon("UUC") == { :ok, "Phenylalanine" }
+    assert ProteinTranslation.of_codon("UUU") == {:ok, "Phenylalanine"}
+    assert ProteinTranslation.of_codon("UUC") == {:ok, "Phenylalanine"}
   end
 
   @tag :pending
   test "identifies Leucine codons" do
-    assert ProteinTranslation.of_codon("UUA") == { :ok, "Leucine" }
-    assert ProteinTranslation.of_codon("UUG") == { :ok, "Leucine" }
+    assert ProteinTranslation.of_codon("UUA") == {:ok, "Leucine"}
+    assert ProteinTranslation.of_codon("UUG") == {:ok, "Leucine"}
   end
 
   @tag :pending
   test "identifies Serine codons" do
-    assert ProteinTranslation.of_codon("UCU") == { :ok, "Serine" }
-    assert ProteinTranslation.of_codon("UCC") == { :ok, "Serine" }
-    assert ProteinTranslation.of_codon("UCA") == { :ok, "Serine" }
-    assert ProteinTranslation.of_codon("UCG") == { :ok, "Serine" }
+    assert ProteinTranslation.of_codon("UCU") == {:ok, "Serine"}
+    assert ProteinTranslation.of_codon("UCC") == {:ok, "Serine"}
+    assert ProteinTranslation.of_codon("UCA") == {:ok, "Serine"}
+    assert ProteinTranslation.of_codon("UCG") == {:ok, "Serine"}
   end
 
   @tag :pending
   test "identifies Tyrosine codons" do
-    assert ProteinTranslation.of_codon("UAU") == { :ok, "Tyrosine" }
-    assert ProteinTranslation.of_codon("UAC") == { :ok, "Tyrosine" }
+    assert ProteinTranslation.of_codon("UAU") == {:ok, "Tyrosine"}
+    assert ProteinTranslation.of_codon("UAC") == {:ok, "Tyrosine"}
   end
 
   @tag :pending
   test "identifies Cysteine codons" do
-    assert ProteinTranslation.of_codon("UGU") == { :ok, "Cysteine" }
-    assert ProteinTranslation.of_codon("UGC") == { :ok, "Cysteine" }
+    assert ProteinTranslation.of_codon("UGU") == {:ok, "Cysteine"}
+    assert ProteinTranslation.of_codon("UGC") == {:ok, "Cysteine"}
   end
 
   @tag :pending
   test "identifies Tryptophan codons" do
-    assert ProteinTranslation.of_codon("UGG") == { :ok, "Tryptophan" }
+    assert ProteinTranslation.of_codon("UGG") == {:ok, "Tryptophan"}
   end
 
   @tag :pending
   test "identifies stop codons" do
-    assert ProteinTranslation.of_codon("UAA") == { :ok, "STOP" }
-    assert ProteinTranslation.of_codon("UAG") == { :ok, "STOP" }
-    assert ProteinTranslation.of_codon("UGA") == { :ok, "STOP" }
+    assert ProteinTranslation.of_codon("UAA") == {:ok, "STOP"}
+    assert ProteinTranslation.of_codon("UAG") == {:ok, "STOP"}
+    assert ProteinTranslation.of_codon("UGA") == {:ok, "STOP"}
   end
 
   @tag :pending
   test "translates rna strand into correct protein" do
     strand = "AUGUUUUGG"
-    assert ProteinTranslation.of_rna(strand) == { :ok, ~w(Methionine Phenylalanine Tryptophan) }
+    assert ProteinTranslation.of_rna(strand) == {:ok, ~w(Methionine Phenylalanine Tryptophan)}
   end
 
   @tag :pending
   test "stops translation if stop codon present" do
     strand = "AUGUUUUAA"
-    assert ProteinTranslation.of_rna(strand) == { :ok, ~w(Methionine Phenylalanine) }
+    assert ProteinTranslation.of_rna(strand) == {:ok, ~w(Methionine Phenylalanine)}
   end
 
   @tag :pending
   test "stops translation of longer strand" do
     strand = "UGGUGUUAUUAAUGGUUU"
-    assert ProteinTranslation.of_rna(strand) == { :ok, ~w(Tryptophan Cysteine Tyrosine) }
+    assert ProteinTranslation.of_rna(strand) == {:ok, ~w(Tryptophan Cysteine Tyrosine)}
   end
 
   @tag :pending
   test "invalid RNA" do
-    assert ProteinTranslation.of_rna("CARROT") == { :error, "invalid RNA" }
+    assert ProteinTranslation.of_rna("CARROT") == {:error, "invalid RNA"}
   end
 
   @tag :pending
   test "invalid codon at end of RNA" do
-    assert ProteinTranslation.of_rna("UUUROT") == { :error, "invalid RNA" }
+    assert ProteinTranslation.of_rna("UUUROT") == {:error, "invalid RNA"}
   end
 
   @tag :pending
   test "invalid codon" do
-    assert ProteinTranslation.of_codon("INVALID") == { :error, "invalid codon" }
+    assert ProteinTranslation.of_codon("INVALID") == {:error, "invalid codon"}
   end
 end