trackler 1.0.4.0 → 1.0.4.1

data/tracks/clojure/exercises/flatten-array/project.clj

@@ -0,0 +1,4 @@
+(defproject flatten-array "0.1.0-SNAPSHOT"
+  :description "flatten-array exercise."
+  :url "https://github.com/exercism/xclojure/tree/master/exercises/flatten-array"
+  :dependencies [[org.clojure/clojure "1.8.0"]])

data/tracks/csharp/exercises/protein-translation/ProteinTranslationTest.cs

@@ -78,6 +78,6 @@ public class ProteinTranslationTest
     [Ignore("Remove to run test")]
     public void Throws_for_invalid_codons()
     {
-        Assert.Throws<Exception>(() => ProteinTranslation.Translate("CARROT"));
+        Assert.That(() => ProteinTranslation.Translate("CARROT"), Throws.Exception);
     }
 }

data/tracks/elixir/exercises/bowling/bowling_test.exs

@@ -29,9 +29,26 @@ defmodule BowlingTest do
   end
 
   @tag :pending
-  test "can score an open frame" do
+  test "can score a game with no strikes or spares" do
     game = Bowling.start
-    rolls = [3, 4,
+    rolls = [3, 6,
+             3, 6,
+             3, 6,
+             3, 6,
+             3, 6,
+             3, 6,
+             3, 6,
+             3, 6,
+             3, 6,
+             3, 6]
+    game = roll_reduce(game, rolls)
+    assert Bowling.score(game) == 90
+  end
+
+  @tag :pending
+  test "spare followed by all 0s is worth 10 points" do
+    game = Bowling.start
+    rolls = [6, 4,
              0, 0,
              0, 0,
              0, 0,
@@ -42,15 +59,15 @@ defmodule BowlingTest do
              0, 0,
              0, 0]
     game = roll_reduce(game, rolls)
-    assert Bowling.score(game) == 7
+    assert Bowling.score(game) == 10
   end
 
   @tag :pending
-  test "can score multiple frames" do
+  test "points scored in the roll after the spare are counted twice" do
     game = Bowling.start
-    rolls = [3, 4,
-             2, 3,
-             5, 2,
+    rolls = [6, 4,
+             3, 0,
+             0, 0,
              0, 0,
              0, 0,
              0, 0,
@@ -59,48 +76,49 @@ defmodule BowlingTest do
              0, 0,
              0, 0]
     game = roll_reduce(game, rolls)
-    assert Bowling.score(game) == 19
+    assert Bowling.score(game) == 16
   end
 
   @tag :pending
-  test "can score a game with all single pin rolls" do
+  test "consecutive spares each get a one roll bonus" do
     game = Bowling.start
-    rolls = [1, 1,
-             1, 1,
-             1, 1,
-             1, 1,
-             1, 1,
-             1, 1,
-             1, 1,
-             1, 1,
-             1, 1,
-             1, 1]
+    rolls = [5, 5,
+             3, 7,
+             4, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0]
     game = roll_reduce(game, rolls)
-    assert Bowling.score(game) == 20
+    assert Bowling.score(game) == 31
   end
 
   @tag :pending
-  test "can score a game with all open frames" do
+  test "a spare in the last frame gets a one roll bonus that is counted once" do
     game = Bowling.start
-    rolls = [3, 6,
-             3, 6,
-             3, 6,
-             3, 6,
-             3, 6,
-             3, 6,
-             3, 6,
-             3, 6,
-             3, 6,
-             3, 6]
+    rolls = [0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             7, 3,
+             7]
     game = roll_reduce(game, rolls)
-    assert Bowling.score(game) == 90
+    assert Bowling.score(game) == 17
   end
 
   @tag :pending
-  test "can score a game with a strike not in the last frame" do
+  test "a strike earns ten points in frame with a single roll" do
     game = Bowling.start
     rolls = [10,
-             5, 3,
+             0, 0,
              0, 0,
              0, 0,
              0, 0,
@@ -110,14 +128,14 @@ defmodule BowlingTest do
              0, 0,
              0, 0]
     game = roll_reduce(game, rolls)
-    assert Bowling.score(game) == 26
+    assert Bowling.score(game) == 10
   end
 
   @tag :pending
-  test "can score a game with a spare not in the last frame" do
+  test "points scored in the two rolls after a strike are counted twice as a bonus" do
     game = Bowling.start
-    rolls = [5, 5,
-             3, 4,
+    rolls = [10,
+             5, 3,
              0, 0,
              0, 0,
              0, 0,
@@ -127,11 +145,11 @@ defmodule BowlingTest do
              0, 0,
              0, 0]
     game = roll_reduce(game, rolls)
-    assert Bowling.score(game) == 20
+    assert Bowling.score(game) == 26
   end
 
   @tag :pending
-  test "can score a game with multiple strikes in a row" do
+  test "consecutive strikes each get the two roll bonus" do
     game = Bowling.start
     rolls = [10,
              10,
@@ -148,24 +166,25 @@ defmodule BowlingTest do
   end
 
   @tag :pending
-  test "can score a game with multiple spares in a row" do
+  test "a strike in the last frame gets a two roll bonus that is counted once" do
     game = Bowling.start
-    rolls = [5, 5,
-             3, 7,
-             4, 1,
+    rolls = [0, 0,
              0, 0,
              0, 0,
              0, 0,
              0, 0,
              0, 0,
              0, 0,
-             0, 0]
+             0, 0,
+             0, 0,
+             10,
+             7, 1]
     game = roll_reduce(game, rolls)
-    assert Bowling.score(game) == 32
+    assert Bowling.score(game) == 18
   end
 
   @tag :pending
-  test "fills out the last frame when there is a strike" do
+  test "rolling a spare with the two roll bonus does not get a bonus roll" do
     game = Bowling.start
     rolls = [0, 0,
              0, 0,
@@ -177,13 +196,13 @@ defmodule BowlingTest do
              0, 0,
              0, 0,
              10,
-             7, 1]
+             7, 3]
     game = roll_reduce(game, rolls)
-    assert Bowling.score(game) == 18
+    assert Bowling.score(game) == 20
   end
 
   @tag :pending
-  test "fills out the last frame when there is a spare" do
+  test "strikes with the two roll bonus do not get bonus rolls" do
     game = Bowling.start
     rolls = [0, 0,
              0, 0,
@@ -194,14 +213,15 @@ defmodule BowlingTest do
              0, 0,
              0, 0,
              0, 0,
-             9, 1,
-             7]
+             10,
+             10,
+             10]
     game = roll_reduce(game, rolls)
-    assert Bowling.score(game) == 17
+    assert Bowling.score(game) == 30
   end
 
   @tag :pending
-  test "allows filled balls to be strikes" do
+  test "a strike with the one roll bonus after a spare in the last frame does not get a bonus" do
     game = Bowling.start
     rolls = [0, 0,
              0, 0,
@@ -212,15 +232,14 @@ defmodule BowlingTest do
              0, 0,
              0, 0,
              0, 0,
-             10,
-             10,
+             7, 3,
              10]
     game = roll_reduce(game, rolls)
-    assert Bowling.score(game) == 30
+    assert Bowling.score(game) == 20
   end
 
   @tag :pending
-  test "scores a perfect game correctly" do
+  test "all strikes is a perfect game" do
     game = Bowling.start
     rolls = [10,
              10,
@@ -239,26 +258,26 @@ defmodule BowlingTest do
   end
 
   @tag :pending
-  test "does not allow negative rolls" do
+  test "rolls can not score negative points" do
     game = Bowling.start
     assert Bowling.roll(game, -1) == {:error, "Pins must have a value from 0 to 10"}
   end
 
   @tag :pending
-  test "does not allow rolls greater than a strike" do
+  test "a roll can not score more than 10 points" do
     game = Bowling.start
     assert Bowling.roll(game, 11) == {:error, "Pins must have a value from 0 to 10"}
   end
 
   @tag :pending
-  test "does not allow consecutive rolls to be greater than a strike" do
+  test "two rolls in a frame can not score more than 10 points" do
     game = Bowling.start
     game = Bowling.roll(game, 5)
     assert Bowling.roll(game, 6) == {:error, "Pin count exceeds pins on the lane"}
   end
 
   @tag :pending
-  test "does not allow pin count to be exeeded in last frame" do
+  test "two bonus rolls after a strike in the last frame can not score more than 10 points" do
     game = Bowling.start
     rolls = [0, 0,
              0, 0,
@@ -274,10 +293,86 @@ defmodule BowlingTest do
     assert Bowling.roll(game, 6) == {:error, "Pin count exceeds pins on the lane"}
   end
 
+  @tag :pending
+  test "an unstarted game can not be scored" do
+    game = Bowling.start
+    assert Bowling.score(game) == {:error, "Score cannot be taken until the end of the game"}
+  end
+
   @tag :pending
   test "score cannot be taken until the end of the game" do
     game = Bowling.start
     game = Bowling.roll(game, 0)
     assert Bowling.score(game) == {:error, "Score cannot be taken until the end of the game"}
   end
+
+  @tag :pending
+  test "a game with more than ten frames can not be scored" do
+    game = Bowling.start
+    rolls = [0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0]
+    game = roll_reduce(game, rolls)
+    assert Bowling.score(game) == {:error, "Invalid game: too many frames"}
+  end
+
+  @tag :pending
+  test "bonus rolls for a strike in the last frame must be rolled before score can be calculated" do
+    game = Bowling.start
+    rolls = [0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             10]
+    game = roll_reduce(game, rolls)
+    assert Bowling.score(game) == {:error, "Score cannot be taken until the end of the game"}
+  end
+
+  @tag :pending
+  test "both bonus rolls for a strike in the last frame must be rolled before score can be calculated" do
+    game = Bowling.start
+    rolls = [0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             10,
+             10]
+    game = roll_reduce(game, rolls)
+    assert Bowling.score(game) == {:error, "Score cannot be taken until the end of the game"}
+  end
+
+  @tag :pending
+  test "bonus roll for a spare in the last frame must be rolled before score can be calculated" do
+    game = Bowling.start
+    rolls = [0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             7, 3]
+    game = roll_reduce(game, rolls)
+    assert Bowling.score(game) == {:error, "Score cannot be taken until the end of the game"}
+  end
 end

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

@@ -53,10 +53,39 @@ defmodule Bowling do
   end
 
   def score(game) do
-    if game.current_frame < 10 do
-      {:error, "Score cannot be taken until the end of the game"}
-    else
-      parse_scores(game.scores)
+    cond do
+      game.current_frame < 10 ->
+        {:error, "Score cannot be taken until the end of the game"}
+      bonus_roll_remaining?(game) ->
+        {:error, "Score cannot be taken until the end of the game"}
+      too_many_frames?(game) ->
+        {:error, "Invalid game: too many frames"}
+      true ->
+        parse_scores(game.scores)
+    end
+  end
+
+  defp bonus_roll_remaining?(game) do
+    final_frame = Enum.at(game.scores, 9)
+    cond do
+      strike?(final_frame) ->
+        cond do
+          strike?(Enum.at(game.scores, 10)) ->
+            game.current_frame == 12 && game.roll_in_frame == 1
+          true ->
+            game.current_frame < 12
+        end
+      spare?(final_frame) ->
+        game.current_frame == 11 && game.roll_in_frame == 1
+      true ->
+        false
+    end
+  end
+
+  defp too_many_frames?(game) do
+    final_frame = Enum.at(game.scores, 9)
+    unless strike?(final_frame) || spare?(final_frame) do
+      game.current_frame == 11 && game.roll_in_frame == 2
     end
   end
 

data/tracks/erlang/config.json

@@ -3,42 +3,182 @@
   "language": "Erlang",
   "repository": "https://github.com/exercism/xerlang",
   "active": true,
-  "problems": [
-    "hello-world",
-    "leap",
-    "rna-transcription",
-    "accumulate",
-    "bob",
-    "sum-of-multiples",
-    "strain",
-    "hamming",
-    "space-age",
-    "grains",
-    "anagram",
-    "nucleotide-count",
-    "atbash-cipher",
-    "phone-number",
-    "robot-simulator",
-    "grade-school",
-    "binary",
-    "word-count",
-    "circular-buffer",
-    "etl",
-    "clock",
-    "gigasecond",
-    "beer-song",
-    "difference-of-squares",
-    "allergies",
-    "bank-account",
-    "luhn",
-    "series",
-    "trinary",
-    "largest-series-product",
-    "meetup",
-    "parallel-letter-frequency",
-    "triangle",
-    "scrabble-score",
-    "zipper"
+  "exercises": [
+    {
+      "slug": "hello-world",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "leap",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "rna-transcription",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "accumulate",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "bob",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "sum-of-multiples",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "strain",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "hamming",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "space-age",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "grains",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "anagram",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "nucleotide-count",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "atbash-cipher",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "phone-number",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "robot-simulator",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "grade-school",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "binary",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "word-count",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "circular-buffer",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "etl",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "clock",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "gigasecond",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "beer-song",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "difference-of-squares",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "allergies",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "bank-account",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "luhn",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "series",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "trinary",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "largest-series-product",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "meetup",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "parallel-letter-frequency",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "triangle",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "scrabble-score",
+      "topics": [],
+      "difficulty": 1
+    },
+    {
+      "slug": "zipper",
+      "topics": [],
+      "difficulty": 1
+    }
   ],
   "deprecated": [
     "point-mutations"