trackler 2.2.1.99 → 2.2.1.100

data/tracks/fsharp/exercises/wordy/Wordy.fs

@@ -1,3 +1,3 @@
 module Wordy
 
-let solve question = failwith "You need to implement this function."
+let answer question = failwith "You need to implement this function."

data/tracks/fsharp/exercises/wordy/WordyTest.fs

@@ -1,71 +1,73 @@
-// This file was created manually and its version is 1.0.0.
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
 module WordyTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
+
 open Wordy
 
 [<Fact>]
-let ``Can parse and solve addition problems`` () =
-    solve "What is 1 plus 1?" |> should equal <| Some 2
-    
+let ``Addition`` () =
+    answer "What is 1 plus 1?" |> should equal (Some 2)
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Can add double digit numbers`` () =
-    solve "What is 53 plus 2?" |> should equal <| Some 55
-    
+let ``More addition`` () =
+    answer "What is 53 plus 2?" |> should equal (Some 55)
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Can add negative numbers`` () =
-    solve "What is -1 plus -10?" |> should equal <| Some -11
-    
+let ``Addition with negative numbers`` () =
+    answer "What is -1 plus -10?" |> should equal (Some -11)
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Can add large numbers`` () =
-    solve "What is 123 plus 45678?" |> should equal <| Some 45801
-    
+let ``Large addition`` () =
+    answer "What is 123 plus 45678?" |> should equal (Some 45801)
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Can parse and solve subtraction problems`` () =
-    solve "What is 4 minus -12?" |> should equal <| Some 16
-    
+let ``Subtraction`` () =
+    answer "What is 4 minus -12?" |> should equal (Some 16)
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Can parse and solve multiplication problems`` () =
-    solve "What is -3 multiplied by 25?" |> should equal <| Some -75
-    
+let ``Multiplication`` () =
+    answer "What is -3 multiplied by 25?" |> should equal (Some -75)
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Can parse and solve division problems`` () =
-    solve "What is 33 divided by -3?" |> should equal <| Some -11
-    
+let ``Division`` () =
+    answer "What is 33 divided by -3?" |> should equal (Some -11)
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Can add twice`` () =
-    solve "What is 1 plus 1 plus 1?" |> should equal <| Some 3
-    
+let ``Multiple additions`` () =
+    answer "What is 1 plus 1 plus 1?" |> should equal (Some 3)
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Can add then subtract`` () =
-    solve "What is 1 plus 5 minus -2?" |> should equal <| Some 8
-    
+let ``Addition and subtraction`` () =
+    answer "What is 1 plus 5 minus -2?" |> should equal (Some 8)
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Can subtract twice`` () =
-    solve "What is 20 minus 4 minus 13?" |> should equal <| Some 3
-    
+let ``Multiple subtraction`` () =
+    answer "What is 20 minus 4 minus 13?" |> should equal (Some 3)
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Can subtract then add`` () =
-    solve "What is 17 minus 6 plus 3?" |> should equal <| Some 14
-    
+let ``Subtraction then addition`` () =
+    answer "What is 17 minus 6 plus 3?" |> should equal (Some 14)
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Can multiply twice`` () =
-    solve "What is 2 multiplied by -2 multiplied by 3?" |> should equal <| Some -12
-    
+let ``Multiple multiplication`` () =
+    answer "What is 2 multiplied by -2 multiplied by 3?" |> should equal (Some -12)
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Can add then multiply`` () =
-    solve "What is -3 plus 7 multiplied by -2?" |> should equal <| Some -8
-    
+let ``Addition and multiplication`` () =
+    answer "What is -3 plus 7 multiplied by -2?" |> should equal (Some -8)
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Can divide twice`` () =
-    solve "What is -12 divided by 2 divided by -3?" |> should equal <| Some 2
-    
+let ``Multiple division`` () =
+    answer "What is -12 divided by 2 divided by -3?" |> should equal (Some 2)
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Cubed is too advanced`` () =
-    solve "What is 53 cubed?" |> should equal None
-    
+let ``Unknown operation`` () =
+    answer "What is 52 cubed?" |> should equal None
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Irrelevant problems are not valid`` () =
-    solve "Who is the president of the United States?" |> should equal None
+let ``Non math question`` () =
+    answer "Who is the President of the United States?" |> should equal None
+

data/tracks/fsharp/exercises/zebra-puzzle/Example.fs

@@ -14,7 +14,7 @@ let rec insertions x = function
 
 let rec permutations = function
     | []      -> seq [ [] ]
-    | x :: xs -> Seq.concat (Seq.map (insertions x) (permutations xs))
+    | x :: xs -> Seq.collect (insertions x) (permutations xs)
 
 let index value = List.findIndex ((=) value)
 
@@ -74,7 +74,7 @@ let solutions = seq {
             yield { colors = validColors; nationalities = validNationalities; pets = validPets; drinks = validDrinks; smokes = validSmokes }
     }
 
-let solve() = Seq.head solutions
+let solution = Seq.head solutions
 
-let whoDrinksWater solution = List.item (index Water solution.drinks) solution.nationalities
-let whoOwnsZebra solution = List.item (index Zebra solution.pets) solution.nationalities
+let drinksWater = List.item (index Water solution.drinks) solution.nationalities
+let ownsZebra = List.item (index Zebra solution.pets) solution.nationalities

data/tracks/fsharp/exercises/zebra-puzzle/ZebraPuzzleTest.fs

@@ -1,18 +1,17 @@
-// This file was created manually and its version is 1.0.0.
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
 module ZebraPuzzleTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open ZebraPuzzle
 
 [<Fact>]
-let ``Who drinks water?`` () =
-    let solution = solve()
-    whoDrinksWater solution |> should equal Norwegian
+let ``Resident who drinks water`` () =
+    drinksWater |> should equal Norwegian
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Who owns the zebra?`` () =
-    let solution = solve()
-    whoOwnsZebra solution |> should equal Japanese
+let ``Resident who owns zebra`` () =
+    ownsZebra |> should equal Japanese
+

data/tracks/fsharp/generators/Common.fs

@@ -43,7 +43,7 @@ let isInt64 (value: obj) =
     | _ -> false
 
 module Option =
-    let ofNonNegativeInt (value: obj) =
+    let ofPositiveInt (value: obj) =
         match value with
         | :? int64 as i -> if i < 0L then None else Some value
         | :? int32 as i -> if i < 0  then None else Some value
@@ -89,6 +89,8 @@ module String =
     let replace (oldValue: string) (newValue: string) (str: string) =
         str.Replace(oldValue, newValue)    
 
+    let toLower (str: string) = str.ToLowerInvariant()
+
 module Json =
     let rec parentsAndSelf (currentToken: JToken) =
         let rec helper acc (token: JToken) =

data/tracks/fsharp/generators/Exercise.fs

@@ -10,6 +10,7 @@ open Serilog
 open Formatting
 open Rendering
 open CanonicalData
+open Track
 
 let private exerciseNameFromType (exerciseType: Type) = exerciseType.Name.Kebaberize()
 
@@ -295,12 +296,15 @@ type CustomExercise() =
 type MissingDataExercise = { Name: string }
 
 type UnimplementedExercise = { Name: string }
+
+type DeprecatedExercise = { Name: string }
     
 type Exercise =
     | Generator of GeneratorExercise
     | Custom of CustomExercise
     | MissingData of MissingDataExercise
     | Unimplemented of UnimplementedExercise
+    | Deprecated of DeprecatedExercise
     
 let exerciseName exercise =
     match exercise with
@@ -308,6 +312,7 @@ let exerciseName exercise =
     | Custom custom -> custom.Name
     | Unimplemented unimplemented -> unimplemented.Name
     | MissingData missingData -> missingData.Name    
+    | Deprecated deprecated -> deprecated.Name    
 
 type ConfigExercise = { Slug: string }
 
@@ -356,13 +361,19 @@ let private tryFindCustomExercise exerciseName =
     |> Map.tryFind exerciseName 
     |> Option.map Custom
     
+let private tryFindDeprecatedExercise exerciseName =
+    match isDeprecated exerciseName with
+    | true  -> Deprecated { Name = exerciseName } |> Some 
+    | false -> None
+    
 let private tryFindUnimplementedExercise options exerciseName =
     match hasCanonicalData options exerciseName with
     | true  -> Unimplemented { Name = exerciseName } |> Some 
     | false -> None
 
 let private createExercise options exerciseName =
-    tryFindGeneratorExercise exerciseName
+    tryFindDeprecatedExercise exerciseName
+    |> Option.orElse (tryFindGeneratorExercise exerciseName)
     |> Option.orElse (tryFindCustomExercise exerciseName)
     |> Option.orElse (tryFindUnimplementedExercise options exerciseName)
     |> Option.orElse (MissingData { Name = exerciseName } |> Some)

data/tracks/fsharp/generators/Generators.fs

@@ -98,8 +98,7 @@ type BeerSong() =
     override __.PropertiesWithIdentifier _ = ["expected"]
 
     override __.RenderExpected (_, _, value) =
-        (value :?> JArray)
-        |> normalizeJArray
+        value :?> JArray
         |> Seq.map formatValue
         |> formatMultiLineList
 
@@ -125,7 +124,7 @@ type Bob() =
 type BookStore() =
     inherit GeneratorExercise()
 
-    let formatFloat (value:obj) = value :?> float |> sprintf "%.2f"
+    let formatFloat (value:obj) = value :?> int64 |> (fun x -> float x / 100.0) |> sprintf "%.2f"
 
     override __.RenderExpected (_, _, value) = formatFloat value
 
@@ -163,7 +162,7 @@ type Change() =
     inherit GeneratorExercise()
 
     override __.RenderExpected (_, _, value) =
-        let convertToOption = if value :? JArray then Option.ofObj else Option.ofNonNegativeInt
+        let convertToOption = if value :? JArray then Option.ofObj else Option.ofPositiveInt
         value |> convertToOption |> formatValue
 
     override this.PropertiesWithIdentifier canonicalDataCase = this.Properties canonicalDataCase
@@ -343,11 +342,10 @@ type CustomSet() =
 
     override __.TestMethodBodyAssertTemplate _ = "AssertEqual"
 
-    member __.RenderSet canonicalDataCase key =
-        let value = 
-            (canonicalDataCase.Properties.[key] :?> JToken).ToObject<seq<string>>()
-            |> formatList
-        sprintf "CustomSet.fromList %s" value
+    member __.RenderSet (jToken: obj) =
+        (jToken :?> JToken).ToObject<seq<string>>()
+        |> formatList
+        |> sprintf "CustomSet.fromList %s"
 
     override this.RenderSut canonicalDataCase =
         match canonicalDataCase.Property with
@@ -365,15 +363,15 @@ type CustomSet() =
         let arrangeLines =
             match canonicalDataCase.Property with
             | "empty" ->
-                let setValue = this.RenderSet canonicalDataCase "set"
+                let setValue = this.RenderSet canonicalDataCase.Input.["set"]
                 [ sprintf "let %s = CustomSet.isEmpty (%s)" this.SutName setValue ]
             | "add" | "contains" ->
                 let methodName = 
                     match canonicalDataCase.Property with
                     | "add" -> "insert"
                     | s -> s
-                let setVar = sprintf "let setValue = %s" (this.RenderSet canonicalDataCase "set")
-                let valueVar = sprintf "let element = %s" (formatValue canonicalDataCase.Properties.["element"])
+                let setVar = sprintf "let setValue = %s" (this.RenderSet canonicalDataCase.Input.["set"])
+                let valueVar = sprintf "let element = %s" (formatValue canonicalDataCase.Input.["element"])
                 let resultVar = sprintf "let %s = CustomSet.%s element setValue" this.SutName methodName 
                 [ setVar; valueVar; resultVar ]
             | "intersection" | "difference" | "union" | "disjoint" | "subset" | "equal" ->
@@ -383,8 +381,8 @@ type CustomSet() =
                     | "subset" -> "isSubsetOf"
                     | "equal" -> "isEqualTo"
                     | s -> s
-                let firstSetVar = sprintf "let set1 = %s" (this.RenderSet canonicalDataCase "set1")
-                let secondSetVar = sprintf "let set2 = %s" (this.RenderSet canonicalDataCase "set2")
+                let firstSetVar = sprintf "let set1 = %s" (this.RenderSet canonicalDataCase.Input.["set1"])
+                let secondSetVar = sprintf "let set2 = %s" (this.RenderSet canonicalDataCase.Input.["set2"])
                 let resultVar = sprintf "let %s = CustomSet.%s set1 set2" this.SutName methodName
                 [ firstSetVar; secondSetVar; resultVar ]
             | _ -> 
@@ -392,7 +390,7 @@ type CustomSet() =
 
         match canonicalDataCase.Property with
         | "add" | "intersection" | "difference" | "union" -> 
-            let expectedSetVar = sprintf "let expectedSet = %s" (this.RenderSet canonicalDataCase "expected")
+            let expectedSetVar = sprintf "let expectedSet = %s" (this.RenderSet canonicalDataCase.Expected)
             let actualBoolVar = sprintf "let %sBool = CustomSet.isEqualTo %s expectedSet" this.SutName this.SutName
             arrangeLines @ [ expectedSetVar; actualBoolVar ]
         | _ -> arrangeLines
@@ -407,8 +405,8 @@ type Dominoes() =
     inherit GeneratorExercise()
     
     let formatAsTuple (value:obj) =
-        let twoElementList = value :?> JArray |> normalizeJArray
-        (twoElementList.Item 0, twoElementList.Item 1) |> string
+        let items = value :?> obj list
+        formatTuple (List.item 0 items, List.item 1 items)
 
     override __.RenderInput (_, _, value) =
         value :?> JArray
@@ -451,8 +449,7 @@ type FoodChain() =
     override __.PropertiesWithIdentifier _ = ["expected"]
 
     override __.RenderExpected (_, _, value) =
-        (value :?> JArray)
-        |> normalizeJArray
+        value :?> JArray
         |> Seq.map formatValue
         |> formatMultiLineList
 
@@ -478,10 +475,8 @@ type Gigasecond() =
 
     override __.RenderExpected (_, _, value) = value :?> DateTime |> formatDateTime |> parenthesize
  
-    override __.RenderInput (canonicalDataCase, key, value) =
-        match key with
-        | "input" -> DateTime.Parse(string value, CultureInfo.InvariantCulture) |> formatDateTime |> parenthesize
-        | _ -> base.RenderInput (canonicalDataCase, key, value)
+    override __.RenderInput (_, _, value) =
+         DateTime.Parse(string value, CultureInfo.InvariantCulture) |> formatDateTime |> parenthesize
 
     override __.AdditionalNamespaces = [typeof<DateTime>.Namespace]
 
@@ -503,8 +498,7 @@ type Grep() =
     override this.PropertiesWithIdentifier canonicalDataCase = this.Properties canonicalDataCase
 
     override __.RenderExpected (_, _, value) =
-        (value :?> JArray)
-        |> normalizeJArray
+        value :?> JArray
         |> Seq.map formatValue
         |> formatMultiLineListWithIndentation 3
 
@@ -546,8 +540,7 @@ type House() =
     override __.PropertiesWithIdentifier _ = ["expected"]
 
     override __.RenderExpected (_, _, value) =
-        (value :?> JArray)
-        |> normalizeJArray
+        value :?> JArray
         |> Seq.map formatValue
         |> formatMultiLineList
 
@@ -578,7 +571,7 @@ type LargestSeriesProduct() =
 
     override __.RenderExpected (_, _, value) = 
         value 
-        |> Option.ofNonNegativeInt 
+        |> Option.ofPositiveInt 
         |> formatValue 
         |> parenthesizeOption
 
@@ -643,7 +636,6 @@ type Minesweeper() =
 
     let renderValue (value: obj) = 
         value :?> JArray
-        |> normalizeJArray
         |> Seq.map formatValue
         |> formatMultiLineList
 
@@ -698,7 +690,7 @@ type OcrNumbers() =
 
     override __.RenderExpected (_, _, value) = 
         value 
-        |> Option.ofNonNegativeInt 
+        |> Option.ofPositiveInt 
         |> formatValue 
         |> parenthesizeOption
 
@@ -715,8 +707,8 @@ type PalindromeProducts() =
     inherit GeneratorExercise()
 
     let toFactors (value: obj) = 
-        let jArray = value :?> JArray
-        let factors = jArray.ToObject<int list>()
+        let jArray = value :?> obj list
+        let factors = jArray |> List.map (string >> int)
         sprintf "(%A, %A)" factors.[0] factors.[1]
 
     let toPalindromeProducts (value: obj) =
@@ -749,9 +741,8 @@ type PascalsTriangle() =
         | :? JArray  ->
             let formattedList = 
                 value :?> JArray
-                |> normalizeJArray
                 |> Seq.map formatValue
-                |> formatMultiLineList
+                |> formatMultiLineList            
 
             if (formattedList.Contains("\n")) then
                 sprintf "%s\n%s" formattedList (indent 2 "|> Some")
@@ -804,14 +795,16 @@ type PrimeFactors() =
     override __.RenderInput (canonicalDataCase, key, value) =
         base.RenderInput (canonicalDataCase, key, value) |> sprintf "%sL"
 
+type ProteinTranslation() =
+    inherit GeneratorExercise()
+
 type Proverb() =
     inherit GeneratorExercise()
 
     override __.PropertiesWithIdentifier _ = ["input"; "expected"]
 
     override __.RenderExpected (_, _, value) =
-        (value :?> JArray)
-        |> normalizeJArray
+        value :?> JArray
         |> Seq.map formatValue
         |> formatMultiLineList
     
@@ -857,7 +850,7 @@ type React() =
     member private __.RenderCells canonicalDataCase = 
         let reactorVar = sprintf "let %s = new %s()" "reactor" "Reactor"
         let cellVars = 
-            canonicalDataCase.Properties.["cells"] :?> JArray
+            canonicalDataCase.Input.["cells"] :?> JArray
             |> Seq.map (fun (cellValue: JToken) -> 
                 let cell = cellValue :?> JObject
                 let cellName = cell.["name"].ToObject<string>()
@@ -878,7 +871,7 @@ type React() =
         [ reactorVar ] @ cellVars
      
     member private __.RenderOperations canonicalDataCase = 
-        canonicalDataCase.Properties.["operations"] :?> JArray
+        canonicalDataCase.Input.["operations"] :?> JArray
         // we can generate more than 1 line per operation
         // so we need to flatten results here
         // collect does it automatically for us 
@@ -1046,18 +1039,43 @@ type RunLengthEncoding() =
 type RomanNumerals() =
     inherit GeneratorExercise()
 
+type Say() =
+    inherit GeneratorExercise()
+
+    override __.RenderExpected (_, _, value) =
+        value 
+        |> Option.ofPositiveInt
+        |> formatValue
+        |> parenthesizeOption
+
+    override __.RenderInput (_, _, value) = sprintf "%sL" (string value)
+
 type ScrabbleScore() =
     inherit GeneratorExercise()
 
-type SpiralMatrix() =
+type Sieve() =
     inherit GeneratorExercise()
 
     override __.RenderExpected (_, _, value) =
         (value :?> JArray)
         |> normalizeJArray
         |> Seq.map formatValue
+        |> formatList
+
+type SecretHandshake() =
+    inherit GeneratorExercise()
+
+type SpiralMatrix() =
+    inherit GeneratorExercise()
+
+    override __.RenderExpected (_, _, value) =
+        value :?> JArray
+        |> Seq.map formatValue
         |> formatMultiLineList
 
+type SumOfMultiples() =
+    inherit GeneratorExercise()
+
 type TwelveDays() =
     inherit GeneratorExercise()
 
@@ -1066,8 +1084,7 @@ type TwelveDays() =
     override __.PropertiesWithIdentifier _ = ["expected"]
 
     override __.RenderExpected (_, _, value) =
-        (value :?> JArray)
-        |> normalizeJArray
+        value :?> JArray
         |> Seq.map formatValue
         |> formatMultiLineList
 
@@ -1075,4 +1092,34 @@ type TwoFer() =
     inherit GeneratorExercise()
 
     override __.RenderInput (_, _, value) =
-        value |> Option.ofObj |> formatValue |> parenthesizeOption
+        value |> Option.ofObj |> formatValue |> parenthesizeOption
+        
+type WordCount() =
+    inherit GeneratorExercise()
+    member __.FormatMap<'TKey, 'TValue> (value: obj) =
+        let input = value :?> JObject
+        let dict = input.ToObject<Collections.Generic.Dictionary<'TKey, 'TValue>>();
+        let formattedList =
+            dict
+            |> Seq.map (fun kv -> formatTuple (kv.Key, kv.Value))
+            |> formatMultiLineList
+
+        if (formattedList.Contains("\n")) then
+            sprintf "%s\n%s" formattedList (indent 2 "|> Map.ofList")
+        else   
+            sprintf "%s |> Map.ofList" formattedList
+
+    override this.RenderExpected (_, _, value) = this.FormatMap<string, int> value
+
+    override __.PropertiesWithIdentifier _ = ["expected"]
+
+type Wordy() =
+    inherit GeneratorExercise()
+
+    override __.RenderExpected (_, _, value) =
+        value |> Option.ofNonFalse |> formatValue |> parenthesizeOption
+
+type ZebraPuzzle() =
+    inherit GeneratorExercise()
+
+    override __.RenderExpected (_, _, value) = string value