trackler 2.2.1.106 → 2.2.1.107

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d834493b144aa3cc972608752f2ad761e230722
-  data.tar.gz: c32fd3c60a8a9a33fd3b4e88c73263330f502885
+  metadata.gz: f11bde21663899b9a570b97621e391aa62e5f379
+  data.tar.gz: 8480dc1e43e611925e76989d561e0e19ea28cefb
 SHA512:
-  metadata.gz: b74d350bd3e7cdf94a468c5e461d46d063af7152bbca12a260801b94be01bc9db3c9c4603e834e6a9f5a814b4990644f6d4c183403863d4dd30440c4582f3555
-  data.tar.gz: 20d1b9a4b558de8ec50fff78c345a8d341af8eebfc9fc55bc41fea7ba159154e3bb27c338ca7ed8173a11f526d5fd0eb4ec023b9178756dd22c910b5f1cc20d2
+  metadata.gz: e6c6211c8f2f91615e89d35a0cf2b3fb6d993d35baa4106ed91f2c419827bb68768b7e4330879e20497ea9f5da663d6ee7b1832080bd35098a401d97b8d176b0
+  data.tar.gz: 8474814afc978a6120f745e9857a2b3b294074b6926cecf6e10917df0af891ac7d9517837dfbcf229560cb031ff9d7afe89751fa85e667b51dd5c78e9221e1cb

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.106"
+  VERSION = "2.2.1.107"
 end

data/tracks/delphi/exercises/bowling/uBowlingExample.pas

@@ -5,7 +5,7 @@ interface
 type
    IBowlingGame = interface(IInvokable)
    ['{D4A292B6-BC15-48ED-AE04-2D34759017CB}']
-     procedure Roll(aPins: integer);
+     function Roll(aPins: integer): Boolean;
      function Score: integer;
    end;
 
@@ -28,10 +28,11 @@ type
      function SpareBonus(aFrameIndex: integer): integer;
      function SumOfPinsInFrame(aFrameIndex: integer): integer;
      function CorrectNumberOfRolls(aFrameIndex: integer): boolean;
+     function ValidInput(aPin: integer): Boolean;
    public
      constructor create;
      function Score: integer;
-     procedure Roll(aPins: integer);
+     function Roll(aPins: integer): Boolean;
    end;
 
 function NewBowlingGame: IBowlingGame;
@@ -44,8 +45,11 @@ begin
   fRolls := TList<integer>.Create;
 end;
 
-procedure TBowlingGame.Roll(aPins: Integer);
+function TBowlingGame.Roll(aPins: Integer): Boolean;
 begin
+  if not ValidInput(aPins) then
+    exit(false);
+
   fRolls.Add(aPins);
 end;
 
@@ -59,6 +63,8 @@ begin
   lScore := 0;
   lFrameIndex := 0;
   try
+    if (fRolls.Count < 12) or (fRolls.Count > 21) then
+      raise EArgumentException.Create('Not a proper game');
     for i := 1 to fNumberOfFrames do
     begin
       if fRolls.Count <= lFrameIndex then
@@ -70,7 +76,7 @@ begin
           raise EArgumentException.Create('Not a proper game');
 
         lStrikeBonus := StrikeBonus(lFrameIndex);
-        if (lStrikeBonus > fMaximumFrameScore) and not IsStrike(lFrameIndex + 1) then
+        if (lStrikeBonus > fMaximumFrameScore) and not IsStrike(lFrameIndex + 1) or (lStrikeBonus > 20) then
           raise EArgumentException.Create('Not a proper game');
 
         lScore := lScore + 10 + lStrikeBonus;
@@ -126,6 +132,27 @@ begin
   result := fRolls[aFrameIndex] + fRolls[aFrameIndex + 1];
 end;
 
+function TBowlingGame.ValidInput(aPin: integer): Boolean;
+begin
+  result := true;
+  if (fRolls.Count >= 21) or (aPin < 0) or (aPin > 10) or
+      ((fRolls.Count + 1) mod 2 = 0) and (fRolls[fRolls.Count - 1] <> 10) and ((fRolls[fRolls.Count - 1] + aPin) > 10) then
+    exit(false);
+
+  if (fRolls.Count = 20) then
+  begin
+    if (fRolls[18] <> 10) and (fRolls[18] + fRolls[19] <> 10) then
+      exit(false);
+
+    if (aPin = 10) and ((fRolls[18] <> 10) or (fRolls[19] <> 10) or (fRolls[19] + aPin > 10) and (fRolls[19] + aPin <> 20)) and
+        (fRolls[18] + fRolls[19] <> 10) then
+      exit(false);
+
+    if (aPin <> 10) and (fRolls[19] + aPin > 10) and (fRolls[19] <> 10) then
+      exit(false);
+  end;
+end;
+
 function TBowlingGame.CorrectNumberOfRolls(aFrameIndex: Integer): boolean;
 begin
   result := aFrameIndex = fRolls.Count;

data/tracks/delphi/exercises/bowling/uBowlingTests.pas

@@ -5,6 +5,9 @@ uses
   DUnitX.TestFramework,
   uBowling;
 
+const
+  CanonicalVersion = '1.2.0';
+
 type
 
   [TestFixture]
@@ -13,7 +16,7 @@ type
     class function RollMany(pins: array of integer; game: IBowlingGame): IBowlingGame; static;
   public
     [Test]
-//  [Ignore('Comment the "[Ignore]" statement to run the test')]
+//    [Ignore('Comment the "[Ignore]" statement to run the test')]
     procedure Should_be_able_to_score_a_game_with_all_zeros;
 
     [Test]
@@ -80,10 +83,26 @@ type
     [Ignore]
     procedure Two_rolls_in_a_frame_cannot_score_more_than_10_points;
 
+    [Test]
+    [Ignore]
+    procedure Bonus_roll_after_a_strike_in_the_last_frame_cannot_score_more_than_10_points;
+
     [Test]
     [Ignore]
     procedure Two_bonus_rolls_after_a_strike_in_the_last_frame_cannot_score_more_than_10_points;
 
+    [Test]
+    [Ignore]
+    procedure Two_bonus_rolls_after_a_strike_in_the_last_frame_can_score_more_than_10_points_if_one_is_a_strike;
+
+    [Test]
+    [Ignore]
+    procedure The_second_bonus_rolls_after_a_strike_in_the_last_frame_cannot_be_a_strike_if_the_first_one_is_not_a_strike;
+
+    [Test]
+    [Ignore]
+    procedure Second_bonus_roll_after_a_strike_in_the_last_frame_cannot_score_more_than_10_points;
+
     [Test]
     [Ignore]
     procedure An_unstarted_game_cannot_be_scored;
@@ -94,7 +113,7 @@ type
 
     [Test]
     [Ignore]
-    procedure A_game_with_more_than_ten_frames_cannot_be_scored;
+    procedure Cannot_roll_if_game_already_has_ten_frames;
 
     [Test]
     [Ignore]
@@ -107,11 +126,26 @@ type
     [Test]
     [Ignore]
     procedure Bonus_roll_for_a_spare_in_the_last_frame_must_be_rolled_before_score_can_be_calculated;
+
+    [Test]
+    [Ignore]
+    procedure Cannot_roll_after_bonus_roll_for_spare;
+
+    [Test]
+    [Ignore]
+    procedure Cannot_roll_after_bonus_rolls_for_strike;
   end;
 
 implementation
 uses System.SysUtils;
 
+procedure BowlingTests.Second_bonus_roll_after_a_strike_in_the_last_frame_cannot_score_more_than_10_points;
+var game: IBowlingGame;
+begin
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10], NewBowlingGame);
+  Assert.IsFalse(game.Roll(11));
+end;
+
 procedure BowlingTests.Should_be_able_to_score_a_game_with_all_zeros;
 var game: IBowlingGame;
 begin
@@ -231,6 +265,13 @@ begin
   Assert.AreEqual(-1, game.Score);
 end;
 
+procedure BowlingTests.The_second_bonus_rolls_after_a_strike_in_the_last_frame_cannot_be_a_strike_if_the_first_one_is_not_a_strike;
+var game: IBowlingGame;
+begin
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 6], NewBowlingGame);
+  Assert.IsFalse(game.Roll(10));
+end;
+
 procedure BowlingTests.Two_bonus_rolls_after_a_strike_in_the_last_frame_cannot_score_more_than_10_points;
 var game: IBowlingGame;
 begin
@@ -238,6 +279,13 @@ begin
   Assert.AreEqual(-1, game.Score);
 end;
 
+procedure BowlingTests.Two_bonus_rolls_after_a_strike_in_the_last_frame_can_score_more_than_10_points_if_one_is_a_strike;
+var game: IBowlingGame;
+begin
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 6], NewBowlingGame);
+  Assert.AreEqual(26, game.Score);
+end;
+
 procedure BowlingTests.An_unstarted_game_cannot_be_scored;
 var game: IBowlingGame;
 begin
@@ -252,11 +300,25 @@ begin
   Assert.AreEqual(-1, game.Score);
 end;
 
-procedure BowlingTests.A_game_with_more_than_ten_frames_cannot_be_scored;
+procedure BowlingTests.Cannot_roll_after_bonus_rolls_for_strike;
 var game: IBowlingGame;
 begin
-  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], NewBowlingGame);
-  Assert.AreEqual(-1, game.Score);
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 3, 2], NewBowlingGame);
+  Assert.IsFalse(game.Roll(2));
+end;
+
+procedure BowlingTests.Cannot_roll_after_bonus_roll_for_spare;
+var game: IBowlingGame;
+begin
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 2], NewBowlingGame);
+  Assert.IsFalse(game.Roll(2));
+end;
+
+procedure BowlingTests.Cannot_roll_if_game_already_has_ten_frames;
+var game: IBowlingGame;
+begin
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], NewBowlingGame);
+  Assert.IsFalse(game.Roll(0));
 end;
 
 procedure BowlingTests.Bonus_rolls_for_a_strike_in_the_last_frame_must_be_rolled_before_score_can_be_calculated;
@@ -273,6 +335,20 @@ begin
   Assert.AreEqual(-1, game.Score);
 end;
 
+procedure BowlingTests.Bonus_roll_after_a_strike_in_the_last_frame_cannot_score_more_than_10_points;
+var game: IBowlingGame;
+begin
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10], NewBowlingGame);
+  Assert.IsFalse(game.Roll(11));
+    (*{
+        var sut = new BowlingGame();
+        var previousRolls = new int[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10};
+        DoRoll(previousRolls, sut);
+        Assert.Throws<ArgumentException>(() => sut.Roll(11));
+    } (**)
+
+end;
+
 procedure BowlingTests.Bonus_roll_for_a_spare_in_the_last_frame_must_be_rolled_before_score_can_be_calculated;
 var game: IBowlingGame;
 begin

data/tracks/elm/config/exercise_readme.go.tmpl

@@ -4,10 +4,35 @@
 {{- with .Hints }}
 {{ . }}
 {{ end }}
-{{- with .TrackInsert }}
-{{ . }}
-{{ end }}
-{{- with .Spec.Credits -}}
+## Elm Installation
+
+Refer to the [Exercism help page](http://exercism.io/languages/elm) for Elm
+installation and learning resources.
+
+## Writing the Code
+
+The first time you start an exercise, you'll need to ensure you have the
+appropriate dependencies installed.
+
+```bash
+$ npm install
+```
+
+Execute the tests with:
+
+```bash
+$ npm test
+```
+
+Automatically run tests again when you save changes:
+
+```bash
+$ npm run watch
+```
+
+As you work your way through the test suite, be sure to remove the `skip <|`
+calls from each test until you get them all passing!
+{{ with .Spec.Credits }}
 ## Source
 
 {{ . }}

data/tracks/elm/exercises/accumulate/README.md

@@ -25,9 +25,6 @@ Keep your hands off that collect/map/fmap/whatchamacallit functionality
 provided by your standard library!
 Solve this one yourself using other basic tools instead.
 
-Lisp specific: it's perfectly fine to use `MAPCAR` or the equivalent,
-as this is idiomatic Lisp, not a library function.
-
 ## Elm Installation
 
 Refer to the [Exercism help page](http://exercism.io/languages/elm) for Elm

data/tracks/elm/exercises/all-your-base/README.md

@@ -60,6 +60,5 @@ $ npm run watch
 As you work your way through the test suite, be sure to remove the `skip <|`
 calls from each test until you get them all passing!
 
-
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/elm/exercises/allergies/README.md

@@ -29,7 +29,6 @@ allergens that score 256, 512, 1024, etc.).  Your program should
 ignore those components of the score.  For example, if the allergy
 score is 257, your program should only report the eggs (1) allergy.
 
-
 ## Elm Installation
 
 Refer to the [Exercism help page](http://exercism.io/languages/elm) for Elm

data/tracks/elm/exercises/atbash-cipher/README.md

@@ -9,7 +9,7 @@ letter, the second with the second-last, and so on.
 
 An Atbash cipher for the Latin alphabet would be as follows:
 
-```plain
+```text
 Plain:  abcdefghijklmnopqrstuvwxyz
 Cipher: zyxwvutsrqponmlkjihgfedcba
 ```
@@ -23,6 +23,7 @@ being 5 letters, and punctuation is excluded. This is to make it harder to guess
 things based on word boundaries.
 
 ## Examples
+
 - Encoding `test` gives `gvhg`
 - Decoding `gvhg` gives `test`
 - Decoding `gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt` gives `thequickbrownfoxjumpsoverthelazydog`

data/tracks/elm/exercises/etl/README.md

@@ -1,8 +1,9 @@
-# Etl
+# ETL
 
 We are going to do the `Transform` step of an Extract-Transform-Load.
 
 ### ETL
+
 Extract-Transform-Load (ETL) is a fancy way of saying, "We have some crufty, legacy data over in this system, and now we need it in this shiny new system over here, so
 we're going to migrate this."
 
@@ -11,6 +12,7 @@ once." That's then typically followed by much forehead slapping and
 moaning about how stupid we could possibly be.)
 
 ### The goal
+
 We're going to extract some scrabble scores from a legacy system.
 
 The old system stored a list of letters per score:

data/tracks/elm/exercises/grade-school/README.md

@@ -21,7 +21,6 @@ In the end, you should be able to:
 Note that all our students only have one name.  (It's a small town, what
 do you want?)
 
-
 ## For bonus points
 
 Did you get the tests passing and the code clean? If you want to, these

data/tracks/elm/exercises/grains/README.md

@@ -15,7 +15,6 @@ Write code that shows:
 - how many grains were on each square, and
 - the total number of grains
 
-
 ## For bonus points
 
 Did you get the tests passing and the code clean? If you want to, these

data/tracks/elm/exercises/leap/README.md

@@ -4,7 +4,7 @@ Given a year, report if it is a leap year.
 
 The tricky thing here is that a leap year in the Gregorian calendar occurs:
 
-```plain
+```text
 on every year that is evenly divisible by 4
   except every year that is evenly divisible by 100
     unless the year is also evenly divisible by 400

data/tracks/elm/exercises/list-ops/README.md

@@ -35,6 +35,5 @@ $ npm run watch
 As you work your way through the test suite, be sure to remove the `skip <|`
 calls from each test until you get them all passing!
 
-
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/elm/exercises/nucleotide-count/README.md

@@ -1,30 +1,16 @@
 # Nucleotide Count
 
-Given a DNA string, compute how many times each nucleotide occurs in the string.
+Given a single stranded DNA string, compute how many times each nucleotide occurs in the string.
 
-DNA is represented by an alphabet of the following symbols: 'A', 'C',
-'G', and 'T'.
-
-Each symbol represents a nucleotide, which is a fancy name for the
-particular molecules that happen to make up a large part of DNA.
-
-Shortest intro to biochemistry EVAR:
+The genetic language of every living thing on the planet is DNA.
+DNA is a large molecule that is built from an extremely long sequence of individual elements called nucleotides.
+4 types exist in DNA and these differ only slightly and can be represented as the following symbols: 'A' for adenine, 'C' for cytosine, 'G' for guanine, and 'T' thymine.
 
+Here is an analogy:
 - twigs are to birds nests as
-- nucleotides are to DNA and RNA as
-- amino acids are to proteins as
-- sugar is to starch as
-- oh crap lipids
-
-I'm not going to talk about lipids because they're crazy complex.
-
-So back to nucleotides.
-
-DNA contains four types of them: adenine (`A`), cytosine (`C`), guanine
-(`G`), and thymine (`T`).
-
-RNA contains a slightly different set of nucleotides, but we don't care
-about that for now.
+- nucleotides are to DNA as
+- legos are to lego houses as
+- words are to sentences as...
 
 ## Elm Installation
 

data/tracks/elm/exercises/pangram/README.md

@@ -2,7 +2,7 @@
 
 Determine if a sentence is a pangram. A pangram (Greek: παν γράμμα, pan gramma,
 "every letter") is a sentence using every letter of the alphabet at least once.
-The best known English pangram is: 
+The best known English pangram is:
 > The quick brown fox jumps over the lazy dog.
 
 The alphabet used consists of ASCII letters `a` to `z`, inclusive, and is case