trackler 2.2.0.2 → 2.2.0.3

data/tracks/elixir/exercises/bob/README.md

@@ -0,0 +1,55 @@
+# Bob
+
+Bob is a lackadaisical teenager. In conversation, his responses are very limited.
+
+Bob answers 'Sure.' if you ask him a question.
+
+He answers 'Whoa, chill out!' if you yell at him.
+
+He says 'Fine. Be that way!' if you address him without actually saying
+anything.
+
+He answers 'Whatever.' to anything else.
+
+## Running tests
+
+Execute the tests with:
+
+```bash
+$ elixir bob_test.exs
+```
+
+(Replace `bob_test.exs` with the name of the test file.)
+
+### Pending tests
+
+In the test suites, all but the first test have been skipped.
+
+Once you get a test passing, you can unskip the next one by
+commenting out the relevant `@tag :pending` with a `#` symbol.
+
+For example:
+
+```elixir
+# @tag :pending
+test "shouting" do
+  assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
+end
+```
+
+Or, you can enable all the tests by commenting out the
+`ExUnit.configure` line in the test suite.
+
+```elixir
+# ExUnit.configure exclude: :pending, trace: true
+```
+
+For more detailed information about the Elixir track, please
+see the [help page](http://exercism.io/languages/elixir).
+
+## Source
+
+Inspired by the 'Deaf Grandma' exercise in Chris Pine's Learn to Program tutorial. [http://pine.fm/LearnToProgram/?Chapter=06](http://pine.fm/LearnToProgram/?Chapter=06)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/elixir/exercises/bowling/README.md

@@ -0,0 +1,90 @@
+# Bowling
+
+Score a bowling game.
+
+Bowling is game where players roll a heavy ball to knock down pins
+arranged in a triangle. Write code to keep track of the score
+of a game of bowling.
+
+## Scoring Bowling
+
+The game consists of 10 frames. A frame is composed of one or two ball throws with 10 pins standing at frame initialization. There are three cases for the tabulation of a frame.
+
+* An open frame is where a score of less than 10 is recorded for the frame. In this case the score for the frame is the number of pins knocked down.
+
+* A spare is where all ten pins are knocked down after the second throw. The total value of a spare is 10 plus the number of pins knocked down in their next throw.
+
+* A strike is where all ten pins are knocked down after the first throw. The total value of a strike is 10 plus the number of pins knocked down in their next two throws. If a strike is immediately followed by a second strike, then we can not total the value of first strike until they throw the ball one more time.
+
+Here is a three frame example:
+
+| Frame 1         | Frame 2       | Frame 3                |
+| :-------------: |:-------------:| :---------------------:|
+| X (strike)      | 5/ (spare)    | 9 0 (open frame)       |
+
+Frame 1 is (10 + 5 + 5) = 20
+
+Frame 2 is (5 + 5 + 9) = 19
+
+Frame 3 is (9 + 0) = 9
+
+This means the current running total is 48.
+
+The tenth frame in the game is a special case. If someone throws a strike or a spare then they get a fill ball. Fill balls exist to calculate the total of the 10th frame. Scoring a strike or spare on the fill ball does not give the player more fill balls. The total value of the 10th frame is the total number of pins knocked down.
+
+For a tenth frame of X1/ (strike and a spare), the total value is 20.
+
+For a tenth frame of XXX (three strikes), the total value is 30.
+
+## Requirements
+
+Write code to keep track of the score of a game of bowling. It should
+support two operations:
+
+* `roll(pins : int)` is called each time the player rolls a ball.  The
+  argument is the number of pins knocked down.
+* `score() : int` is called only at the very end of the game.  It
+  returns the total score for that game.
+
+## Running tests
+
+Execute the tests with:
+
+```bash
+$ elixir bob_test.exs
+```
+
+(Replace `bob_test.exs` with the name of the test file.)
+
+### Pending tests
+
+In the test suites, all but the first test have been skipped.
+
+Once you get a test passing, you can unskip the next one by
+commenting out the relevant `@tag :pending` with a `#` symbol.
+
+For example:
+
+```elixir
+# @tag :pending
+test "shouting" do
+  assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
+end
+```
+
+Or, you can enable all the tests by commenting out the
+`ExUnit.configure` line in the test suite.
+
+```elixir
+# ExUnit.configure exclude: :pending, trace: true
+```
+
+For more detailed information about the Elixir track, please
+see the [help page](http://exercism.io/languages/elixir).
+
+## Source
+
+The Bowling Game Kata at but UncleBob [http://butunclebob.com/ArticleS.UncleBob.TheBowlingGameKata](http://butunclebob.com/ArticleS.UncleBob.TheBowlingGameKata)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

@@ -12,7 +12,7 @@ defmodule BowlingTest do
     Enum.reduce(rolls, game, fn(roll, game) -> Bowling.roll(game, roll) end)
   end
 
-  test "can score all 0s" do
+  test "should be able to score a game with all zeros" do
     game = Bowling.start
     rolls = [0, 0,
              0, 0,
@@ -29,7 +29,7 @@ defmodule BowlingTest do
   end
 
   @tag :pending
-  test "can score a game with no strikes or spares" do
+  test "should be able to score a game with no strikes or spares" do
     game = Bowling.start
     rolls = [3, 6,
              3, 6,
@@ -46,7 +46,7 @@ defmodule BowlingTest do
   end
 
   @tag :pending
-  test "spare followed by all 0s is worth 10 points" do
+  test "a spare followed by zeros is worth ten points" do
     game = Bowling.start
     rolls = [6, 4,
              0, 0,
@@ -63,7 +63,7 @@ defmodule BowlingTest do
   end
 
   @tag :pending
-  test "points scored in the roll after the spare are counted twice" do
+  test "points scored in the roll after a spare are counted twice" do
     game = Bowling.start
     rolls = [6, 4,
              3, 0,
@@ -115,7 +115,7 @@ defmodule BowlingTest do
   end
 
   @tag :pending
-  test "a strike earns ten points in frame with a single roll" do
+  test "a strike earns ten points in a frame with a single roll" do
     game = Bowling.start
     rolls = [10,
              0, 0,
@@ -258,26 +258,26 @@ defmodule BowlingTest do
   end
 
   @tag :pending
-  test "rolls can not score negative points" do
+  test "rolls cannot score negative points" do
     game = Bowling.start
-    assert Bowling.roll(game, -1) == {:error, "Pins must have a value from 0 to 10"}
+    assert Bowling.roll(game, -1) == {:error, "Negative roll is invalid"}
   end
 
   @tag :pending
-  test "a roll can not score more than 10 points" do
+  test "a roll cannot score more than 10 points" do
     game = Bowling.start
-    assert Bowling.roll(game, 11) == {:error, "Pins must have a value from 0 to 10"}
+    assert Bowling.roll(game, 11) == {:error, "Pin count exceeds pins on the lane"}
   end
 
   @tag :pending
-  test "two rolls in a frame can not score more than 10 points" do
+  test "two rolls in a frame cannot 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 "two bonus rolls after a strike in the last frame can not score more than 10 points" do
+  test "bonus roll after a strike in the last frame cannot score more than 10 points" do
     game = Bowling.start
     rolls = [0, 0,
              0, 0,
@@ -288,26 +288,100 @@ defmodule BowlingTest do
              0, 0,
              0, 0,
              0, 0,
+             10]
+    game = roll_reduce(game, rolls)
+    assert Bowling.roll(game, 11) == {:error, "Pin count exceeds pins on the lane"}
+  end
+
+  @tag :pending
+  test "two bonus rolls after a strike in the last frame cannot score more than 10 points" do
+    game = Bowling.start
+    rolls = [0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             10,
              5]
     game = roll_reduce(game, rolls)
     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
+  test "two bonus rolls after a strike in the last frame can score more than 10 points if one is a strike" 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,
+             6]
+    game = roll_reduce(game, rolls)
+    assert Bowling.score(game) == 26
+  end
+
+  @tag :pending
+  test "the second bonus rolls after a strike in the last frame cannot be a strike if the first one is not a strike" do
+    game = Bowling.start
+    rolls = [0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             0, 0,
+             10,
+             6]
+    game = roll_reduce(game, rolls)
+    assert Bowling.roll(game, 10) == {:error, "Pin count exceeds pins on the lane"}
+  end
+
+  @tag :pending
+  test "second bonus roll after a strike in the last frame cannot score more than 10 points" 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.roll(game, 11) == {:error, "Pin count exceeds pins on the lane"}
+  end
+
+  @tag :pending
+  test "an unstarted game cannot 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
+  test "an incomplete game cannot be scored" do
     game = Bowling.start
-    game = Bowling.roll(game, 0)
+    rolls = [0, 0]
+    game = roll_reduce(game, rolls)
     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
+  test "cannot roll if game already has ten frames" do
     game = Bowling.start
     rolls = [0, 0,
              0, 0,
@@ -318,10 +392,9 @@ defmodule BowlingTest do
              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"}
+    assert Bowling.roll(game, 0) == {:error, "Cannot roll after game is over"}
   end
 
   @tag :pending

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

@@ -10,16 +10,18 @@ defmodule Bowling do
   end
 
   def roll(_, score) when score < 0 do
-    {:error, "Pins must have a value from 0 to 10"}
+    {:error, "Negative roll is invalid"}
   end
 
   def roll(_, score) when score > 10 do
-    {:error, "Pins must have a value from 0 to 10"}
+    {:error, "Pin count exceeds pins on the lane"}
   end
 
   def roll(game, score) do
     updates = update_score(game.roll_in_frame, game, score)
     cond do
+      too_many_frames?(updates) ->
+        {:error, "Cannot roll after game is over"}
       valid_updates?(updates) ->
         updates
       true ->
@@ -58,8 +60,6 @@ defmodule Bowling do
         {: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

data/tracks/elixir/exercises/bracket-push/README.md

@@ -0,0 +1,47 @@
+# Bracket Push
+
+Given a string containing brackets `[]`, braces `{}` and parentheses `()`,
+verify that all the pairs are matched and nested correctly.
+
+## Running tests
+
+Execute the tests with:
+
+```bash
+$ elixir bob_test.exs
+```
+
+(Replace `bob_test.exs` with the name of the test file.)
+
+### Pending tests
+
+In the test suites, all but the first test have been skipped.
+
+Once you get a test passing, you can unskip the next one by
+commenting out the relevant `@tag :pending` with a `#` symbol.
+
+For example:
+
+```elixir
+# @tag :pending
+test "shouting" do
+  assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
+end
+```
+
+Or, you can enable all the tests by commenting out the
+`ExUnit.configure` line in the test suite.
+
+```elixir
+# ExUnit.configure exclude: :pending, trace: true
+```
+
+For more detailed information about the Elixir track, please
+see the [help page](http://exercism.io/languages/elixir).
+
+## Source
+
+Ginna Baker
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/elixir/exercises/change/README.md

@@ -0,0 +1,60 @@
+# Change
+
+Correctly determine the fewest number of coins to be given to a customer such
+that the sum of the coins' value would equal the correct amount of change.
+
+## For example
+
+- An input of 15 with [1, 5, 10, 25, 100] should return one nickel (5)
+  and one dime (10) or [0, 1, 1, 0, 0]
+- An input of 40 with [1, 5, 10, 25, 100] should return one nickel (5)
+  and one dime (10) and one quarter (25) or [0, 1, 1, 1, 0]
+
+## Edge cases
+
+- Does your algorithm work for any given set of coins?
+- Can you ask for negative change?
+- Can you ask for a change value smaller than the smallest coin value?
+
+## Running tests
+
+Execute the tests with:
+
+```bash
+$ elixir bob_test.exs
+```
+
+(Replace `bob_test.exs` with the name of the test file.)
+
+### Pending tests
+
+In the test suites, all but the first test have been skipped.
+
+Once you get a test passing, you can unskip the next one by
+commenting out the relevant `@tag :pending` with a `#` symbol.
+
+For example:
+
+```elixir
+# @tag :pending
+test "shouting" do
+  assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
+end
+```
+
+Or, you can enable all the tests by commenting out the
+`ExUnit.configure` line in the test suite.
+
+```elixir
+# ExUnit.configure exclude: :pending, trace: true
+```
+
+For more detailed information about the Elixir track, please
+see the [help page](http://exercism.io/languages/elixir).
+
+## Source
+
+Software Craftsmanship - Kata-logue [http://craftsmanship.sv.cmu.edu/exercises/coin-change-kata](http://craftsmanship.sv.cmu.edu/exercises/coin-change-kata)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.