trackler 2.2.1.52 → 2.2.1.53

data/tracks/fsharp/exercises/clock/Example.fs

@@ -6,15 +6,15 @@ type Clock = { hours: int; minutes: int }
 
 let modulo x y = (int)(((x % y) + y) % y)
 
-let mkClock hours minutes =
+let create hours minutes =
     let totalMinutes = hours * 60 + minutes
     let normalizedHours = modulo ((double)totalMinutes / 60.0) 24.0
     let normalizedMinutes = modulo ((double)minutes) 60.0
 
     { hours = normalizedHours; minutes = normalizedMinutes }
 
-let add minutes clock = mkClock clock.hours (clock.minutes + minutes)
+let add minutes clock = create clock.hours (clock.minutes + minutes)
 
-let subtract minutes clock = mkClock clock.hours (clock.minutes - minutes)
+let subtract minutes clock = create clock.hours (clock.minutes - minutes)
 
 let display clock = sprintf "%02i:%02i" clock.hours clock.minutes

data/tracks/fsharp/exercises/dominoes/DominoesTest.fs

@@ -1,66 +1,69 @@
+// This file was auto-generated based on version 2.0.0 of the canonical data.
+
 module DominoesTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open Dominoes
 
 [<Fact>]
 let ``Empty input = empty output`` () =
-    let actual = []
-    canChain actual |> should equal true
+    let input = []
+    canChain input |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Singleton input = singleton output`` () =
-    let actual = [(1, 1)]
-    canChain actual |> should equal true
+    let input = [(1, 1)]
+    canChain input |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Singleton that can't be chained`` () =
-    let actual = [(1, 2)]
-    canChain actual |> should equal false
+    let input = [(1, 2)]
+    canChain input |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Three elements`` () =
-    let actual = [(1, 2); (3, 1); (2, 3)]
-    canChain actual |> should equal true
+    let input = [(1, 2); (3, 1); (2, 3)]
+    canChain input |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Can reverse dominoes`` () =
-    let actual = [(1, 2); (1, 3); (2, 3)]
-    canChain actual |> should equal true
+    let input = [(1, 2); (1, 3); (2, 3)]
+    canChain input |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Can't be chained`` () =
-    let actual = [(1, 2); (4, 1); (2, 3)]
-    canChain actual |> should equal false
+    let input = [(1, 2); (4, 1); (2, 3)]
+    canChain input |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Disconnected - simple`` () =
-    let actual = [(1, 1); (2, 2)]
-    canChain actual |> should equal false
+    let input = [(1, 1); (2, 2)]
+    canChain input |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Disconnected - double loop`` () =
-    let actual = [(1, 2); (2, 1); (3, 4); (4, 3)]
-    canChain actual |> should equal false
+    let input = [(1, 2); (2, 1); (3, 4); (4, 3)]
+    canChain input |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Disconnected - single isolated`` () =
-    let actual = [(1, 2); (2, 3); (3, 1); (4, 4)]
-    canChain actual |> should equal false
+    let input = [(1, 2); (2, 3); (3, 1); (4, 4)]
+    canChain input |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Need backtrack`` () =
-    let actual = [(1, 2); (2, 3); (3, 1); (2, 4); (2, 4)]
-    canChain actual |> should equal true
+    let input = [(1, 2); (2, 3); (3, 1); (2, 4); (2, 4)]
+    canChain input |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Separate loops`` () =
-    let actual = [(1, 2); (2, 3); (3, 1); (1, 1); (2, 2); (3, 3)]
-    canChain actual |> should equal true
+    let input = [(1, 2); (2, 3); (3, 1); (1, 1); (2, 2); (3, 3)]
+    canChain input |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Ten elements`` () =
-    let actual = [(1, 2); (5, 3); (3, 1); (1, 2); (2, 4); (1, 6); (2, 3); (3, 4); (5, 6)]
-    canChain actual |> should equal true
+let ``Nine elements`` () =
+    let input = [(1, 2); (5, 3); (3, 1); (1, 2); (2, 4); (1, 6); (2, 3); (3, 4); (5, 6)]
+    canChain input |> should equal true
+

data/tracks/fsharp/exercises/largest-series-product/LargestSeriesProductTest.fs

@@ -10,75 +10,90 @@ open LargestSeriesProduct
 [<Fact>]
 let ``Finds the largest product if span equals length`` () =
     let digits = "29"
-    largestProduct digits 2 |> should equal (Some 18)
+    let span = 2
+    largestProduct digits span |> should equal (Some 18)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Can find the largest product of 2 with numbers in order`` () =
     let digits = "0123456789"
-    largestProduct digits 2 |> should equal (Some 72)
+    let span = 2
+    largestProduct digits span |> should equal (Some 72)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Can find the largest product of 2`` () =
     let digits = "576802143"
-    largestProduct digits 2 |> should equal (Some 48)
+    let span = 2
+    largestProduct digits span |> should equal (Some 48)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Can find the largest product of 3 with numbers in order`` () =
     let digits = "0123456789"
-    largestProduct digits 3 |> should equal (Some 504)
+    let span = 3
+    largestProduct digits span |> should equal (Some 504)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Can find the largest product of 3`` () =
     let digits = "1027839564"
-    largestProduct digits 3 |> should equal (Some 270)
+    let span = 3
+    largestProduct digits span |> should equal (Some 270)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Can find the largest product of 5 with numbers in order`` () =
     let digits = "0123456789"
-    largestProduct digits 5 |> should equal (Some 15120)
+    let span = 5
+    largestProduct digits span |> should equal (Some 15120)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Can get the largest product of a big number`` () =
     let digits = "73167176531330624919225119674426574742355349194934"
-    largestProduct digits 6 |> should equal (Some 23520)
+    let span = 6
+    largestProduct digits span |> should equal (Some 23520)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Reports zero if the only digits are zero`` () =
     let digits = "0000"
-    largestProduct digits 2 |> should equal (Some 0)
+    let span = 2
+    largestProduct digits span |> should equal (Some 0)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Reports zero if all spans include zero`` () =
     let digits = "99099"
-    largestProduct digits 3 |> should equal (Some 0)
+    let span = 3
+    largestProduct digits span |> should equal (Some 0)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Rejects span longer than string length`` () =
     let digits = "123"
-    largestProduct digits 4 |> should equal None
+    let span = 4
+    largestProduct digits span |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Reports 1 for empty string and empty product (0 span)`` () =
     let digits = ""
-    largestProduct digits 0 |> should equal (Some 1)
+    let span = 0
+    largestProduct digits span |> should equal (Some 1)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Reports 1 for nonempty string and empty product (0 span)`` () =
     let digits = "123"
-    largestProduct digits 0 |> should equal (Some 1)
+    let span = 0
+    largestProduct digits span |> should equal (Some 1)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Rejects empty string and nonzero span`` () =
     let digits = ""
-    largestProduct digits 1 |> should equal None
+    let span = 1
+    largestProduct digits span |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Rejects invalid character in digits`` () =
     let digits = "1234a5"
-    largestProduct digits 2 |> should equal None
+    let span = 2
+    largestProduct digits span |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Rejects negative span`` () =
     let digits = "12345"
-    largestProduct digits -1 |> should equal None
+    let span = -1
+    largestProduct digits span |> should equal None
 

data/tracks/fsharp/exercises/leap/LeapTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.1.0 of the canonical data.
+// This file was auto-generated based on version 1.2.0 of the canonical data.
 
 module LeapTest
 
@@ -13,7 +13,7 @@ let ``Year not divisible by 4: common year`` () =
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Year divisible by 4, not divisible by 100: leap year`` () =
-    leapYear 2020 |> should equal true
+    leapYear 1996 |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Year divisible by 100, not divisible by 400: common year`` () =

data/tracks/fsharp/exercises/rectangles/Example.fs

@@ -1,4 +1,4 @@
-module Rectangle
+module Rectangles
 
 open System
 

data/tracks/fsharp/exercises/rectangles/Rectangles.fs

@@ -1,3 +1,3 @@
-module Rectangle
+module Rectangles
 
 let rectangles lines = failwith "You need to implement this function."

data/tracks/fsharp/exercises/rectangles/RectanglesTest.fs

@@ -1,11 +1,11 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 module RectanglesTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
-open System
-
-open Rectangle
+open Rectangles
 
 [<Fact>]
 let ``No rows`` () =
@@ -25,70 +25,93 @@ let ``No rectangles`` () =
 [<Fact(Skip = "Remove to run test")>]
 let ``One rectangle`` () =
     let input = 
-        [ "+-+";
-          "| |";
-          "+-+" ]        
+      [ "+-+"; 
+        "| |"; 
+        "+-+" ]
     rectangles input |> should equal 1
 
 [<Fact(Skip = "Remove to run test")>]
-let ``two rectangles without shared parts`` () =
+let ``Two rectangles without shared parts`` () =
     let input = 
-        [ "  +-+";
-          "  | |";
-          "+-+-+";
-          "| |  ";
-          "+-+  " ]        
+      [ "  +-+"; 
+        "  | |"; 
+        "+-+-+"; 
+        "| |  "; 
+        "+-+  " ]
     rectangles input |> should equal 2
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Five rectangles with shared parts`` () =
     let input = 
-        [ "  +-+";
-          "  | |";
-          "+-+-+";
-          "| | |";
-          "+-+-+" ]        
+      [ "  +-+"; 
+        "  | |"; 
+        "+-+-+"; 
+        "| | |"; 
+        "+-+-+" ]
     rectangles input |> should equal 5
 
+[<Fact(Skip = "Remove to run test")>]
+let ``Rectangle of height 1 is counted`` () =
+    let input = 
+      [ "+--+"; 
+        "+--+" ]
+    rectangles input |> should equal 1
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Rectangle of width 1 is counted`` () =
+    let input = 
+      [ "++"; 
+        "||"; 
+        "++" ]
+    rectangles input |> should equal 1
+
+[<Fact(Skip = "Remove to run test")>]
+let ``1x1 square is counted`` () =
+    let input = 
+      [ "++"; 
+        "++" ]
+    rectangles input |> should equal 1
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Only complete rectangles are counted`` () =
     let input = 
-        [ "  +-+";
-          "    |";
-          "+-+-+";
-          "| | -";
-          "+-+-+" ]       
+      [ "  +-+"; 
+        "    |"; 
+        "+-+-+"; 
+        "| | -"; 
+        "+-+-+" ]
     rectangles input |> should equal 1
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Rectangles can be of different sizes`` () =
-    let input =
-         ["+------+----+";
-          "|      |    |";
-          "+---+--+    |";
-          "|   |       |";
-          "+---+-------+" ]       
+    let input = 
+      [ "+------+----+"; 
+        "|      |    |"; 
+        "+---+--+    |"; 
+        "|   |       |"; 
+        "+---+-------+" ]
     rectangles input |> should equal 3
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Corner is required for a rectangle to be complete`` () =
     let input = 
-        [ "+------+----+";
-          "|      |    |";
-          "+------+    |";
-          "|   |       |";
-          "+---+-------+" ]       
+      [ "+------+----+"; 
+        "|      |    |"; 
+        "+------+    |"; 
+        "|   |       |"; 
+        "+---+-------+" ]
     rectangles input |> should equal 2
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Large input with many rectangles`` () =
     let input = 
-        [ "+---+--+----+";
-          "|   +--+----+";
-          "+---+--+    |";
-          "|   +--+----+";
-          "+---+--+--+-+";
-          "+---+--+--+-+";
-          "+------+  | |";
-          "          +-+" ]       
-    rectangles input |> should equal 60
+      [ "+---+--+----+"; 
+        "|   +--+----+"; 
+        "+---+--+    |"; 
+        "|   +--+----+"; 
+        "+---+--+--+-+"; 
+        "+---+--+--+-+"; 
+        "+------+  | |"; 
+        "          +-+" ]
+    rectangles input |> should equal 60
+

data/tracks/fsharp/generators/Generators.fs

@@ -94,12 +94,67 @@ type Change() =
             | _  -> None
         | _ -> None
 
+type Clock() =
+    inherit Exercise()
+
+    let createClock (value:obj) clockId =
+        let clock = value :?> JObject
+        let hour = clock.["hour"].ToObject<string>()
+        let minute = clock.["minute"].ToObject<string>()
+        sprintf "let %s = create %s %s" clockId hour minute
+
+    member private this.renderPropertyValue canonicalDataCase property =
+        this.RenderSutParameter (canonicalDataCase, property, Map.find property canonicalDataCase.Properties)
+
+    override this.PropertiesWithIdentifier canonicalDataCase = ["clock1"; "clock2"]
+
+    override this.RenderValueWithIdentifier (canonicalDataCase, key, value) =
+        match key with
+        | "clock1" | "clock2" -> createClock value key
+        | _ -> base.RenderValueWithIdentifier (canonicalDataCase, key, value)
+    
+    override this.RenderArrange canonicalDataCase =
+        match canonicalDataCase.Property with
+        | "create" | "add" -> 
+            let hour = this.renderPropertyValue canonicalDataCase "hour"
+            let minute = this.renderPropertyValue canonicalDataCase "minute"
+            [sprintf "let clock = create %s %s" hour minute]
+        | _ -> 
+            base.RenderArrange canonicalDataCase
+
+    override this.RenderSut canonicalDataCase =
+        match canonicalDataCase.Property with
+        | "create" -> 
+            sprintf "display clock"
+        | "add" -> 
+            this.renderPropertyValue canonicalDataCase "add"
+            |> sprintf "add %s clock |> display" 
+        | "equal" -> 
+            "clock1 = clock2" 
+        | _ -> 
+            base.RenderSut canonicalDataCase
+
 type CryptoSquare() =
     inherit Exercise()
 
 type DifferenceOfSquares() =
     inherit Exercise()
 
+type Dominoes() =
+    inherit Exercise()
+    
+    let formatAsTuple (value:obj) =
+        let twoElementList = value :?> JArray |> normalizeJArray
+        (twoElementList.Item 0, twoElementList.Item 1) |> string
+
+    override this.RenderInput (canonicalDataCase, key, value) =
+        value :?> JArray
+        |> normalizeJArray
+        |> Seq.map formatAsTuple
+        |> formatList
+
+    override this.PropertiesWithIdentifier canonicalDataCase = this.PropertiesUsedAsSutParameter canonicalDataCase
+
 type Gigasecond() =
     inherit Exercise()
 
@@ -147,7 +202,7 @@ type KindergartenGarden() =
 type LargestSeriesProduct() =
     inherit Exercise()
 
-     override this.PropertiesWithIdentifier canonicalDataCase = ["digits"]
+    override this.PropertiesWithIdentifier canonicalDataCase = this.PropertiesUsedAsSutParameter canonicalDataCase
 
     override this.RenderExpected (canonicalDataCase, key, value) = 
         value 
@@ -267,6 +322,35 @@ type RailFenceCipher() =
 type Raindrops() =
     inherit Exercise()
 
+type Rectangles() = 
+    inherit Exercise()
+
+    member private this.GetPadding n = 
+        String.replicate n " "
+
+    member private this.FormatList (list: List<string>) = 
+        let separator = "; \n" + (this.GetPadding 8)
+        let value = 
+            list 
+            |> String.concat separator
+
+        if list.Length < 2 then 
+            sprintf "[%s]" value
+        else
+            sprintf "\n%s[ %s ]" (this.GetPadding 6) value
+
+    override this.PropertiesWithIdentifier canonicalDataCase = ["input"]
+    override this.RenderSutProperty canonicalDataCase = "rectangles"
+
+    override this.RenderValueWithoutIdentifier (canonicalDataCase, key, value) = 
+        match key with
+        | "input" ->
+            (value :?> JToken).ToObject<List<string>>() 
+            |> List.map formatString 
+            |> this.FormatList
+        | _ -> 
+            base.RenderValueWithoutIdentifier (canonicalDataCase, key, value)
+
 type RobotSimulator() =
     inherit Exercise()