trackler 2.0.8.19 → 2.0.8.20

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

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

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

@@ -0,0 +1,87 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("protein_translation.exs", __DIR__)
+end
+
+ExUnit.start
+ExUnit.configure exclude: :pending, trace: true
+
+defmodule ProteinTranslationTest do
+  use ExUnit.Case
+
+  #@tag :pending
+  test "AUG translates to methionine" do
+    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" }
+  end
+
+  @tag :pending
+  test "identifies Leucine codons" do
+    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" }
+  end
+
+  @tag :pending
+  test "identifies Tyrosine codons" do
+    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" }
+  end
+
+  @tag :pending
+  test "identifies Tryptophan codons" do
+    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" }
+  end
+
+  @tag :pending
+  test "translates rna strand into correct protein" do
+    strand = "AUGUUUUGG"
+    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) }
+  end
+
+  @tag :pending
+  test "stops translation of longer strand" do
+    strand = "UGGUGUUAUUAAUGGUUU"
+    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" }
+  end
+
+  @tag :pending
+  test "invalid codon" do
+    assert ProteinTranslation.of_codon("INVALID") == { :error, "invalid codon" }
+  end
+end

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

@@ -0,0 +1,139 @@
+defmodule Say do
+  @moduledoc """
+  This example solution takes an integer and breaks it into chunks of 3 and
+  translates those chunks the same. The larger denominations (e.g. 'thousand')
+  are added if there are multiple chunks to translate.  Here are a few examples:
+
+  - `Say.in_english(23)` creates the chunk of `[0, 2, 3]` and invokes
+    `translate_chunk` on that to produce "twenty-three".
+  - `Say.in_english(1_234)` creates the chunks of `[0, 0, 1]` and `[2, 3, 4]`,
+     which `translate_chunk` will translate to "one" and
+     "two hundred thirty-four" and `translate_chunks` will combine them for
+     `one thousand two hundred thirty-four`.
+
+  Padding the chunks with leading zeroes gives us nice and even chunks of 3
+  digits to translate.
+  """
+
+  @small_numbers ~w(
+    one two three four five six seven eight nine ten
+    eleven twelve thirteen fourteen fifteen sixteen
+    seventeen eighteen nineteen
+  )
+
+  @decades ~w(
+    twenty thirty forty fifty sixty seventy eighty ninety
+  )
+
+  @separators ~w(thousand million billion)
+
+  @doc """
+  Translate a positive integer into English.
+  """
+
+  @spec in_english(Integer.t) :: {atom, String.t}
+  def in_english(number) when number < 0 or number >= 1_000_000_000_000 do
+    {:error, "number is out of range"}
+  end
+  def in_english(0), do: {:ok, "zero"}
+  def in_english(number) do
+    result = Integer.digits(number)
+    |> padded_chunk(3, 0)
+    |> translate_chunks
+    |> clean_join(" ")
+
+    {:ok, result}
+  end
+
+
+  @spec translate_chunks(List.t) :: [String.t]
+  defp translate_chunks(chunks) do
+    translate_chunks(chunks, Enum.count(chunks))
+  end
+
+
+  @spec translate_chunks(List.t, Integer.t) :: [String.t]
+  defp translate_chunks([chunk], 1), do: [translate_chunk(chunk)]
+  defp translate_chunks([[0, 0, 0] | remaining], n) do
+    translate_chunks(remaining, n - 1)
+  end
+  defp translate_chunks([chunk | remaining], n) do
+    chunk_in_english = [
+      translate_chunk(chunk),
+      Enum.at(@separators, n - 2)
+    ]
+    |> clean_join(" ")
+
+    [ chunk_in_english | translate_chunks(remaining, n - 1) ]
+  end
+
+
+  @spec translate_chunk([Integer.t]) :: String.t
+  defp translate_chunk([0, 0, 0]), do: ""
+  defp translate_chunk([0, 0, ones]), do: ones_in_english(ones)
+  defp translate_chunk([0, 1, ones]) do
+    ones_in_english(ones + 10)
+  end
+  defp translate_chunk([0, tens, 0]), do: tens_in_english(tens)
+  defp translate_chunk([0, tens, ones]) do
+    [
+      tens_in_english(tens),
+      ones_in_english(ones)
+    ]
+    |> clean_join("-")
+  end
+  defp translate_chunk([hundreds, 0, 0]) do
+    "#{ones_in_english(hundreds)} hundred"
+  end
+  defp translate_chunk([hundreds, tens, ones]) do
+    [
+      translate_chunk([hundreds, 0, 0]),
+      translate_chunk([0, tens, ones])
+    ]
+    |> clean_join(" ")
+  end
+
+
+  @spec ones_in_english(Integer.t) :: String.t
+  defp ones_in_english(index), do: Enum.at(@small_numbers, index - 1)
+
+
+  @spec tens_in_english(Integer.t) :: String.t
+  defp tens_in_english(index), do: Enum.at(@decades, index - 2)
+
+
+  @spec clean_join([any], String.t) :: String.t
+  defp clean_join(collection, separator) do
+    collection
+    |> reject_blank
+    |> Enum.join(separator)
+  end
+
+
+  @spec reject_blank([any]) :: [any]
+  defp reject_blank(col) do
+    col
+    |> Enum.reject(&(&1 == nil || &1 == ""))
+  end
+
+
+  @spec padded_chunk([any], Integer.t, any) :: [any]
+  defp padded_chunk(list, chunk_size, pad) do
+    pad_size = pad_size(chunk_size, rem(Enum.count(list), chunk_size))
+
+    pad(list, pad, pad_size)
+    |> Enum.chunk(chunk_size)
+  end
+
+
+  @spec pad_size(Integer.t, Integer.t) :: Integer.t
+  defp pad_size(_, 0), do: 0
+  defp pad_size(total, rem), do: total - rem
+
+
+  @spec pad([any], any, Integer.t) :: [any]
+  defp pad(list, _, 0), do: list
+  defp pad(list, pad, count) do
+    [pad] ++ pad(list, pad, count - 1)
+  end
+end

data/tracks/elixir/exercises/say/say.exs

@@ -0,0 +1,8 @@
+defmodule Say do
+  @doc """
+  Translate a positive integer into English.
+  """
+  @spec in_english(integer) :: {atom, String.t}
+  def in_english(number) do
+  end
+end

data/tracks/elixir/exercises/say/say_test.exs

@@ -0,0 +1,85 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("say.exs", __DIR__)
+end
+
+ExUnit.start
+ExUnit.configure exclude: :pending, trace: true
+
+defmodule SayTest do
+  use ExUnit.Case
+
+  # @tag :pending
+  test "zero" do
+    assert Say.in_english(0) == {:ok, "zero"}
+  end
+
+  @tag :pending
+  test "one" do
+    assert Say.in_english(1) == {:ok, "one"}
+  end
+
+  @tag :pending
+  test "fourteen" do
+    assert Say.in_english(14) == {:ok, "fourteen"}
+  end
+
+  @tag :pending
+  test "twenty" do
+    assert Say.in_english(20) == {:ok, "twenty"}
+  end
+
+  @tag :pending
+  test "twenty-two" do
+    assert Say.in_english(22) == {:ok, "twenty-two"}
+  end
+
+  @tag :pending
+  test "one hundred" do
+    assert Say.in_english(100) == {:ok, "one hundred"}
+  end
+
+  @tag :pending
+  test "one hundred twenty-three" do
+    assert Say.in_english(123) == {:ok, "one hundred twenty-three"}
+  end
+
+  @tag :pending
+  test "one thousand" do
+    assert Say.in_english(1_000) == {:ok, "one thousand"}
+  end
+
+  @tag :pending
+  test "one thousand two hundred thirty-four" do
+    assert Say.in_english(1_234) == {:ok, "one thousand two hundred thirty-four"}
+  end
+
+  @tag :pending
+  test "one million" do
+    assert Say.in_english(1_000_000) == {:ok, "one million"}
+  end
+
+  @tag :pending
+  test "one million two thousand three hundred forty-five" do
+    assert Say.in_english(1_002_345) == {:ok, "one million two thousand three hundred forty-five"}
+  end
+
+  @tag :pending
+  test "one billion" do
+    assert Say.in_english(1_000_000_000) == {:ok, "one billion"}
+  end
+
+  @tag :pending
+  test "a big number" do
+    assert Say.in_english(987_654_321_123) == {:ok, "nine hundred eighty-seven billion six hundred fifty-four million three hundred twenty-one thousand one hundred twenty-three"}
+  end
+
+  @tag :pending
+  test "numbers below zero are out of range" do
+    assert Say.in_english(-1) == {:error, "number is out of range"}
+  end
+
+  @tag :pending
+  test "numbers above 999,999,999,999 are out of range" do
+    assert Say.in_english(1_000_000_000_000) == {:error, "number is out of range"}
+  end
+end

data/tracks/go/exercises/robot-name/example.go

@@ -7,6 +7,8 @@ import (
 	"math/rand"
 )
 
+const testVersion = 1
+
 type Robot struct {
 	name string
 }

data/tracks/go/exercises/robot-name/robot_name_test.go

@@ -5,10 +5,18 @@ import (
 	"testing"
 )
 
-func New() *Robot { return new(Robot) }
+const targetTestVersion = 1
 
 var namePat = regexp.MustCompile(`^[A-Z]{2}\d{3}$`)
 
+func New() *Robot { return new(Robot) }
+
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
+	}
+}
+
 func TestNameValid(t *testing.T) {
 	n := New().Name()
 	if !namePat.MatchString(n) {

data/tracks/go/exercises/roman-numerals/roman_numerals_test.go

@@ -4,10 +4,13 @@ import "testing"
 
 const targetTestVersion = 3
 
-func TestRomanNumerals(t *testing.T) {
+func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
 		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
 	}
+}
+
+func TestRomanNumerals(t *testing.T) {
 	tc := append(romanNumeralTests, []romanNumeralTest{
 		{0, "", true},
 		{-1, "", true},

data/tracks/go/exercises/saddle-points/saddle_points_test.go

@@ -20,6 +20,12 @@ var tests = []struct {
 	{"4 5 4\n3 5 5\n1 5 4", []Pair{{0, 1}, {1, 1}, {2, 1}}},
 }
 
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Fatalf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+	}
+}
+
 func TestSaddle(t *testing.T) {
 	for _, test := range tests {
 		m, err := New(test.m)
@@ -51,12 +57,6 @@ exp:
 	return true
 }
 
-func TestTestVersion(t *testing.T) {
-	if testVersion != targetTestVersion {
-		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
-	}
-}
-
 func BenchmarkSaddle(b *testing.B) {
 	ms := make([]*Matrix, len(tests))
 	var err error

data/tracks/php/config.json

@@ -355,6 +355,13 @@
       "Control-flow (loops)",
       "Integers"
     ]
+  },
+  {
+    "slug": "grade-school",
+    "difficulty": 6,
+    "topics": [
+      "Arrays"
+    ]
   }
   ]
 }