trackler 2.2.1.104 → 2.2.1.105

data/tracks/fsharp/exercises/word-search/WordSearch.fs

@@ -1,3 +1,3 @@
 module WordSearch
 
-let find puzzle word = failwith "You need to implement this function."
+let search grid wordsToSearchFor = failwith "You need to implement this function."

data/tracks/fsharp/exercises/word-search/WordSearchTest.fs

@@ -1,75 +1,330 @@
-// 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 WordSearchTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open WordSearch
 
-let puzzle = 
-    ["jefblpepre";
-     "camdcimgtc";
-     "oivokprjsm";
-     "pbwasqroua";
-     "rixilelhrs";
-     "wolcqlirpc";
-     "screeaumgr";
-     "alxhpburyi";
-     "jalaycalmp";
-     "clojurermt"]
-
 [<Fact>]
-let ``Should find horizontal words written left-to-right`` () =
-    let actual = find puzzle "clojure"
-    actual |> should equal <| Some ((1, 10), (7, 10))
+let ``Should accept an initial game grid and a target search word`` () =
+    let grid = ["jefblpepre"]
+    let wordsToSearchFor = ["clojure"]
+    let expected = [("clojure", Option<((int * int) * (int * int))>.None)] |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Should locate one word written left to right`` () =
+    let grid = ["clojurermt"]
+    let wordsToSearchFor = ["clojure"]
+    let expected = [("clojure", Some (((1, 1), (7, 1))))] |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Should locate the same word written left to right in a different position`` () =
+    let grid = ["mtclojurer"]
+    let wordsToSearchFor = ["clojure"]
+    let expected = [("clojure", Some (((3, 1), (9, 1))))] |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Should locate a different left to right word`` () =
+    let grid = ["coffeelplx"]
+    let wordsToSearchFor = ["coffee"]
+    let expected = [("coffee", Some (((1, 1), (6, 1))))] |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Should locate that different left to right word in a different position`` () =
+    let grid = ["xcoffeezlp"]
+    let wordsToSearchFor = ["coffee"]
+    let expected = [("coffee", Some (((2, 1), (7, 1))))] |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Should locate a left to right word in two line grid`` () =
+    let grid = 
+        [ "jefblpepre";
+          "tclojurerm" ]
+    let wordsToSearchFor = ["clojure"]
+    let expected = [("clojure", Some (((2, 2), (8, 2))))] |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Should locate a left to right word in three line grid`` () =
+    let grid = 
+        [ "camdcimgtc";
+          "jefblpepre";
+          "clojurermt" ]
+    let wordsToSearchFor = ["clojure"]
+    let expected = [("clojure", Some (((1, 3), (7, 3))))] |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Should locate a left to right word in ten line grid`` () =
+    let grid = 
+        [ "jefblpepre";
+          "camdcimgtc";
+          "oivokprjsm";
+          "pbwasqroua";
+          "rixilelhrs";
+          "wolcqlirpc";
+          "screeaumgr";
+          "alxhpburyi";
+          "jalaycalmp";
+          "clojurermt" ]
+    let wordsToSearchFor = ["clojure"]
+    let expected = [("clojure", Some (((1, 10), (7, 10))))] |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Should locate that left to right word in a different position in a ten line grid`` () =
+    let grid = 
+        [ "jefblpepre";
+          "camdcimgtc";
+          "oivokprjsm";
+          "pbwasqroua";
+          "rixilelhrs";
+          "wolcqlirpc";
+          "screeaumgr";
+          "alxhpburyi";
+          "clojurermt";
+          "jalaycalmp" ]
+    let wordsToSearchFor = ["clojure"]
+    let expected = [("clojure", Some (((1, 9), (7, 9))))] |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Should locate a different left to right word in a ten line grid`` () =
+    let grid = 
+        [ "jefblpepre";
+          "camdcimgtc";
+          "oivokprjsm";
+          "pbwasqroua";
+          "rixilelhrs";
+          "wolcqlirpc";
+          "fortranftw";
+          "alxhpburyi";
+          "clojurermt";
+          "jalaycalmp" ]
+    let wordsToSearchFor = ["fortran"]
+    let expected = [("fortran", Some (((1, 7), (7, 7))))] |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Should locate multiple words`` () =
+    let grid = 
+        [ "jefblpepre";
+          "camdcimgtc";
+          "oivokprjsm";
+          "pbwasqroua";
+          "rixilelhrs";
+          "wolcqlirpc";
+          "fortranftw";
+          "alxhpburyi";
+          "jalaycalmp";
+          "clojurermt" ]
+    let wordsToSearchFor = ["fortran"; "clojure"]
+    let expected = 
+        [ ("clojure", Some (((1, 10), (7, 10))));
+          ("fortran", Some (((1, 7), (7, 7)))) ]
+        |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Should find horizontal words written right-to-left`` () =
-    let actual = find puzzle "elixir"
-    actual |> should equal <| Some ((6, 5), (1, 5))
+let ``Should locate a single word written right to left`` () =
+    let grid = ["rixilelhrs"]
+    let wordsToSearchFor = ["elixir"]
+    let expected = [("elixir", Some (((6, 1), (1, 1))))] |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Should find vertical words written top-to-bottom`` () =
-    let actual = find puzzle "ecmascript"
-    actual |> should equal <| Some ((10, 1), (10, 10))
+let ``Should locate multiple words written in different horizontal directions`` () =
+    let grid = 
+        [ "jefblpepre";
+          "camdcimgtc";
+          "oivokprjsm";
+          "pbwasqroua";
+          "rixilelhrs";
+          "wolcqlirpc";
+          "screeaumgr";
+          "alxhpburyi";
+          "jalaycalmp";
+          "clojurermt" ]
+    let wordsToSearchFor = ["elixir"; "clojure"]
+    let expected = 
+        [ ("clojure", Some (((1, 10), (7, 10))));
+          ("elixir", Some (((6, 5), (1, 5)))) ]
+        |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Should find vertical words written bottom-to-top`` () =
-    let actual = find puzzle "rust"
-    actual |> should equal <| Some ((9, 5), (9, 2))
+let ``Should locate words written top to bottom`` () =
+    let grid = 
+        [ "jefblpepre";
+          "camdcimgtc";
+          "oivokprjsm";
+          "pbwasqroua";
+          "rixilelhrs";
+          "wolcqlirpc";
+          "screeaumgr";
+          "alxhpburyi";
+          "jalaycalmp";
+          "clojurermt" ]
+    let wordsToSearchFor = ["clojure"; "elixir"; "ecmascript"]
+    let expected = 
+        [ ("clojure", Some (((1, 10), (7, 10))));
+          ("elixir", Some (((6, 5), (1, 5))));
+          ("ecmascript", Some (((10, 1), (10, 10)))) ]
+        |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Should find diagonal words written top-left-to-bottom-right`` () =
-    let actual = find puzzle "java"
-    actual |> should equal <| Some ((1, 1), (4, 4))
+let ``Should locate words written bottom to top`` () =
+    let grid = 
+        [ "jefblpepre";
+          "camdcimgtc";
+          "oivokprjsm";
+          "pbwasqroua";
+          "rixilelhrs";
+          "wolcqlirpc";
+          "screeaumgr";
+          "alxhpburyi";
+          "jalaycalmp";
+          "clojurermt" ]
+    let wordsToSearchFor = ["clojure"; "elixir"; "ecmascript"; "rust"]
+    let expected = 
+        [ ("clojure", Some (((1, 10), (7, 10))));
+          ("elixir", Some (((6, 5), (1, 5))));
+          ("ecmascript", Some (((10, 1), (10, 10))));
+          ("rust", Some (((9, 5), (9, 2)))) ]
+        |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Should find diagonal upper written bottom-right-to-top-left`` () =
-    let actual = find puzzle "lua"
-    actual |> should equal <| Some ((8, 9), (6, 7))
+let ``Should locate words written top left to bottom right`` () =
+    let grid = 
+        [ "jefblpepre";
+          "camdcimgtc";
+          "oivokprjsm";
+          "pbwasqroua";
+          "rixilelhrs";
+          "wolcqlirpc";
+          "screeaumgr";
+          "alxhpburyi";
+          "jalaycalmp";
+          "clojurermt" ]
+    let wordsToSearchFor = ["clojure"; "elixir"; "ecmascript"; "rust"; "java"]
+    let expected = 
+        [ ("clojure", Some (((1, 10), (7, 10))));
+          ("elixir", Some (((6, 5), (1, 5))));
+          ("ecmascript", Some (((10, 1), (10, 10))));
+          ("rust", Some (((9, 5), (9, 2))));
+          ("java", Some (((1, 1), (4, 4)))) ]
+        |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Should find diagonal upper written bottom-left-to-top-right`` () =
-    let actual = find puzzle "lisp"
-    actual |> should equal <| Some ((3, 6), (6, 3))
+let ``Should locate words written bottom right to top left`` () =
+    let grid = 
+        [ "jefblpepre";
+          "camdcimgtc";
+          "oivokprjsm";
+          "pbwasqroua";
+          "rixilelhrs";
+          "wolcqlirpc";
+          "screeaumgr";
+          "alxhpburyi";
+          "jalaycalmp";
+          "clojurermt" ]
+    let wordsToSearchFor = ["clojure"; "elixir"; "ecmascript"; "rust"; "java"; "lua"]
+    let expected = 
+        [ ("clojure", Some (((1, 10), (7, 10))));
+          ("elixir", Some (((6, 5), (1, 5))));
+          ("ecmascript", Some (((10, 1), (10, 10))));
+          ("rust", Some (((9, 5), (9, 2))));
+          ("java", Some (((1, 1), (4, 4))));
+          ("lua", Some (((8, 9), (6, 7)))) ]
+        |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Should find diagonal upper written top-right-to-bottom-left`` () =
-    let actual = find puzzle "ruby"    
-    actual |> should equal <| Some ((8, 6), (5, 9))
+let ``Should locate words written bottom left to top right`` () =
+    let grid = 
+        [ "jefblpepre";
+          "camdcimgtc";
+          "oivokprjsm";
+          "pbwasqroua";
+          "rixilelhrs";
+          "wolcqlirpc";
+          "screeaumgr";
+          "alxhpburyi";
+          "jalaycalmp";
+          "clojurermt" ]
+    let wordsToSearchFor = ["clojure"; "elixir"; "ecmascript"; "rust"; "java"; "lua"; "lisp"]
+    let expected = 
+        [ ("clojure", Some (((1, 10), (7, 10))));
+          ("elixir", Some (((6, 5), (1, 5))));
+          ("ecmascript", Some (((10, 1), (10, 10))));
+          ("rust", Some (((9, 5), (9, 2))));
+          ("java", Some (((1, 1), (4, 4))));
+          ("lua", Some (((8, 9), (6, 7))));
+          ("lisp", Some (((3, 6), (6, 3)))) ]
+        |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Should not find words that are not in the puzzle`` () =
-    let actual = find puzzle "haskell"
-    actual |> should equal None
+let ``Should locate words written top right to bottom left`` () =
+    let grid = 
+        [ "jefblpepre";
+          "camdcimgtc";
+          "oivokprjsm";
+          "pbwasqroua";
+          "rixilelhrs";
+          "wolcqlirpc";
+          "screeaumgr";
+          "alxhpburyi";
+          "jalaycalmp";
+          "clojurermt" ]
+    let wordsToSearchFor = ["clojure"; "elixir"; "ecmascript"; "rust"; "java"; "lua"; "lisp"; "ruby"]
+    let expected = 
+        [ ("clojure", Some (((1, 10), (7, 10))));
+          ("elixir", Some (((6, 5), (1, 5))));
+          ("ecmascript", Some (((10, 1), (10, 10))));
+          ("rust", Some (((9, 5), (9, 2))));
+          ("java", Some (((1, 1), (4, 4))));
+          ("lua", Some (((8, 9), (6, 7))));
+          ("lisp", Some (((3, 6), (6, 3))));
+          ("ruby", Some (((8, 6), (5, 9)))) ]
+        |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Should be able to search differently-sized puzzles`` () =
-    let differentSizePuzzle =
-        ["qwertyuiopz";
-         "luamsicrexe";
-         "abcdefghijk"]
+let ``Should fail to locate a word that is not in the puzzle`` () =
+    let grid = 
+        [ "jefblpepre";
+          "camdcimgtc";
+          "oivokprjsm";
+          "pbwasqroua";
+          "rixilelhrs";
+          "wolcqlirpc";
+          "screeaumgr";
+          "alxhpburyi";
+          "jalaycalmp";
+          "clojurermt" ]
+    let wordsToSearchFor = ["clojure"; "elixir"; "ecmascript"; "rust"; "java"; "lua"; "lisp"; "ruby";
+ "haskell"]
+    let expected = 
+        [ ("clojure", Some (((1, 10), (7, 10))));
+          ("elixir", Some (((6, 5), (1, 5))));
+          ("ecmascript", Some (((10, 1), (10, 10))));
+          ("rust", Some (((9, 5), (9, 2))));
+          ("java", Some (((1, 1), (4, 4))));
+          ("lua", Some (((8, 9), (6, 7))));
+          ("lisp", Some (((3, 6), (6, 3))));
+          ("ruby", Some (((8, 6), (5, 9))));
+          ("haskell", Option<((int * int) * (int * int))>.None) ]
+        |> Map.ofList
+    search grid wordsToSearchFor |> should equal expected
 
-    let actual = find differentSizePuzzle "exercism"    
-    actual |> should equal <| Some ((11, 2), (4, 2))

data/tracks/fsharp/generators/Formatting.fs

@@ -44,6 +44,8 @@ let formatDateTime (dateTime: DateTime) =
 let formatTimeSpan (timeSpan: TimeSpan) = 
     sprintf "TimeSpan(%d, %d, %d)" timeSpan.Hours timeSpan.Minutes timeSpan.Seconds
 
+let isInt (jToken: JToken) = jToken.Value<int64>() <= int64 Int32.MaxValue
+
 let rec normalizeJArray (jArray: JArray): obj list =
     let toBoxedList seq = 
         seq
@@ -52,8 +54,10 @@ let rec normalizeJArray (jArray: JArray): obj list =
 
     if jArray.Count = 0 then
         []
-    else if jArray.Children() |> Seq.forall (fun x -> x.Type = JTokenType.Integer) then
+    else if jArray.Children() |> Seq.forall (fun x -> x.Type = JTokenType.Integer && isInt x) then
         jArray.Values<int>() |> toBoxedList
+    else if jArray.Children() |> Seq.forall (fun x -> x.Type = JTokenType.Integer) then
+        jArray.Values<int64>() |> toBoxedList
     else if jArray.Children() |> Seq.forall (fun x -> x.Type = JTokenType.Float) then
         jArray.Values<float>() |> toBoxedList
     else if jArray.Children() |> Seq.forall (fun x -> x.Type = JTokenType.Boolean) then
@@ -73,7 +77,8 @@ let rec normalizeJArray (jArray: JArray): obj list =
 
 let formatToken (jToken: JToken) =
     match jToken.Type with
-    | JTokenType.Integer  -> jToken.ToObject<int>()      |> string
+    | JTokenType.Integer when isInt jToken -> jToken.ToObject<int>() |> string
+    | JTokenType.Integer  -> jToken.ToObject<int64>()    |> string
     | JTokenType.Float    -> jToken.ToObject<float>()    |> string
     | JTokenType.Boolean  -> jToken.ToObject<bool>()     |> formatBool
     | JTokenType.String   -> jToken.ToObject<string>()   |> formatString

data/tracks/fsharp/generators/Generators.fs

@@ -292,7 +292,7 @@ type ComplexNumbers() =
         | :? JArray as jArray ->
             let renderAssertion testedFunction expected =
                 { Sut = sprintf "%s sut" testedFunction; Expected = expected }
-                |> renderInlineTemplate "{{ Sut }} |> should (equalWithin 0.000000001) {{ Expected }}"
+                |> renderPartialTemplate "AssertEqualWithin"
 
             [ renderAssertion "real" (renderNumber jArray.[0]) 
               renderAssertion "imaginary" (renderNumber jArray.[1]) |> indent 1 ]
@@ -933,6 +933,19 @@ type RailFenceCipher() =
 type Raindrops() =
     inherit GeneratorExercise()
 
+type RationalNumbers() =
+    inherit GeneratorExercise()
+
+    override __.RenderValue (canonicalDataCase, key, value) =
+        match value with
+        | :? JArray as jArray -> sprintf "(create %d %d)" (jArray.[0].Value<int>()) (jArray.[1].Value<int>())
+        | _ -> base.RenderValue (canonicalDataCase, key, value)
+
+    override __.TestMethodBodyAssertTemplate canonicalDataCase =
+        match canonicalDataCase.Expected with
+        | :? double -> "AssertEqualWithin"
+        | _ -> base.TestMethodBodyAssertTemplate(canonicalDataCase)
+
 type React() = 
     inherit GeneratorExercise()
 
@@ -1248,13 +1261,58 @@ type Triangle() =
         value :?> JArray
         |> normalizeJArray
         |> Seq.map formatFloat
-        |> formatList  
+        |> formatList
+
+type TwoBucket() =
+    inherit GeneratorExercise()
+
+    let renderBucket (value: obj) = 
+        value |> string |> String.upperCaseFirst |> sprintf "Bucket.%s"
+
+    override this.PropertiesWithIdentifier canonicalDataCase = this.Properties canonicalDataCase
+
+    override __.RenderInput (canonicalDataCase, key, value) =
+        match key with
+        | "startBucket" -> renderBucket value
+        | _ -> base.RenderInput (canonicalDataCase, key, value)
+
+    override __.RenderExpected (_, _, value) =
+        let jObject = value :?> JObject
+        let moves       = jObject.Value<int>("moves")
+        let goalBucket  = jObject.Value<string>("goalBucket") |> renderBucket
+        let otherBucket = jObject.Value<int>("otherBucket")
+        sprintf "{ Moves = %d; GoalBucket = %s; OtherBucket = %d }" moves goalBucket otherBucket
 
 type TwoFer() =
     inherit GeneratorExercise()
 
     override __.RenderInput (_, _, value) =
         value |> Option.ofObj |> formatValue |> parenthesizeOption
+
+type VariableLengthQuantity() = 
+    inherit GeneratorExercise()
+
+    let formatUnsignedByteList (value: obj) =
+        value :?> JArray
+        |> Seq.map (fun x -> x.Value<byte>() |> sprintf "0x%xuy")
+        |> formatList
+
+    let formatUnsignedIntList (value: obj) =
+        value :?> JArray
+        |> Seq.map (fun x -> x.Value<uint32>() |> sprintf "0x%xu")
+        |> formatList
+
+    override __.RenderInput (canonicalDataCase, key, value) =
+        match canonicalDataCase.Property with
+        | "encode" -> value |> formatUnsignedIntList
+        | "decode" -> value |> formatUnsignedByteList
+        | _ -> base.RenderInput (canonicalDataCase, key, value)
+
+    override __.RenderExpected (canonicalDataCase, key, value) =
+        match canonicalDataCase.Property with
+        | "encode" -> value |> formatUnsignedByteList
+        | "decode" -> value |> Option.ofObj |> Option.map formatUnsignedIntList |> formatOption |> parenthesizeOption
+        | _ -> base.RenderExpected (canonicalDataCase, key, value)
         
 type WordCount() =
     inherit GeneratorExercise()
@@ -1275,6 +1333,43 @@ type WordCount() =
 
     override __.PropertiesWithIdentifier _ = ["expected"]
 
+type WordSearch() =
+    inherit GeneratorExercise()
+
+    let toCoordinates (value: JToken) = value.Value<int>("column"), value.Value<int>("row")
+
+    let renderExpectedCoordinates (value: JObject) =
+        formatTuple (value.Item("start") |> toCoordinates, value.Item("end") |> toCoordinates)
+
+    let renderExpectedValue (value: JObject) =
+        match isNull value with
+        | true  -> "Option<((int * int) * (int * int))>.None"
+        | false -> sprintf "Some (%s)" (renderExpectedCoordinates value)
+
+    override __.RenderExpected (_, _, value) = 
+        let input = value :?> JObject
+        let formattedList =
+            input.ToObject<Collections.Generic.Dictionary<string, JObject>>()
+            |> Seq.map (fun kv -> sprintf "(%s, %s)" (formatValue kv.Key) (renderExpectedValue kv.Value))
+            |> formatMultiLineList
+
+        if (formattedList.Contains("\n")) then
+            sprintf "%s\n%s" formattedList (indent 2 "|> Map.ofList")
+        else   
+            sprintf "%s |> Map.ofList" formattedList
+
+    override __.RenderInput (canonicalDataCase, key, value) = 
+        match key with
+        | "grid" -> 
+            value :?> JArray
+            |> normalizeJArray
+            |> Seq.map formatValue
+            |> formatMultiLineList
+        | _ -> 
+            base.RenderInput(canonicalDataCase, key, value)
+
+    override this.PropertiesWithIdentifier canonicalDataCase = this.Properties canonicalDataCase
+
 type Wordy() =
     inherit GeneratorExercise()