trackler 2.0.8.10 → 2.0.8.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9dceda62cf5804961190a45bdb1674e22beb903a
-  data.tar.gz: 1591edf17af892e711aecb9d1b2cabc1b472a5cc
+  metadata.gz: 7985975e695c967206c6399587638d7b92f6ddeb
+  data.tar.gz: f605cb15bcc556c8f153ebf0aa71768b773709c5
 SHA512:
-  metadata.gz: abe7d5a9af5ae04d307b468618acb433fda74fb9266d8df78a6ca015cdcec513b95f47e39d584c8228f4785607b60bf4defcc3a08fa1569f9ffc069883a82a8f
-  data.tar.gz: 9294b813acecd5b4831e7585e3d7ce271b13da1cf49259b79a9ff188505c01820c2f8dea5c28ce0705ffa7a6d6df657a0012485bbd7841d453e4f400393b9789
+  metadata.gz: 3f6cd5026c972237c9495b8acd567fa1ac65fc949bcf2da45c797526fe5057cea00c78bd433f840c8003da55f729e675c184a65d4d6510aa589f31288b22350f
+  data.tar.gz: 8687e2946dec0948f8a7800850103074d894c24aba6d92a530ea452672788f7014abf9a3e5d03fcffb619a5e1cbd845f51784451eaad4444a0493c7240a40ba9

data/common/exercises/palindrome-products/description.md

@@ -27,4 +27,4 @@ The largest product is `9`. It's factors are `(1, 9)`, `(3, 3)`, and `(9, 1)`.
 Given the range `[10, 99]` (both inclusive)...
 
 The smallest palindrome product is `121`. It's factors are `(11, 11)`.
-The largest palindrome product is `9009`. It's factors are `(93, 99)` and `(99, 91)`.
+The largest palindrome product is `9009`. It's factors are `(91, 99)` and `(99, 91)`.

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.8.10"
+  VERSION = "2.0.8.11"
 end

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

@@ -1,7 +1,6 @@
 unit uBowling;
 
 interface
-uses System.Generics.Collections;
 
 type
    IBowlingGame = interface(IInvokable)
@@ -13,18 +12,22 @@ type
    function NewBowlingGame: IBowlingGame;
 
 implementation
+uses System.SysUtils, System.Math, System.Generics.Collections;
 
 type
    TBowlingGame = class(TInterfacedObject, IBowlingGame)
    private
-     fRolls: TList<integer>;
-     fNumberOfFrames: integer;
-     fMaximumFrameScore: integer;
+     var
+       fRolls: TList<integer>;
+     const
+       fNumberOfFrames = 10;
+       fMaximumFrameScore = 10;
      function IsStrike(aFrameIndex: integer): Boolean;
      function IsSpare(aFrameIndex: integer): Boolean;
      function StrikeBonus(aFrameIndex: integer): integer;
      function SpareBonus(aFrameIndex: integer): integer;
      function SumOfPinsInFrame(aFrameIndex: integer): integer;
+     function CorrectNumberOfRolls(aFrameIndex: integer): boolean;
    public
      constructor create;
      function Score: integer;
@@ -38,8 +41,6 @@ end;
 
 constructor TBowlingGame.create;
 begin
-  fNumberOfFrames := 10;
-  fMaximumFrameScore := 10;
   fRolls := TList<integer>.Create;
 end;
 
@@ -52,29 +53,52 @@ function TBowlingGame.Score: integer;
 var lFrameIndex: integer;
     i: integer;
     lScore: integer;
+    lStrikeBonus: integer;
+    lFrameScore: integer;
 begin
   lScore := 0;
   lFrameIndex := 0;
-  for i := 0 to fNumberOfFrames - 1 do
-  begin
-    if IsStrike(lFrameIndex) then
+  try
+    for i := 1 to fNumberOfFrames do
     begin
-      lScore := lScore + 10 + StrikeBonus(lFrameIndex);
-      inc(lFrameIndex);
-    end
-    else
-    if IsSpare(lFrameIndex) then
-    begin
-      lScore := lScore + 10 + SpareBonus(lFrameIndex);
-      inc(lFrameIndex, 2);
-    end
-    else
-    begin
-      lScore := lScore + SumOfPinsInFrame(lFrameIndex);
-      inc(lFrameIndex, 2);
+      if fRolls.Count <= lFrameIndex then
+        raise EArgumentException.Create('Not a proper game');
+
+      if IsStrike(lFrameIndex) then
+      begin
+        if (fRolls.Count <= lFrameIndex + 2) then
+          raise EArgumentException.Create('Not a proper game');
+
+        lStrikeBonus := StrikeBonus(lFrameIndex);
+        if (lStrikeBonus > fMaximumFrameScore) and not IsStrike(lFrameIndex + 1) then
+          raise EArgumentException.Create('Not a proper game');
+
+        lScore := lScore + 10 + lStrikeBonus;
+        inc(lFrameIndex, ifthen(i = fNumberOfFrames, 3, 1));
+      end
+      else
+      if IsSpare(lFrameIndex) then
+      begin
+        if (fRolls.Count <= lFrameIndex + 2) then
+          raise EArgumentException.Create('Not a proper game');
+
+        lScore := lScore + 10 + SpareBonus(lFrameIndex);
+        inc(lFrameIndex, ifthen(i = fNumberOfFrames, 3, 2));
+      end
+      else
+      begin
+        lFrameScore := SumOfPinsInFrame(lFrameIndex);
+        if (lFrameScore < 0) or (lFrameScore > 10) then
+          raise EArgumentException.Create('Not a proper game');
+
+        lScore := lScore + lFrameScore;
+        inc(lFrameIndex, 2);
+      end;
     end;
+    result := ifthen(CorrectNumberOfRolls(lFrameIndex), lScore, -1);
+  except
+    result := -1;
   end;
-  result := lScore;
 end;
 
 function TBowlingGame.IsStrike(aFrameIndex: Integer): Boolean;
@@ -102,4 +126,9 @@ begin
   result := fRolls[aFrameIndex] + fRolls[aFrameIndex + 1];
 end;
 
+function TBowlingGame.CorrectNumberOfRolls(aFrameIndex: Integer): boolean;
+begin
+  result := aFrameIndex = fRolls.Count;
+end;
+
 end.

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

@@ -10,90 +10,281 @@ type
   [TestFixture]
   BowlingTests = class(TObject)
   private
-    class procedure RollMany(pins: integer; count: integer; game: IBowlingGame); static;
-    class procedure RollSpare(game: IBowlingGame); static;
-    class procedure RollStrike(game: IBowlingGame); static;
+    class function RollMany(pins: array of integer; game: IBowlingGame): IBowlingGame; static;
   public
     [Test]
-    [Ignore]
-    procedure Gutter_game;
+    procedure Should_be_able_to_score_a_game_with_all_zeros;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure Should_be_able_to_score_a_game_with_no_strikes_or_spares;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure A_spare_followed_by_zeros_is_worth_ten_points;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure Points_scored_in_the_roll_after_a_spare_are_counted_twice;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure Consecutive_spares_each_get_a_one_roll_bonus;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure A_spare_in_the_last_frame_gets_a_one_roll_bonus_that_is_counted_once;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure A_strike_earns_ten_points_in_frame_with_a_single_roll;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure Points_scored_in_the_two_rolls_after_a_strike_are_counted_twice_as_a_bonus;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure Consecutive_strikes_each_get_the_two_roll_bonus;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure A_strike_in_the_last_frame_gets_a_two_roll_bonus_that_is_counted_once;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure Rolling_a_spare_with_the_two_roll_bonus_does_not_get_a_bonus_roll;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure Strikes_with_the_two_roll_bonus_do_not_get_bonus_rolls;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure A_strike_with_the_one_roll_bonus_after_a_spare_in_the_last_frame_does_not_get_a_bonus;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure All_strikes_is_a_perfect_game;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure Rolls_can_not_score_negative_points;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure A_roll_can_not_score_more_than_10_points;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure Two_rolls_in_a_frame_can_not_score_more_than_10_points;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure Two_bonus_rolls_after_a_strike_in_the_last_frame_can_not_score_more_than_10_points;
+
     [Test]
-    [Ignore]
-    procedure All_ones_game;
+    [Ignore('Comment this line to run this test')]
+    procedure An_unstarted_game_can_not_be_scored;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure An_incomplete_game_can_not_be_scored;
+
     [Test]
-    [Ignore]
-    procedure One_spare_game;
+    [Ignore('Comment this line to run this test')]
+    procedure A_game_with_more_than_ten_frames_can_not_be_scored;
+
     [Test]
-    [Ignore]
-    procedure One_strike_game;
+    [Ignore('Comment this line to run this test')]
+    procedure Bonus_rolls_for_a_strike_in_the_last_frame_must_be_rolled_before_score_can_be_calculated;
+
+    [Test]
+    [Ignore('Comment this line to run this test')]
+    procedure Both_bonus_rolls_for_a_strike_in_the_last_frame_must_be_rolled_before_score_can_be_calculated;
+
     [Test]
-    [Ignore]
-    procedure Perfect_game;
+    [Ignore('Comment this line to run this test')]
+    procedure Bonus_roll_for_a_spare_in_the_last_frame_must_be_rolled_before_score_can_be_calculated;
   end;
 
 implementation
+uses System.SysUtils;
 
-procedure BowlingTests.Gutter_game;
+procedure BowlingTests.Should_be_able_to_score_a_game_with_all_zeros;
 var game: IBowlingGame;
 begin
-  game := NewBowlingGame;
-  RollMany(0,20,game);
-  assert.AreEqual(0,game.Score);
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], NewBowlingGame);
+  assert.AreEqual(0, game.Score);
 end;
 
-procedure BowlingTests.All_ones_game;
+procedure BowlingTests.Should_be_able_to_score_a_game_with_no_strikes_or_spares;
 var game: IBowlingGame;
 begin
-  game := NewBowlingGame;
-  RollMany(1, 20, game);
-  assert.AreEqual(20,game.Score);
+  game := RollMany([3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6], NewBowlingGame);
+  assert.AreEqual(90, game.Score);
 end;
 
-procedure BowlingTests.One_spare_game;
+procedure BowlingTests.A_spare_followed_by_zeros_is_worth_ten_points;
 var game: IBowlingGame;
 begin
-  game := NewBowlingGame;
-  RollSpare(game);
-  game.Roll(3);
-  RollMany(0, 17, game);
+  game := RollMany([6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], NewBowlingGame);
+  assert.AreEqual(10, game.Score);
+end;
+
+procedure BowlingTests.Points_scored_in_the_roll_after_a_spare_are_counted_twice;
+var game: IBowlingGame;
+begin
+  game := RollMany([6, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], NewBowlingGame);
   assert.AreEqual(16, game.Score);
 end;
 
-procedure BowlingTests.One_strike_game;
+procedure BowlingTests.Consecutive_spares_each_get_a_one_roll_bonus;
+var game: IBowlingGame;
+begin
+  game := RollMany([5, 5, 3, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], NewBowlingGame);
+  assert.AreEqual(31, game.Score);
+end;
+
+procedure BowlingTests.A_spare_in_the_last_frame_gets_a_one_roll_bonus_that_is_counted_once;
+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, 7], NewBowlingGame);
+  assert.AreEqual(17, game.Score);
+end;
+
+procedure BowlingTests.A_strike_earns_ten_points_in_frame_with_a_single_roll;
+var game: IBowlingGame;
+begin
+  game := RollMany([10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], NewBowlingGame);
+  assert.AreEqual(10, game.Score);
+end;
+
+procedure BowlingTests.Points_scored_in_the_two_rolls_after_a_strike_are_counted_twice_as_a_bonus;
+var game: IBowlingGame;
+begin
+  game := RollMany([10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], NewBowlingGame);
+  assert.AreEqual(26, game.Score);
+end;
+
+procedure BowlingTests.Consecutive_strikes_each_get_the_two_roll_bonus;
+var game: IBowlingGame;
+begin
+  game := RollMany([10, 10, 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], NewBowlingGame);
+  assert.AreEqual(81, game.Score);
+end;
+
+procedure BowlingTests.A_strike_in_the_last_frame_gets_a_two_roll_bonus_that_is_counted_once;
+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, 7, 1], NewBowlingGame);
+  assert.AreEqual(18, game.Score);
+end;
+
+procedure BowlingTests.Rolling_a_spare_with_the_two_roll_bonus_does_not_get_a_bonus_roll;
+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, 7, 3], NewBowlingGame);
+  assert.AreEqual(20, game.Score);
+end;
+
+procedure BowlingTests.Strikes_with_the_two_roll_bonus_do_not_get_bonus_rolls;
+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, 10], NewBowlingGame);
+  assert.AreEqual(30, game.Score);
+end;
+
+procedure BowlingTests.A_strike_with_the_one_roll_bonus_after_a_spare_in_the_last_frame_does_not_get_a_bonus;
+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, 10], NewBowlingGame);
+  assert.AreEqual(20, game.Score);
+end;
+
+procedure BowlingTests.All_strikes_is_a_perfect_game;
+var game: IBowlingGame;
+begin
+  game := RollMany([10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10], NewBowlingGame);
+  assert.AreEqual(300, game.Score);
+end;
+
+procedure BowlingTests.Rolls_can_not_score_negative_points;
+var game: IBowlingGame;
+begin
+  game := RollMany([-1, 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);
+end;
+
+procedure BowlingTests.A_roll_can_not_score_more_than_10_points;
+var game: IBowlingGame;
+begin
+  game := RollMany([11, 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);
+end;
+
+procedure BowlingTests.Two_rolls_in_a_frame_can_not_score_more_than_10_points;
+var game: IBowlingGame;
+begin
+  game := RollMany([5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], NewBowlingGame);
+  Assert.AreEqual(-1, game.Score);
+end;
+
+procedure BowlingTests.Two_bonus_rolls_after_a_strike_in_the_last_frame_can_not_score_more_than_10_points;
 var game: IBowlingGame;
 begin
-  game := NewBowlingGame;
-  RollStrike(game);
-  game.Roll(3);
-  game.Roll(4);
-  RollMany(0, 16, game);
-  assert.AreEqual(24, game.Score);
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5, 6], NewBowlingGame);
+  Assert.AreEqual(-1, game.Score);
 end;
 
-procedure BowlingTests.Perfect_game;
+procedure BowlingTests.An_unstarted_game_can_not_be_scored;
 var game: IBowlingGame;
 begin
-  game := NewBowlingGame;
-  RollMany(10, 12, game);
-  assert.AreEqual(300, Game.Score);
+  game := RollMany([],NewBowlingGame);
+  Assert.AreEqual(-1, game.Score);
 end;
 
-class procedure BowlingTests.RollMany(pins: integer; count: integer; game: IBowlingGame);
-var i: integer;
+procedure BowlingTests.An_incomplete_game_can_not_be_scored;
+var game: IBowlingGame;
+begin
+  game := RollMany([0, 0], NewBowlingGame);
+  Assert.AreEqual(-1, game.Score);
+end;
+
+procedure BowlingTests.A_game_with_more_than_ten_frames_can_not_be_scored;
+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);
+end;
+
+procedure BowlingTests.Bonus_rolls_for_a_strike_in_the_last_frame_must_be_rolled_before_score_can_be_calculated;
+var game: IBowlingGame;
 begin
-  for i := 0 to count - 1 do
-    game.Roll(pins);
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10], NewBowlingGame);
+  Assert.AreEqual(-1, game.Score);
 end;
 
-class procedure BowlingTests.RollSpare(game: IBowlingGame);
+procedure BowlingTests.Both_bonus_rolls_for_a_strike_in_the_last_frame_must_be_rolled_before_score_can_be_calculated;
+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.AreEqual(-1, game.Score);
+end;
+
+procedure BowlingTests.Bonus_roll_for_a_spare_in_the_last_frame_must_be_rolled_before_score_can_be_calculated;
+var game: IBowlingGame;
 begin
-  game.Roll(5);
-  game.Roll(5);
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3], NewBowlingGame);
+  Assert.AreEqual(-1, game.Score);
 end;
 
-class procedure BowlingTests.RollStrike(game: IBowlingGame);
+class function BowlingTests.RollMany(pins: array of integer; game: IBowlingGame): IBowlingGame;
+var count: integer;
 begin
-  game.Roll(10);
+  for count in pins do
+    game.Roll(count);
+  result := game;
 end;
 
 initialization

data/tracks/go/exercises/forth/example.go

@@ -10,25 +10,25 @@ import (
 
 type operatorFn func(stack *[]int) error
 
-type operatorId byte
+type operatorID byte
 
 const (
-	addOp operatorId = iota
-	subOp
-	mulOp
-	divOp
-	dropOp
-	dupOp
-	swapOp
-	overOp
-	constOp
-	userDefOp
-	endDefOp
+	opAdd operatorID = iota
+	opSub
+	opMul
+	opDiv
+	opDrop
+	opDup
+	opSwap
+	opOver
+	opConst
+	opUserDef
+	opEndDef
 )
 
 type operatorTyp struct {
 	fn operatorFn
-	id operatorId
+	id operatorID
 }
 
 func Forth(input []string) (result []int, err error) {
@@ -73,15 +73,15 @@ func parse(phrase string, userDefs map[string][]operatorTyp) (oplist []operatorT
 		if udef, ok := userDefs[w]; ok {
 			oplist = append(oplist, udef...)
 		} else if op, ok := builtinOps[w]; ok {
-			if op.id == userDefOp {
+			if op.id == opUserDef {
 				// Handle user defined word definition.
 				t++
 				if t >= len(words)-2 {
-					return nil, emptyUserDefErr
+					return nil, errEmptyUserDef
 				}
 				userword := strings.ToUpper(words[t])
 				if _, numerr := strconv.Atoi(userword); numerr == nil {
-					return nil, invalidUserDefErr
+					return nil, errInvalidUserDef
 				}
 				t++
 				var userops []operatorTyp
@@ -90,17 +90,16 @@ func parse(phrase string, userDefs map[string][]operatorTyp) (oplist []operatorT
 					if err != nil {
 						return nil, err
 					}
-					if oneOp[0].id == endDefOp {
+					if oneOp[0].id == opEndDef {
 						break
 					}
 					userops = append(userops, oneOp...)
 					t++
 				}
 				if len(userops) == 0 {
-					return nil, emptyUserDefErr
-				} else {
-					userDefs[userword] = userops
+					return nil, errEmptyUserDef
 				}
+				userDefs[userword] = userops
 			} else {
 				// Normal builtin operator.
 				oplist = append(oplist, op)
@@ -113,7 +112,7 @@ func parse(phrase string, userDefs map[string][]operatorTyp) (oplist []operatorT
 				return nil, err
 			}
 			oplist = append(oplist,
-				operatorTyp{id: constOp,
+				operatorTyp{id: opConst,
 					fn: func(stack *[]int) error {
 						push(stack, x)
 						return nil
@@ -126,16 +125,16 @@ func parse(phrase string, userDefs map[string][]operatorTyp) (oplist []operatorT
 
 // builtinOps are the pre-defined operators to support.
 var builtinOps = map[string]operatorTyp{
-	"+":    {add, addOp},
-	"-":    {subtract, subOp},
-	"*":    {multiply, mulOp},
-	"/":    {divide, divOp},
-	"DUP":  {dup, dropOp},
-	"DROP": {drop, dupOp},
-	"SWAP": {swap, swapOp},
-	"OVER": {over, overOp},
-	":":    {nil, userDefOp},
-	";":    {nil, endDefOp},
+	"+":    {add, opAdd},
+	"-":    {subtract, opSub},
+	"*":    {multiply, opMul},
+	"/":    {divide, opDiv},
+	"DUP":  {dup, opDrop},
+	"DROP": {drop, opDup},
+	"SWAP": {swap, opSwap},
+	"OVER": {over, opOver},
+	":":    {nil, opUserDef},
+	";":    {nil, opEndDef},
 }
 
 func pop(stack *[]int) (v int, err error) {
@@ -145,7 +144,7 @@ func pop(stack *[]int) (v int, err error) {
 		*stack = (*stack)[:slen-1]
 		return v, nil
 	}
-	return 0, notEnoughOperands
+	return 0, errNotEnoughOperands
 }
 
 func pop2(stack *[]int) (v1, v2 int, err error) {
@@ -188,7 +187,7 @@ func divide(stack *[]int) error {
 		return err
 	}
 	if v1 == 0 {
-		return divideByZero
+		return errDivideByZero
 	}
 	push(stack, v2/v1)
 	return nil
@@ -230,9 +229,9 @@ func swap(stack *[]int) error {
 	return nil
 }
 
-var notEnoughOperands error = errors.New("not enough operands")
-var divideByZero error = errors.New("attempt to divide by zero")
-var emptyUserDefErr error = errors.New("empty user definition")
-var invalidUserDefErr error = errors.New("invalid user def word")
+var errNotEnoughOperands = errors.New("not enough operands")
+var errDivideByZero = errors.New("attempt to divide by zero")
+var errEmptyUserDef = errors.New("empty user definition")
+var errInvalidUserDef = errors.New("invalid user def word")
 
 const testVersion = 1

data/tracks/go/exercises/kindergarten-garden/kindergarten_garden_test.go

@@ -140,7 +140,7 @@ func TestGarden(t *testing.T) {
 					t.Fatalf("Garden %d lookup %s returned ok = %t, want %t.",
 						test.number, l.child, ok, l.ok)
 				case ok && !reflect.DeepEqual(plants, l.plants):
-					t.Fatalf("Garden %d lookup %s = %v, want %v.",
+					t.Fatalf("Garden %d lookup %s = %q, want %q.",
 						test.number, l.child, plants, l.plants)
 				}
 			}
@@ -192,7 +192,7 @@ RVGCCGCV`
 			t.Skip("Garden %d lookup %s returned ok = false, want true.",
 				n, child)
 		case !reflect.DeepEqual(plants, expPlants):
-			t.Fatalf("Garden %d lookup %s = %v, want %v.",
+			t.Fatalf("Garden %d lookup %s = %q, want %q.",
 				n, child, plants, expPlants)
 		}
 	}

data/tracks/java/exercises/allergies/src/test/java/AllergiesTest.java

@@ -90,6 +90,8 @@ public class AllergiesTest {
         Allergies allergies = new Allergies(5);
 
         assertEquals(true, allergies.isAllergicTo(Allergen.EGGS));
+        assertEquals(true, allergies.isAllergicTo(Allergen.SHELLFISH));
+        assertEquals(false, allergies.isAllergicTo(Allergen.STRAWBERRIES));
     }
 
     @Ignore

data/tracks/scala/config.json

@@ -264,6 +264,16 @@
             "Filtering"
          ]
       },
+      {
+         "slug":"simple-linked-list",
+         "difficulty":1,
+         "topics":[
+            "Classes",
+            "Lists",
+            "Transforming",
+            "Generics"
+         ]
+      },
       {
          "slug":"atbash-cipher",
          "difficulty":1,

data/tracks/scala/exercises/simple-linked-list/build.sbt

@@ -0,0 +1,3 @@
+scalaVersion := "2.12.1"
+
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.1" % "test"

data/tracks/scala/exercises/simple-linked-list/example.scala

@@ -0,0 +1,95 @@
+class Node[+T]
+case object Empty extends Node[Nothing]
+case class NonEmpty[T](value: T, next: Node[T]) extends Node[T]
+
+trait SimpleLinkedList[T] {
+  def isEmpty: Boolean
+  def value: T
+  def add(item: T): SimpleLinkedList[T]
+  def next: SimpleLinkedList[T]
+  def reverse: SimpleLinkedList[T]
+  def toSeq: Seq[T]
+}
+
+class SimpleLinkedListImpl[T](first: Node[T]) extends SimpleLinkedList[T] {
+
+  def isEmpty: Boolean = first == Empty
+
+  def value: T = first match {
+    case Empty => throw new NoSuchElementException
+    case node: NonEmpty[T] => node.value
+  }
+
+  def add(item: T): SimpleLinkedList[T] = {
+    var reversed = reverse
+    var current = NonEmpty[T](item, Empty)
+
+    while (!reversed.isEmpty) {
+      val value = reversed.value
+      val newNode = NonEmpty[T](value, current)
+
+      current = newNode
+      reversed = reversed.next
+    }
+
+    new SimpleLinkedListImpl[T](current)
+  }
+
+  def next: SimpleLinkedList[T] = first match {
+    case Empty => this
+    case node: NonEmpty[T] => new SimpleLinkedListImpl[T](first.asInstanceOf[NonEmpty[T]].next)
+  }
+
+  def reverse: SimpleLinkedList[T] = {
+    var newLast: Node[T] = Empty
+    var prev: Node[T] = Empty
+    var current = first
+    var next: Node[T] = Empty
+    while (current != Empty) {
+      val newNode = NonEmpty[T](current.asInstanceOf[NonEmpty[T]].value, prev)
+
+      if (newLast == Empty) {
+        newLast = newNode
+      }
+
+      next = current.asInstanceOf[NonEmpty[T]].next
+      prev = newNode
+      current = next
+    }
+
+    new SimpleLinkedListImpl[T](prev)
+  }
+
+  def length: Int = {
+    var len = 0
+
+    var current = first
+    while (current != Empty) {
+      len = len + 1
+      current = current.asInstanceOf[NonEmpty[T]].next
+    }
+
+    len
+  }
+
+  def toSeq: Seq[T] = {
+    var xs = List[T]()
+
+    var current = first
+    while (current != Empty) {
+      xs = current.asInstanceOf[NonEmpty[T]].value :: xs
+      current = current.asInstanceOf[NonEmpty[T]].next
+    }
+
+    xs.reverse
+  }
+}
+
+object SimpleLinkedList {
+  def apply[T](): SimpleLinkedList[T] = new SimpleLinkedListImpl[T](Empty)
+
+  def apply[T](ts: T*): SimpleLinkedList[T] = fromSeq(ts)
+
+  def fromSeq[T](seq: Seq[T]): SimpleLinkedList[T] =
+    seq.foldLeft(SimpleLinkedList[T]())((acc, t) => acc.add(t))
+}

data/tracks/scala/exercises/simple-linked-list/src/main/scala/SimpleLinkedList.scala

@@ -0,0 +1,8 @@
+trait SimpleLinkedList[T] {
+  def isEmpty: Boolean
+  def value: T
+  def add(item: T): SimpleLinkedList[T]
+  def next: SimpleLinkedList[T]
+  def reverse: SimpleLinkedList[T]
+  def toSeq: Seq[T]
+}

data/tracks/scala/exercises/simple-linked-list/src/test/scala/SimpleLinkedListTest.scala

@@ -0,0 +1,108 @@
+import org.scalacheck.{Arbitrary}
+import org.scalatest.prop.GeneratorDrivenPropertyChecks
+import org.scalatest.{FlatSpec, Matchers}
+
+
+class SimpleLinkedListTest extends FlatSpec with Matchers with GeneratorDrivenPropertyChecks {
+
+  private implicit def arbitrarySimpleLinkedList[T](implicit arbitraryTs: Arbitrary[Array[T]]): Arbitrary[SimpleLinkedList[T]] =
+    Arbitrary {
+      arbitraryTs.arbitrary map (SimpleLinkedList(_:_*))
+    }
+
+  it should "handle single item list" in {
+    val list = SimpleLinkedList().add(1)
+    list.isEmpty should be (false)
+    list.value should be (1)
+  }
+
+  it should "handle single item has no next item" in {
+    pending
+    val list = SimpleLinkedList().add(1)
+    list.next.isEmpty should be (true)
+  }
+
+  it should "handle two item list" in {
+    pending
+    val list = SimpleLinkedList().add(1).add(2)
+    list.value should be (1)
+    list.next.value should be (2)
+  }
+
+  it should "handle two item list has no next value" in {
+    pending
+    val list = SimpleLinkedList().add(1).add(2)
+    list.next.next.isEmpty should be (true)
+  }
+
+  it should "allow creation from a Seq" in {
+    pending
+    val list = SimpleLinkedList.fromSeq(List(3, 2, 1))
+    list.value should be (3)
+    list.next.value should be (2)
+    list.next.next.value should be (1)
+  }
+
+  it should "allow conversion to a Seq" in {
+    pending
+    val list = SimpleLinkedList.fromSeq(List(3, 2, 1))
+    val seq = list.toSeq
+    seq should be (List(3, 2, 1))
+  }
+
+  it should "handle reverse" in {
+    pending
+    val list = SimpleLinkedList.fromSeq(List(1, 2, 3, 4, 5, 6))
+    val reversed = list.reverse
+    reversed.value should be (6)
+    reversed.next.value should be (5)
+    reversed.next.next.value should be (4)
+    reversed.next.next.next.value should be (3)
+    reversed.next.next.next.next.value should be (2)
+    reversed.next.next.next.next.next.value should be (1)
+  }
+  
+  it should "handle arbitrary list fromSeq toSeq" in {
+    pending
+    forAll { seq: Seq[Int] =>
+      assert(SimpleLinkedList.fromSeq(seq).toSeq == seq)
+    }
+  }
+
+  it should "handle reverse arbitrary list " in {
+    pending
+    forAll { seq: Seq[Int] =>
+      assert(SimpleLinkedList.fromSeq(seq).reverse.toSeq == seq.reverse)
+    }
+  }
+
+  it should "reverse arbitrary list back to original" in {
+    pending
+    forAll { list: SimpleLinkedList[Int] =>
+      assert(list.reverse.reverse.toSeq == list.toSeq)
+    }
+  }
+
+  it should "return correct arbitrary value at index" in {
+    pending
+    def nthDatum(list: SimpleLinkedList[Int], i: Int): Int = {
+      (0 until i).foldLeft(list)((acc, j) => acc.next).value
+    }
+
+    forAll { xs: Seq[Int]  =>
+      whenever(xs.nonEmpty) {
+        val list = SimpleLinkedList.fromSeq(xs)
+        xs.indices.foreach {
+          i => assert(nthDatum(list, i) == xs(i))
+        }
+      }
+    }
+  }
+
+  it should "handle arbitrary generics" in {
+    pending
+    forAll { xs: Seq[String] =>
+      assert(SimpleLinkedList.fromSeq(xs).toSeq == xs)
+    }
+  }
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.0.8.10
+  version: 2.0.8.11
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-03 00:00:00.000000000 Z
+date: 2017-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -7391,6 +7391,10 @@ files:
 - tracks/scala/exercises/simple-cipher/example.scala
 - tracks/scala/exercises/simple-cipher/src/main/scala/.keep
 - tracks/scala/exercises/simple-cipher/src/test/scala/CipherTest.scala
+- tracks/scala/exercises/simple-linked-list/build.sbt
+- tracks/scala/exercises/simple-linked-list/example.scala
+- tracks/scala/exercises/simple-linked-list/src/main/scala/SimpleLinkedList.scala
+- tracks/scala/exercises/simple-linked-list/src/test/scala/SimpleLinkedListTest.scala
 - tracks/scala/exercises/space-age/build.sbt
 - tracks/scala/exercises/space-age/example.scala
 - tracks/scala/exercises/space-age/src/main/scala/.keep