trackler 2.2.1.120 → 2.2.1.121

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a486b638b9189b70b5b8a98fdc0d8507d2809db2
-  data.tar.gz: 36a67377a22749bad5a8de5820deba5cad99ddbe
+  metadata.gz: 79523d8a19c7d2f3b248cd1914ca6a5cdd60a08c
+  data.tar.gz: 12d9dc9779fd141256d07b4547a421fa579245fc
 SHA512:
-  metadata.gz: 196bf7990a971994d171d907d1a89f4abd5d06b7771d5a410ac5158d989f1b34b28231a22bf033ad57e1d1eff0c0c15fbcc075176df98664f43e378ece4a079d
-  data.tar.gz: a20674462cc9aa55651ecead73275a7bfd4fd844a56db788ab80517937470039cc687e2e4a650d1893fd7fa1d60da51c32abd751239d130dcec217c3f5362799
+  metadata.gz: e61ec423a5e5ec0c1a24f0db7adb7b7d3888b92b7dedb9044c0a77a2b81eedc19d327c9938c82e0a61881e9e8e1d48a9513ddf60bbc75399121b313e3578a3ef
+  data.tar.gz: d6a7ead384bd7881be86acb5801fa158422120e44dc4213dca1f3058cde2ea67ab5c8c727b54d7e93a73d0a09091c5f2478e827fcf3ec02450f245355b1362cb

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.120"
+  VERSION = "2.2.1.121"
 end

data/tracks/javascript/.eslintignore

@@ -1,8 +1,5 @@
 big-integer.js
-exercises/custom-set
-exercises/flatten-array
 exercises/grains/big-integer.js
 exercises/grains/big-integer.spec.js
-exercises/queen-attack
 exercises/robot-simulator
 exercises/simple-cipher

data/tracks/javascript/exercises/bowling/bowling.spec.js

@@ -208,5 +208,21 @@ describe('Bowling', function () {
       expect(function () { bowling.score(); }).toThrow(
         new Error('Score cannot be taken until the end of the game'));
     });
+
+    xit('cannot roll after bonus roll for a spare', function () {
+      var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 2];
+      var bowling = new Bowling();
+      previousRolls(bowling, rolls);
+      expect(function () { bowling.roll(2); }).toThrow(
+        new Error('Cannot roll after game is over'));
+    });
+
+    xit('cannot roll after bonus rolls for a strike', function () {
+      var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 3, 2];
+      var bowling = new Bowling();
+      previousRolls(bowling, rolls);
+      expect(function () { bowling.roll(2); }).toThrow(
+        new Error('Cannot roll after game is over'));
+    });
   });
 });

data/tracks/prolog/.github/stale.yml

@@ -0,0 +1 @@
+

data/tracks/prolog/config.json

@@ -1,6 +1,6 @@
 {
   "language": "Prolog",
-  "active": false,
+  "active": true,
   "exercises": [
     {
       "uuid": "68a85ec5-acdd-4f4f-9b9e-a5e39f1f7ac0",
@@ -140,6 +140,16 @@
       "difficulty": 1,
       "topics": [
 
+      ]
+    },
+    {
+      "uuid": "b7022a0f-9fda-4144-ae1e-11615bac0f56",
+      "slug": "pascals-triangle",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+
       ]
     }
   ],

data/tracks/prolog/docs/RESOURCES.md

@@ -3,3 +3,4 @@
 * [SWISH - An online Prolog REPL](http://swish.swi-prolog.org/)
 * [Prolog on Stack Overflow](https://stackoverflow.com/tags/prolog)
 * [Tutorials and Resources](http://www.swi-prolog.org/Links.html)
+* [A Taste of Prolog by Aja Hammerly](https://www.youtube.com/watch?v=hEOVcLAPRG8)

data/tracks/prolog/exercises/pascals-triangle/README.md

@@ -0,0 +1,19 @@
+Compute Pascal's triangle up to a given number of rows.
+
+In Pascal's Triangle each number is computed by adding the numbers to
+the right and left of the current position in the previous row.
+
+```text
+    1
+   1 1
+  1 2 1
+ 1 3 3 1
+1 4 6 4 1
+# ... etc
+```
+## Source
+
+[Pascal's Triangle at Wolfram Math World](http://mathworld.wolfram.com/PascalsTriangle.html)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/prolog/exercises/pascals-triangle/pascals_triangle.example

@@ -0,0 +1,15 @@
+pascal(0, []) :- !.
+pascal(X, P)  :-
+  numlist(1, X, NL),
+  maplist(pascalH, NL, P).
+
+pascalH(1, [1])   :- !.
+pascalH(N, [X|L]) :-
+  succ(N1, N),
+  pascalH(N1, [X|L1]),
+  build([X|L1], L), !.
+
+build([X],     [X]).
+build([X,Y|Z], [H|R]) :-
+  H is X+Y,
+  build([Y|Z], R).

data/tracks/prolog/exercises/pascals-triangle/pascals_triangle.pl

@@ -0,0 +1 @@
+pascal(false).

data/tracks/prolog/exercises/pascals-triangle/pascals_triangle_tests.plt

@@ -0,0 +1,43 @@
+pending :-
+    current_prolog_flag(argv, ['--all'|_]).
+pending :-
+    write('\nA TEST IS PENDING!\n'),
+    fail.
+
+:- begin_tests(pascal).
+
+    test(zero_rows, condition(true)) :-
+      pascal(0, []).
+
+    test(single_row, condition(pending)) :-
+      pascal(1, [[1]]).
+
+    test(two_rows, condition(pending)) :-
+      pascal(2, [[1], [1,1]]).
+
+    test(three_rows, condition(pending)) :-
+      pascal(3, [[1], [1,1], [1,2,1]]).
+
+    test(four_rows, condition(pending)) :-
+      pascal(4, [[1], [1,1], [1,2,1], [1,3,3,1]]).
+
+    test(five_rows, condition(pending)) :-
+      pascal(5, [[1], [1,1], [1,2,1], [1,3,3,1], [1,4,6,4,1]]).
+
+    test(six_rows, condition(pending)) :-
+      pascal(6, [[1], [1,1], [1,2,1], [1,3,3,1], [1,4,6,4,1], [1,5,10,10,5,1]]).
+
+    test(ten_rows, condition(pending)) :-
+      pascal(10, [ [1],
+                   [1,1],
+                   [1,2,1],
+                   [1,3,3,1],
+                   [1,4,6,4,1],
+                   [1,5,10,10,5,1],
+                   [1,6,15,20,15,6,1],
+                   [1,7,21,35,35,21,7,1],
+                   [1,8,28,56,70,56,28,8,1],
+                   [1,9,36,84,126,126,84,36,9,1]
+                 ]).
+
+:- end_tests(pascal).

data/tracks/scala/exercises/all-your-base/src/test/scala/AllYourBaseTest.scala

@@ -1,109 +1,111 @@
 import org.scalatest.{Matchers, FunSuite}
 
-/** @version 2.2.0 */
+/** @version 2.3.0 */
 class AllYourBaseTest extends FunSuite with Matchers {
 
   test("single bit one to decimal") {
-    AllYourBase.rebase(2, List(1), 10) should be (Some(List(1)))
+    AllYourBase.rebase(2, List(1), 10) should be(Some(List(1)))
   }
 
   test("binary to single decimal") {
     pending
-    AllYourBase.rebase(2, List(1, 0, 1), 10) should be (Some(List(5)))
+    AllYourBase.rebase(2, List(1, 0, 1), 10) should be(Some(List(5)))
   }
 
   test("single decimal to binary") {
     pending
-    AllYourBase.rebase(10, List(5), 2) should be (Some(List(1, 0, 1)))
+    AllYourBase.rebase(10, List(5), 2) should be(Some(List(1, 0, 1)))
   }
 
   test("binary to multiple decimal") {
     pending
-    AllYourBase.rebase(2, List(1, 0, 1, 0, 1, 0), 10) should be (Some(List(4, 2)))
+    AllYourBase.rebase(2, List(1, 0, 1, 0, 1, 0), 10) should be(
+      Some(List(4, 2)))
   }
 
   test("decimal to binary") {
     pending
-    AllYourBase.rebase(10, List(4, 2), 2) should be (Some(List(1, 0, 1, 0, 1, 0)))
+    AllYourBase.rebase(10, List(4, 2), 2) should be(
+      Some(List(1, 0, 1, 0, 1, 0)))
   }
 
   test("trinary to hexadecimal") {
     pending
-    AllYourBase.rebase(3, List(1, 1, 2, 0), 16) should be (Some(List(2, 10)))
+    AllYourBase.rebase(3, List(1, 1, 2, 0), 16) should be(Some(List(2, 10)))
   }
 
   test("hexadecimal to trinary") {
     pending
-    AllYourBase.rebase(16, List(2, 10), 3) should be (Some(List(1, 1, 2, 0)))
+    AllYourBase.rebase(16, List(2, 10), 3) should be(Some(List(1, 1, 2, 0)))
   }
 
   test("15-bit integer") {
     pending
-    AllYourBase.rebase(97, List(3, 46, 60), 73) should be (Some(List(6, 10, 45)))
+    AllYourBase.rebase(97, List(3, 46, 60), 73) should be(Some(List(6, 10, 45)))
   }
 
   test("empty list") {
     pending
-    AllYourBase.rebase(2, List(), 10) should be (Some(List(0)))
+    AllYourBase.rebase(2, List(), 10) should be(Some(List(0)))
   }
 
   test("single zero") {
     pending
-    AllYourBase.rebase(10, List(0), 2) should be (Some(List(0)))
+    AllYourBase.rebase(10, List(0), 2) should be(Some(List(0)))
   }
 
   test("multiple zeros") {
     pending
-    AllYourBase.rebase(10, List(0, 0, 0), 2) should be (Some(List(0)))
+    AllYourBase.rebase(10, List(0, 0, 0), 2) should be(Some(List(0)))
   }
 
   test("leading zeros") {
     pending
-    AllYourBase.rebase(7, List(0, 6, 0), 10) should be (Some(List(4, 2)))
+    AllYourBase.rebase(7, List(0, 6, 0), 10) should be(Some(List(4, 2)))
   }
 
   test("input base is one") {
     pending
-    AllYourBase.rebase(1, List(), 10) should be (None)
+    AllYourBase.rebase(1, List(0), 10) should be(None)
   }
 
   test("input base is zero") {
     pending
-    AllYourBase.rebase(0, List(), 10) should be (None)
+    AllYourBase.rebase(0, List(), 10) should be(None)
   }
 
   test("input base is negative") {
     pending
-    AllYourBase.rebase(-2, List(1), 10) should be (None)
+    AllYourBase.rebase(-2, List(1), 10) should be(None)
   }
 
   test("negative digit") {
     pending
-    AllYourBase.rebase(2, List(1, -1, 1, 0, 1, 0), 10) should be (None)
+    AllYourBase.rebase(2, List(1, -1, 1, 0, 1, 0), 10) should be(None)
   }
 
   test("invalid positive digit") {
     pending
-    AllYourBase.rebase(2, List(1, 2, 1, 0, 1, 0), 10) should be (None)
+    AllYourBase.rebase(2, List(1, 2, 1, 0, 1, 0), 10) should be(None)
   }
 
   test("output base is one") {
     pending
-    AllYourBase.rebase(2, List(1, 0, 1, 0, 1, 0), 1) should be (None)
+    AllYourBase.rebase(2, List(1, 0, 1, 0, 1, 0), 1) should be(None)
   }
 
   test("output base is zero") {
     pending
-    AllYourBase.rebase(10, List(7), 0) should be (None)
+    AllYourBase.rebase(10, List(7), 0) should be(None)
   }
 
   test("output base is negative") {
     pending
-    AllYourBase.rebase(2, List(1), -7) should be (None)
+    AllYourBase.rebase(2, List(1), -7) should be(None)
   }
 
   test("both bases are negative") {
     pending
-    AllYourBase.rebase(-2, List(1), -7) should be (None)
+    AllYourBase.rebase(-2, List(1), -7) should be(None)
   }
-}
+}

data/tracks/scala/exercises/clock/src/test/scala/ClockTest.scala

@@ -1,254 +1,254 @@
 import org.scalatest.{Matchers, FunSuite}
 
-/** @version 1.0.1 */
+/** @version 2.2.1 */
 class ClockTest extends FunSuite with Matchers {
 
   test("on the hour") {
-    Clock(8, 0) should be (Clock(8, 0))
+    Clock(8, 0) should be(Clock(8, 0))
   }
 
   test("past the hour") {
     pending
-    Clock(11, 9) should be (Clock(11, 9))
+    Clock(11, 9) should be(Clock(11, 9))
   }
 
   test("midnight is zero hours") {
     pending
-    Clock(24, 0) should be (Clock(0, 0))
+    Clock(24, 0) should be(Clock(0, 0))
   }
 
   test("hour rolls over") {
     pending
-    Clock(25, 0) should be (Clock(1, 0))
+    Clock(25, 0) should be(Clock(1, 0))
   }
 
   test("hour rolls over continuously") {
     pending
-    Clock(100, 0) should be (Clock(4, 0))
+    Clock(100, 0) should be(Clock(4, 0))
   }
 
   test("sixty minutes is next hour") {
     pending
-    Clock(1, 60) should be (Clock(2, 0))
+    Clock(1, 60) should be(Clock(2, 0))
   }
 
   test("minutes roll over") {
     pending
-    Clock(0, 160) should be (Clock(2, 40))
+    Clock(0, 160) should be(Clock(2, 40))
   }
 
   test("minutes roll over continuously") {
     pending
-    Clock(0, 1723) should be (Clock(4, 43))
+    Clock(0, 1723) should be(Clock(4, 43))
   }
 
   test("hour and minutes roll over") {
     pending
-    Clock(25, 160) should be (Clock(3, 40))
+    Clock(25, 160) should be(Clock(3, 40))
   }
 
   test("hour and minutes roll over continuously") {
     pending
-    Clock(201, 3001) should be (Clock(11, 1))
+    Clock(201, 3001) should be(Clock(11, 1))
   }
 
   test("hour and minutes roll over to exactly midnight") {
     pending
-    Clock(72, 8640) should be (Clock(0, 0))
+    Clock(72, 8640) should be(Clock(0, 0))
   }
 
   test("negative hour") {
     pending
-    Clock(-1, 15) should be (Clock(23, 15))
+    Clock(-1, 15) should be(Clock(23, 15))
   }
 
   test("negative hour rolls over") {
     pending
-    Clock(-25, 0) should be (Clock(23, 0))
+    Clock(-25, 0) should be(Clock(23, 0))
   }
 
   test("negative hour rolls over continuously") {
     pending
-    Clock(-91, 0) should be (Clock(5, 0))
+    Clock(-91, 0) should be(Clock(5, 0))
   }
 
   test("negative minutes") {
     pending
-    Clock(1, -40) should be (Clock(0, 20))
+    Clock(1, -40) should be(Clock(0, 20))
   }
 
   test("negative minutes roll over") {
     pending
-    Clock(1, -160) should be (Clock(22, 20))
+    Clock(1, -160) should be(Clock(22, 20))
   }
 
   test("negative minutes roll over continuously") {
     pending
-    Clock(1, -4820) should be (Clock(16, 40))
+    Clock(1, -4820) should be(Clock(16, 40))
   }
 
   test("negative hour and minutes both roll over") {
     pending
-    Clock(-25, -160) should be (Clock(20, 20))
+    Clock(-25, -160) should be(Clock(20, 20))
   }
 
   test("negative hour and minutes both roll over continuously") {
     pending
-    Clock(-121, -5810) should be (Clock(22, 10))
+    Clock(-121, -5810) should be(Clock(22, 10))
   }
 
   test("add minutes") {
     pending
-    Clock(10, 0) + Clock(3) should be (Clock(10, 3))
+    Clock(10, 0) + Clock(3) should be(Clock(10, 3))
   }
 
   test("add no minutes") {
     pending
-    Clock(6, 41) + Clock(0) should be (Clock(6, 41))
+    Clock(6, 41) + Clock(0) should be(Clock(6, 41))
   }
 
   test("add to next hour") {
     pending
-    Clock(0, 45) + Clock(40) should be (Clock(1, 25))
+    Clock(0, 45) + Clock(40) should be(Clock(1, 25))
   }
 
   test("add more than one hour") {
     pending
-    Clock(10, 0) + Clock(61) should be (Clock(11, 1))
+    Clock(10, 0) + Clock(61) should be(Clock(11, 1))
   }
 
   test("add more than two hours with carry") {
     pending
-    Clock(0, 45) + Clock(160) should be (Clock(3, 25))
+    Clock(0, 45) + Clock(160) should be(Clock(3, 25))
   }
 
   test("add across midnight") {
     pending
-    Clock(23, 59) + Clock(2) should be (Clock(0, 1))
+    Clock(23, 59) + Clock(2) should be(Clock(0, 1))
   }
 
   test("add more than one day (1500 min = 25 hrs)") {
     pending
-    Clock(5, 32) + Clock(1500) should be (Clock(6, 32))
+    Clock(5, 32) + Clock(1500) should be(Clock(6, 32))
   }
 
   test("add more than two days") {
     pending
-    Clock(1, 1) + Clock(3500) should be (Clock(11, 21))
+    Clock(1, 1) + Clock(3500) should be(Clock(11, 21))
   }
 
   test("subtract minutes") {
     pending
-    Clock(10, 3) - Clock(3) should be (Clock(10, 0))
+    Clock(10, 3) - Clock(3) should be(Clock(10, 0))
   }
 
   test("subtract to previous hour") {
     pending
-    Clock(10, 3) - Clock(30) should be (Clock(9, 33))
+    Clock(10, 3) - Clock(30) should be(Clock(9, 33))
   }
 
   test("subtract more than an hour") {
     pending
-    Clock(10, 3) - Clock(70) should be (Clock(8, 53))
+    Clock(10, 3) - Clock(70) should be(Clock(8, 53))
   }
 
   test("subtract across midnight") {
     pending
-    Clock(0, 3) - Clock(4) should be (Clock(23, 59))
+    Clock(0, 3) - Clock(4) should be(Clock(23, 59))
   }
 
   test("subtract more than two hours") {
     pending
-    Clock(0, 0) - Clock(160) should be (Clock(21, 20))
+    Clock(0, 0) - Clock(160) should be(Clock(21, 20))
   }
 
   test("subtract more than two hours with borrow") {
     pending
-    Clock(6, 15) - Clock(160) should be (Clock(3, 35))
+    Clock(6, 15) - Clock(160) should be(Clock(3, 35))
   }
 
   test("subtract more than one day (1500 min = 25 hrs)") {
     pending
-    Clock(5, 32) - Clock(1500) should be (Clock(4, 32))
+    Clock(5, 32) - Clock(1500) should be(Clock(4, 32))
   }
 
   test("subtract more than two days") {
     pending
-    Clock(2, 20) - Clock(3000) should be (Clock(0, 20))
+    Clock(2, 20) - Clock(3000) should be(Clock(0, 20))
   }
 
   test("clocks with same time") {
     pending
-    Clock(15, 37) == Clock(15, 37) should be (true)
+    Clock(15, 37) == Clock(15, 37) should be(true)
   }
 
   test("clocks a minute apart") {
     pending
-    Clock(15, 36) == Clock(15, 37) should be (false)
+    Clock(15, 36) == Clock(15, 37) should be(false)
   }
 
   test("clocks an hour apart") {
     pending
-    Clock(14, 37) == Clock(15, 37) should be (false)
+    Clock(14, 37) == Clock(15, 37) should be(false)
   }
 
   test("clocks with hour overflow") {
     pending
-    Clock(10, 37) == Clock(34, 37) should be (true)
+    Clock(10, 37) == Clock(34, 37) should be(true)
   }
 
   test("clocks with hour overflow by several days") {
     pending
-    Clock(3, 11) == Clock(99, 11) should be (true)
+    Clock(3, 11) == Clock(99, 11) should be(true)
   }
 
   test("clocks with negative hour") {
     pending
-    Clock(22, 40) == Clock(-2, 40) should be (true)
+    Clock(22, 40) == Clock(-2, 40) should be(true)
   }
 
   test("clocks with negative hour that wraps") {
     pending
-    Clock(17, 3) == Clock(-31, 3) should be (true)
+    Clock(17, 3) == Clock(-31, 3) should be(true)
   }
 
   test("clocks with negative hour that wraps multiple times") {
     pending
-    Clock(13, 49) == Clock(-83, 49) should be (true)
+    Clock(13, 49) == Clock(-83, 49) should be(true)
   }
 
   test("clocks with minute overflow") {
     pending
-    Clock(0, 1) == Clock(0, 1441) should be (true)
+    Clock(0, 1) == Clock(0, 1441) should be(true)
   }
 
   test("clocks with minute overflow by several days") {
     pending
-    Clock(2, 2) == Clock(2, 4322) should be (true)
+    Clock(2, 2) == Clock(2, 4322) should be(true)
   }
 
   test("clocks with negative minute") {
     pending
-    Clock(2, 40) == Clock(3, -20) should be (true)
+    Clock(2, 40) == Clock(3, -20) should be(true)
   }
 
   test("clocks with negative minute that wraps") {
     pending
-    Clock(4, 10) == Clock(5, -1490) should be (true)
+    Clock(4, 10) == Clock(5, -1490) should be(true)
   }
 
   test("clocks with negative minute that wraps multiple times") {
     pending
-    Clock(6, 15) == Clock(6, -4305) should be (true)
+    Clock(6, 15) == Clock(6, -4305) should be(true)
   }
 
   test("clocks with negative hours and minutes") {
     pending
-    Clock(7, 32) == Clock(-12, -268) should be (true)
+    Clock(7, 32) == Clock(-12, -268) should be(true)
   }
 
   test("clocks with negative hours and minutes that wrap") {
     pending
-    Clock(18, 7) == Clock(-54, -11513) should be (true)
+    Clock(18, 7) == Clock(-54, -11513) should be(true)
   }
-}
+}