trackler 2.2.1.138 → 2.2.1.139

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 904ea15d99f928d3a60c4a94f9f6f487b5c56bb4
-  data.tar.gz: 5e14581709b274c20adacd33233c8e268534c83e
+  metadata.gz: b48b5f9ad4c3dda8082d4ec68ca569b6f58bcd9e
+  data.tar.gz: 906a0b93107cfb896d1683e08fd1de2bfb139d4a
 SHA512:
-  metadata.gz: e02921838fab6c43ad19a3eabbf7d832e1e6f6568065420af7fa31484393f601d6e990af8eacf8093e5e3caf7885c07aa2436d2eb417977bcebc68f7cac0f2de
-  data.tar.gz: cb188e5c1cea7a4e79f2e8bc6af2561c7b4113cbeef75feab4921d475cb5d3315a20929ade4f705a9c6a51bb1974ec6959a365065e1f7aefd6ae780c4a9f4533
+  metadata.gz: 061ee013f6f779604520690a10c22a0b1009322a215cef3f0143753bfe18820fa0f4023c608835db4c587ea4839a2836eb314cf6ca04be928587861e3af1b1e4
+  data.tar.gz: b35bb468ad872a13417de79eed391fde0a004607157780ba079e510abad4a85305377c229f897108e80053594a1964435e33ceb8adf371954205d5894b256b1c

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.138"
+  VERSION = "2.2.1.139"
 end

data/problem-specifications/exercises/crypto-square/description.md

@@ -10,11 +10,15 @@ regarded as forming a rectangle when printed with intervening newlines.
 
 For example, the sentence
 
-> If man was meant to stay on the ground, god would have given us roots.
+```text
+"If man was meant to stay on the ground, god would have given us roots."
+```
 
 is normalized to:
 
-> ifmanwasmeanttostayonthegroundgodwouldhavegivenusroots
+```text
+"ifmanwasmeanttostayonthegroundgodwouldhavegivenusroots"
+```
 
 The plaintext should be organized in to a rectangle.  The size of the
 rectangle (`r x c`) should be decided by the length of the message,
@@ -25,13 +29,13 @@ Our normalized text is 54 characters long, dictating a rectangle with
 `c = 8` and `r = 7`:
 
 ```text
-ifmanwas
-meanttos
-tayonthe
-groundgo
-dwouldha
-vegivenu
-sroots
+"ifmanwas"
+"meanttos"
+"tayonthe"
+"groundgo"
+"dwouldha"
+"vegivenu"
+"sroots  "
 ```
 
 The coded message is obtained by reading down the columns going left to
@@ -40,7 +44,7 @@ right.
 The message above is coded as:
 
 ```text
-imtgdvsfearwermayoogoanouuiontnnlvtwttddesaohghnsseoau
+"imtgdvsfearwermayoogoanouuiontnnlvtwttddesaohghnsseoau"
 ```
 
 Output the encoded text in chunks that fill perfect rectangles `(r X c)`,
@@ -49,19 +53,19 @@ with `c` chunks of `r` length, separated by spaces. For phrases that are
 chunks with a single trailing space.
 
 ```text
-imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau 
+"imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau "
 ```
 
 Notice that were we to stack these, we could visually decode the
 cyphertext back in to the original message:
 
 ```text
-imtgdvs
-fearwer
-mayoogo
-anouuio
-ntnnlvt
-wttddes
-aohghn
-sseoau
+"imtgdvs"
+"fearwer"
+"mayoogo"
+"anouuio"
+"ntnnlvt"
+"wttddes"
+"aohghn "
+"sseoau "
 ```

data/problem-specifications/exercises/yacht/canonical-data.json

@@ -1,6 +1,6 @@
 {
     "exercise":"yacht",
-    "version":"1.0.0",
+    "version":"1.1.0",
     "comments":[
         "The dice are represented always as a list of exactly five integers",
         "with values between 1 and 6 inclusive. The category is an string.",
@@ -130,6 +130,15 @@
             },
             "expected":0
         },
+        {
+            "description":"Four of a kind is not a full house",
+            "property":"score",
+            "input":{
+                "dice":[1, 4, 4, 4, 4],
+                "category":"full house"
+            },
+            "expected":0
+        },
         {
             "description":"Yacht is not a full house",
             "property":"score",

data/tracks/clojure/exercises/gigasecond/src/gigasecond.clj

@@ -0,0 +1,5 @@
+(ns gigasecond)
+
+(defn from []  ;; <- arglist goes here
+    ;; your code goes here
+)

data/tracks/clojure/exercises/grade-school/src/grade_school.clj

@@ -0,0 +1,13 @@
+(ns grade-school)
+
+(defn grade []  ;; <- arglist goes here
+    ;; your code goes here
+)
+
+(defn add []  ;; <- arglist goes here
+    ;; your code goes here
+)
+
+(defn sorted []  ;; <- arglist goes here
+    ;; your code goes here
+)

data/tracks/clojure/exercises/grains/src/grains.clj

@@ -0,0 +1,9 @@
+(ns grains)
+
+(defn square [] ;; <- arglist goes here
+    ;; your code goes here
+)
+
+(defn total []  ;; <- arglist goes here
+    ;; your code goes here
+)

data/tracks/clojure/exercises/minesweeper/src/minesweeper.clj

@@ -0,0 +1,5 @@
+(ns minesweeper)
+
+(defn draw [] ;; <- arglist goes here
+  ;; your code goes here
+  )

data/tracks/fsharp/docs/GENERATORS.md

@@ -43,10 +43,9 @@ Render the input of a test method.
 The `Gigasecond` generator renders the input value as a (parenthesized) `DateTime` value:
 
 ```fsharp
-override __.RenderInput (canonicalDataCase, key, value) =
+override __.RenderInput (_, _, value) =
     DateTime.Parse(string value, CultureInfo.InvariantCulture)
-    |> formatDateTime
-    |> parenthesize
+    |> DateTime.renderParenthesized
 ```
 
 Note that you could use the `key` field to only customize the output for specific input fields. The `Yacht` generator does this:
@@ -54,7 +53,7 @@ Note that you could use the `key` field to only customize the output for specifi
 ```fsharp
 override __.RenderInput (canonicalDataCase, key, value) =
     match key with
-    | "category" -> sprintf "Category.%s" (string value |> String.dehumanize)
+    | "category" -> Obj.renderEnum "Category" value
     | _ -> base.RenderInput (canonicalDataCase, key, value)
 ```
 
@@ -136,11 +135,10 @@ Render a single value (which is used to render input parameters, the expected va
 The `ComplexNumbers` generator renders different values based on the value's type:
 
 ```fsharp
-override __.RenderValue (canonicalDataCase, key, value) =
-    match value with
-    | :? JArray as jArray -> renderComplexNumber jArray
-    | :? int64 as i -> sprintf "%d.0" i
-    | _ -> base.RenderValue (canonicalDataCase, key, value)
+override __.PropertiesWithIdentifier canonicalDataCase =
+    match canonicalDataCase.Expected.Type with
+    | JTokenType.Array -> ["sut"]
+    | _ -> base.PropertiesWithIdentifier canonicalDataCase
 ```
 
 ### Method: MapCanonicalDataCase
@@ -196,8 +194,8 @@ In some cases, you want an identifier to have an explicit type. A common use cas
 The `Minesweeper` generator adds a `string list` type annotation for empty values:
 
 ```fsharp
-override __.IdentifierTypeAnnotation (_, _, value) = 
-    match value :?> JArray |> Seq.isEmpty with 
+override __.IdentifierTypeAnnotation (_, _, value) =
+    match Seq.isEmpty value with
     | true  -> Some "string list"
     | false -> None
 ```
@@ -224,9 +222,9 @@ The `RationalNumbers` generator uses the `"AssertEqualWithin"` template to allow
 
 ```fsharp
 override __.AssertTemplate canonicalDataCase =
-    match canonicalDataCase.Expected with
-    | :? double -> "AssertEqualWithin"
-    | _ -> base.TestMethodBodyAssertTemplate(canonicalDataCase)
+    match canonicalDataCase.Expected.Type with
+    | JTokenType.Float -> "AssertEqualWithin"
+    | _ -> base.AssertTemplate(canonicalDataCase)
 ```
 
 ### Method: TestFileFormat

data/tracks/fsharp/exercises/bowling/BowlingTest.fs

@@ -13,85 +13,85 @@ let rollMany rolls game = List.fold (fun game pins -> roll pins game) game rolls
 let ``Should be able to score a game with all zeros`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
     let game = rollMany rolls (newGame())
-    score game |> should equal <| Some 0
+    score game |> should equal (Some 0)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Should be able to score a game with no strikes or spares`` () =
     let rolls = [3; 6; 3; 6; 3; 6; 3; 6; 3; 6; 3; 6; 3; 6; 3; 6; 3; 6; 3; 6]
     let game = rollMany rolls (newGame())
-    score game |> should equal <| Some 90
+    score game |> should equal (Some 90)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``A spare followed by zeros is worth ten points`` () =
     let rolls = [6; 4; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
     let game = rollMany rolls (newGame())
-    score game |> should equal <| Some 10
+    score game |> should equal (Some 10)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Points scored in the roll after a spare are counted twice`` () =
     let rolls = [6; 4; 3; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
     let game = rollMany rolls (newGame())
-    score game |> should equal <| Some 16
+    score game |> should equal (Some 16)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Consecutive spares each get a one roll bonus`` () =
     let rolls = [5; 5; 3; 7; 4; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
     let game = rollMany rolls (newGame())
-    score game |> should equal <| Some 31
+    score game |> should equal (Some 31)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``A spare in the last frame gets a one roll bonus that is counted once`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 7; 3; 7]
     let game = rollMany rolls (newGame())
-    score game |> should equal <| Some 17
+    score game |> should equal (Some 17)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``A strike earns ten points in a frame with a single roll`` () =
     let rolls = [10; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
     let game = rollMany rolls (newGame())
-    score game |> should equal <| Some 10
+    score game |> should equal (Some 10)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Points scored in the two rolls after a strike are counted twice as a bonus`` () =
     let rolls = [10; 5; 3; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
     let game = rollMany rolls (newGame())
-    score game |> should equal <| Some 26
+    score game |> should equal (Some 26)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Consecutive strikes each get the two roll bonus`` () =
     let rolls = [10; 10; 10; 5; 3; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
     let game = rollMany rolls (newGame())
-    score game |> should equal <| Some 81
+    score game |> should equal (Some 81)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``A strike in the last frame gets a two roll bonus that is counted once`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 10; 7; 1]
     let game = rollMany rolls (newGame())
-    score game |> should equal <| Some 18
+    score game |> should equal (Some 18)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Rolling a spare with the two roll bonus does not get a bonus roll`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 10; 7; 3]
     let game = rollMany rolls (newGame())
-    score game |> should equal <| Some 20
+    score game |> should equal (Some 20)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Strikes with the two roll bonus do not get bonus rolls`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 10; 10; 10]
     let game = rollMany rolls (newGame())
-    score game |> should equal <| Some 30
+    score game |> should equal (Some 30)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``A strike with the one roll bonus after a spare in the last frame does not get a bonus`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 7; 3; 10]
     let game = rollMany rolls (newGame())
-    score game |> should equal <| Some 20
+    score game |> should equal (Some 20)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``All strikes is a perfect game`` () =
     let rolls = [10; 10; 10; 10; 10; 10; 10; 10; 10; 10; 10; 10]
     let game = rollMany rolls (newGame())
-    score game |> should equal <| Some 300
+    score game |> should equal (Some 300)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Rolls cannot score negative points`` () =
@@ -132,7 +132,7 @@ let ``Two bonus rolls after a strike in the last frame cannot score more than 10
 let ``Two bonus rolls after a strike in the last frame can score more than 10 points if one is a strike`` () =
     let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 10; 10; 6]
     let game = rollMany rolls (newGame())
-    score game |> should equal <| Some 26
+    score game |> should equal (Some 26)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``The second bonus rolls after a strike in the last frame cannot be a strike if the first one is not a strike`` () =

data/tracks/fsharp/exercises/perfect-numbers/PerfectNumbersTest.fs

@@ -9,47 +9,47 @@ open PerfectNumbers
 
 [<Fact>]
 let ``Smallest perfect number is classified correctly`` () =
-    classify 6 |> should equal (Some Perfect)
+    classify 6 |> should equal (Some Classification.Perfect)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Medium perfect number is classified correctly`` () =
-    classify 28 |> should equal (Some Perfect)
+    classify 28 |> should equal (Some Classification.Perfect)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Large perfect number is classified correctly`` () =
-    classify 33550336 |> should equal (Some Perfect)
+    classify 33550336 |> should equal (Some Classification.Perfect)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Smallest abundant number is classified correctly`` () =
-    classify 12 |> should equal (Some Abundant)
+    classify 12 |> should equal (Some Classification.Abundant)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Medium abundant number is classified correctly`` () =
-    classify 30 |> should equal (Some Abundant)
+    classify 30 |> should equal (Some Classification.Abundant)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Large abundant number is classified correctly`` () =
-    classify 33550335 |> should equal (Some Abundant)
+    classify 33550335 |> should equal (Some Classification.Abundant)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Smallest prime deficient number is classified correctly`` () =
-    classify 2 |> should equal (Some Deficient)
+    classify 2 |> should equal (Some Classification.Deficient)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Smallest non-prime deficient number is classified correctly`` () =
-    classify 4 |> should equal (Some Deficient)
+    classify 4 |> should equal (Some Classification.Deficient)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Medium deficient number is classified correctly`` () =
-    classify 32 |> should equal (Some Deficient)
+    classify 32 |> should equal (Some Classification.Deficient)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Large deficient number is classified correctly`` () =
-    classify 33550337 |> should equal (Some Deficient)
+    classify 33550337 |> should equal (Some Classification.Deficient)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Edge case (no factors other than itself) is classified correctly`` () =
-    classify 1 |> should equal (Some Deficient)
+    classify 1 |> should equal (Some Classification.Deficient)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Zero is rejected (not a natural number)`` () =

data/tracks/fsharp/exercises/rna-transcription/Example.fs

@@ -1,19 +1,11 @@
 module RnaTranscription
 
-open System.Text.RegularExpressions
-
-let dnaToRna = 
+let private dnaToRna = 
     function
-    | 'G' -> Some 'C'
-    | 'C' -> Some 'G'
-    | 'T' -> Some 'A'
-    | 'A' -> Some 'U'
-    | _   -> None
-
-let toRna dna = 
-    let helper rna nucleotide = 
-        match rna, dnaToRna nucleotide with
-        | Some x, Some y -> Some (x + string y)
-        | _ -> None
+    | 'G' -> 'C'
+    | 'C' -> 'G'
+    | 'T' -> 'A'
+    | 'A' -> 'U'
+    | _   -> failwith "Unknown nucleotide"
 
-    Seq.fold helper (Some "") dna 
+let toRna dna = String.map dnaToRna dna

data/tracks/fsharp/exercises/rna-transcription/RnaTranscription.fs

@@ -1,3 +1,3 @@
 module RnaTranscription
 
-let toRna (dna: string): string option = failwith "You need to implement this function."
+let toRna (dna: string): string = failwith "You need to implement this function."

data/tracks/fsharp/exercises/rna-transcription/RnaTranscriptionTest.fs

@@ -9,21 +9,21 @@ open RnaTranscription
 
 [<Fact>]
 let ``RNA complement of cytosine is guanine`` () =
-    toRna "C" |> should equal (Some "G")
+    toRna "C" |> should equal "G"
 
 [<Fact(Skip = "Remove to run test")>]
 let ``RNA complement of guanine is cytosine`` () =
-    toRna "G" |> should equal (Some "C")
+    toRna "G" |> should equal "C"
 
 [<Fact(Skip = "Remove to run test")>]
 let ``RNA complement of thymine is adenine`` () =
-    toRna "T" |> should equal (Some "A")
+    toRna "T" |> should equal "A"
 
 [<Fact(Skip = "Remove to run test")>]
 let ``RNA complement of adenine is uracil`` () =
-    toRna "A" |> should equal (Some "U")
+    toRna "A" |> should equal "U"
 
 [<Fact(Skip = "Remove to run test")>]
 let ``RNA complement`` () =
-    toRna "ACGTGGTCTTAA" |> should equal (Some "UGCACCAGAAUU")
+    toRna "ACGTGGTCTTAA" |> should equal "UGCACCAGAAUU"