trackler 2.2.1.100 → 2.2.1.101

data/tracks/delphi/exercises/two-fer/README.md

@@ -34,7 +34,7 @@ For example, if you're submitting `ubob.pas` for the Bob exercise, the submit co
 
 ## Source
 
-This is an exercise to introduce users to basic programming constructs, just after hello World. [https://en.wikipedia.org/wiki/Two-fer](https://en.wikipedia.org/wiki/Two-fer)
+This is an exercise to introduce users to basic programming constructs, just after Hello World. [https://en.wikipedia.org/wiki/Two-fer](https://en.wikipedia.org/wiki/Two-fer)
 
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/elixir/exercises/nth-prime/nth_prime.exs

@@ -6,5 +6,4 @@ defmodule Prime do
   @spec nth(non_neg_integer) :: non_neg_integer
   def nth(count) do
   end
-
 end

data/tracks/fsharp/exercises/pov/PovTest.fs

@@ -1,80 +1,93 @@
-// This file was created manually and its version is 1.0.0.
+// This file was auto-generated based on version 1.1.1 of the canonical data.
 
 module PovTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open Pov
 
-let x = "x"
-let leaf v = mkGraph v []
-
-let singleton = mkGraph x []
-let flat = mkGraph "root" (List.map leaf ["a"; "b"; x; "c"])
-let nested = mkGraph "level-0" [mkGraph "level-1" [mkGraph "level-2" [mkGraph "level-3" [mkGraph x []]]]]
-let kids = mkGraph "root" [mkGraph x [mkGraph "kid-0" []; mkGraph "kid-1" []]]
-let cousins = mkGraph "grandparent" [
-                mkGraph "parent" [
-                    mkGraph x [leaf "kid-a"; leaf "kid-b"]; 
-                    (leaf "sibling-0"); 
-                    (leaf "sibling-1")];
-                    mkGraph "uncle" [
-                        (leaf "cousin-0");
-                        (leaf "cousin-1")]]
-
-let singleton' = singleton
-let flat' = mkGraph x [mkGraph "root" (List.map leaf ["a"; "b"; "c"])]
-let nested' = mkGraph x [mkGraph "level-3" [mkGraph "level-2" [mkGraph "level-1" [mkGraph "level-0" []]]]]
-let kids' = mkGraph x [mkGraph "kid-0" []; mkGraph "kid-1" []; mkGraph "root" []]
-let cousins' = mkGraph x [
-                leaf "kid-a";
-                leaf "kid-b";
-                mkGraph "parent" [
-                    mkGraph "sibling-0" [];
-                    mkGraph "sibling-1" [];
-                    mkGraph "grandparent" [
-                        mkGraph "uncle" [
-                            mkGraph "cousin-0" [];
-                            mkGraph "cousin-1" []]]]]
+let rec graphToList graph = 
+    let right =
+        graph.children
+        |> List.sortBy (fun x -> x.value)
+        |> List.collect graphToList
+    [graph.value] @ right
+let mapToList graph = match graph with | Some x -> graphToList x | None -> []
 
 [<Fact>]
-let ``Reparent singleton`` () =
-    fromPOV x singleton |> should equal <| Some singleton'
+let ``Results in the same tree if the input tree is a singleton`` () =
+    let tree = mkGraph "x" []
+    let expected = mkGraph "x" []
+    fromPOV "x" tree |> mapToList  |> should equal <| graphToList expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Can reroot a tree with a parent and one sibling`` () =
+    let tree = mkGraph "parent" [mkGraph "x" []; mkGraph "sibling" []]
+    let expected = mkGraph "x" [mkGraph "parent" [mkGraph "sibling" []]]
+    fromPOV "x" tree |> mapToList  |> should equal <| graphToList expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Can reroot a tree with a parent and many siblings`` () =
+    let tree = mkGraph "parent" [mkGraph "a" []; mkGraph "x" []; mkGraph "b" []; mkGraph "c" []]
+    let expected = mkGraph "x" [mkGraph "parent" [mkGraph "a" []; mkGraph "b" []; mkGraph "c" []]]
+    fromPOV "x" tree |> mapToList  |> should equal <| graphToList expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Reparent flat`` () =
-    fromPOV x flat |> should equal <| Some flat'
+let ``Can reroot a tree with new root deeply nested in tree`` () =
+    let tree = mkGraph "level-0" [mkGraph "level-1" [mkGraph "level-2" [mkGraph "level-3" [mkGraph "x" []]]]]
+    let expected = mkGraph "x" [mkGraph "level-3" [mkGraph "level-2" [mkGraph "level-1" [mkGraph "level-0" []]]]]
+    fromPOV "x" tree |> mapToList  |> should equal <| graphToList expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Reparent nested`` () =
-    fromPOV x nested |> should equal <| Some nested'
+let ``Moves children of the new root to same level as former parent`` () =
+    let tree = mkGraph "parent" [mkGraph "x" [mkGraph "kid-0" []; mkGraph "kid-1" []]]
+    let expected = mkGraph "x" [mkGraph "kid-0" []; mkGraph "kid-1" []; mkGraph "parent" []]
+    fromPOV "x" tree |> mapToList  |> should equal <| graphToList expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Reparent kids`` () =
-    fromPOV x kids |> should equal <| Some kids'
+let ``Can reroot a complex tree with cousins`` () =
+    let tree = mkGraph "grandparent" [mkGraph "parent" [mkGraph "x" [mkGraph "kid-0" []; mkGraph "kid-1" []]; mkGraph "sibling-0" []; mkGraph "sibling-1" []]; mkGraph "uncle" [mkGraph "cousin-0" []; mkGraph "cousin-1" []]]
+    let expected = mkGraph "x" [mkGraph "kid-1" []; mkGraph "kid-0" []; mkGraph "parent" [mkGraph "sibling-0" []; mkGraph "sibling-1" []; mkGraph "grandparent" [mkGraph "uncle" [mkGraph "cousin-0" []; mkGraph "cousin-1" []]]]]
+    fromPOV "x" tree |> mapToList  |> should equal <| graphToList expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Reparent cousins`` () =
-    fromPOV x cousins |> should equal <| Some cousins'
+let ``Errors if target does not exist in a singleton tree`` () =
+    let tree = mkGraph "x" []
+    fromPOV "nonexistent" tree  |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Reparent from POV of non-existent node`` () =
-    fromPOV x (leaf "foo") |> should equal None
+let ``Errors if target does not exist in a large tree`` () =
+    let tree = mkGraph "parent" [mkGraph "x" [mkGraph "kid-0" []; mkGraph "kid-1" []]; mkGraph "sibling-0" []; mkGraph "sibling-1" []]
+    fromPOV "nonexistent" tree  |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Should not be able to find a missing node`` () =
-    let nodes = [singleton; flat; kids; nested; cousins] |> List.map (fromPOV "NOT THERE")
-    nodes |> List.iter (should equal None)
+let ``Can find path to parent`` () =
+    let tree = mkGraph "parent" [mkGraph "x" []; mkGraph "sibling" []]
+    tracePathBetween "x" "parent" tree |> should equal <| Some ["x"; "parent"]
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Cannot trace between un-connected nodes`` () =
-    tracePathBetween x "NOT THERE" cousins |> should equal None
+let ``Can find path to sibling`` () =
+    let tree = mkGraph "parent" [mkGraph "a" []; mkGraph "x" []; mkGraph "b" []; mkGraph "c" []]
+    tracePathBetween "x" "b" tree |> should equal <| Some ["x"; "parent"; "b"]
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Can trace a path from x to cousin`` () = 
-    tracePathBetween x "cousin-1" cousins |> should equal <| Some ["x"; "parent"; "grandparent"; "uncle"; "cousin-1"]
+let ``Can find path to cousin`` () =
+    let tree = mkGraph "grandparent" [mkGraph "parent" [mkGraph "x" [mkGraph "kid-0" []; mkGraph "kid-1" []]; mkGraph "sibling-0" []; mkGraph "sibling-1" []]; mkGraph "uncle" [mkGraph "cousin-0" []; mkGraph "cousin-1" []]]
+    tracePathBetween "x" "cousin-1" tree |> should equal <| Some ["x"; "parent"; "grandparent"; "uncle"; "cousin-1"]
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Can trace from a leaf to a leaf`` () =
-    tracePathBetween "kid-a" "cousin-0" cousins |> should equal <| Some ["kid-a"; "x"; "parent"; "grandparent"; "uncle"; "cousin-0"]
+let ``Can find path from nodes other than x`` () =
+    let tree = mkGraph "parent" [mkGraph "a" []; mkGraph "x" []; mkGraph "b" []; mkGraph "c" []]
+    tracePathBetween "a" "c" tree |> should equal <| Some ["a"; "parent"; "c"]
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Errors if destination does not exist`` () =
+    let tree = mkGraph "parent" [mkGraph "x" [mkGraph "kid-0" []; mkGraph "kid-1" []]; mkGraph "sibling-0" []; mkGraph "sibling-1" []]
+    tracePathBetween "x" "nonexistent" tree |> should equal None
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Errors if source does not exist`` () =
+    let tree = mkGraph "parent" [mkGraph "x" [mkGraph "kid-0" []; mkGraph "kid-1" []]; mkGraph "sibling-0" []; mkGraph "sibling-1" []]
+    tracePathBetween "nonexistent" "x" tree |> should equal None
+

data/tracks/fsharp/exercises/space-age/Example.fs

@@ -12,20 +12,20 @@ type Planet =
     | Neptune
     | Uranus
 
-let secondsOnEarth = 31557600m    
+let secondsOnEarth = 31557600.0   
 
 let planetPeriods = 
-    [Mercury, 0.2408467m;
-     Venus,   0.61519726m;
-     Earth,   1.0m;
-     Mars,    1.8808158m;
-     Jupiter, 11.862615m;
-     Saturn,  29.447498m;
-     Uranus,  84.016846m;
-     Neptune, 164.79132m] 
+    [Mercury, 0.2408467;
+     Venus,   0.61519726;
+     Earth,   1.0;
+     Mars,    1.8808158;
+     Jupiter, 11.862615;
+     Saturn,  29.447498;
+     Uranus,  84.016846;
+     Neptune, 164.79132] 
     |> Map.ofList
 
-let spaceAge planet (seconds: decimal) = 
-    let yearsUsingPeriod (period:decimal) = Math.Round((seconds / period) / secondsOnEarth, 2)
+let age planet (seconds: int64) = 
+    let yearsUsingPeriod (period: float) = Math.Round((float seconds / period) / secondsOnEarth, 2)
         
     yearsUsingPeriod planetPeriods.[planet]

data/tracks/fsharp/exercises/space-age/SpaceAge.fs

@@ -2,4 +2,4 @@
 
 // TODO: define the Planet type
 
-let spaceAge (planet: Planet) (seconds: decimal): decimal = failwith "You need to implement this function."
+let age (planet: Planet) (seconds: int64): float = failwith "You need to implement this function."

data/tracks/fsharp/exercises/space-age/SpaceAgeTest.fs

@@ -1,54 +1,41 @@
-// 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 SpaceAgeTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
+
 open SpaceAge
-    
+
 [<Fact>]
-let ``Age on earth`` () =
-    let seconds = 1000000000m
-    spaceAge Planet.Earth seconds |> should equal 31.69m
+let ``Age on Earth`` () =
+    age Earth 1000000000L |> should equal 31.69
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Age on mercury`` () =
-    let seconds = 2134835688m
-    spaceAge Planet.Earth seconds |> should equal 67.65m
-    spaceAge Planet.Mercury seconds |> should equal 280.88m
+let ``Age on Mercury`` () =
+    age Mercury 2134835688L |> should equal 280.88
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Age on venus`` () =
-    let seconds = 189839836m
-    spaceAge Planet.Earth seconds |> should equal 6.02m
-    spaceAge Planet.Venus seconds |> should equal 9.78m
+let ``Age on Venus`` () =
+    age Venus 189839836L |> should equal 9.78
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Age on mars`` () =
-    let seconds = 2329871239m
-    spaceAge Planet.Earth seconds |> should equal 73.83m
-    spaceAge Planet.Mars seconds |> should equal 39.25m
+let ``Age on Mars`` () =
+    age Mars 2329871239L |> should equal 39.25
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Age on jupiter`` () =
-    let seconds = 901876382m
-    spaceAge Planet.Earth seconds |> should equal 28.58m
-    spaceAge Planet.Jupiter seconds |> should equal 2.41m
+let ``Age on Jupiter`` () =
+    age Jupiter 901876382L |> should equal 2.41
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Age on saturn`` () =
-    let seconds = 3000000000m
-    spaceAge Planet.Earth seconds |> should equal 95.06m
-    spaceAge Planet.Saturn seconds |> should equal 3.23m
+let ``Age on Saturn`` () =
+    age Saturn 3000000000L |> should equal 3.23
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Age on uranus`` () =
-    let seconds = 3210123456m
-    spaceAge Planet.Earth seconds |> should equal 101.72m
-    spaceAge Planet.Uranus seconds |> should equal 1.21m
+let ``Age on Uranus`` () =
+    age Uranus 3210123456L |> should equal 1.21
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Age on neptune`` () =
-    let seconds = 8210123456m
-    spaceAge Planet.Earth seconds |> should equal 260.16m
-    spaceAge Planet.Neptune seconds |> should equal 1.58m
+let ``Age on Neptune`` () =
+    age Neptune 8210123456L |> should equal 1.58
+

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

@@ -1,22 +1,17 @@
 module Triangle
 
-open System
+let private isValid triangle = 
+    let nonZero = List.sum triangle <> 0.0
+    let equality =
+        let [x; y; z] = triangle
+        x + y >= z && x + z >= y && y + z >= x
+    
+    equality && nonZero
 
-type TriangleKind =
-    | Equilateral
-    | Isosceles
-    | Scalene
+let private distinctSides triangle = triangle |> List.distinct |> List.length
 
-let kind (x: decimal) (y: decimal) (z: decimal) = 
-    let hasZeroSides = x = 0m && y = 0m && z = 0m
-    let hasNegativeSide = x < 0m || y < 0m || z < 0m
-    let violatesTriangleEquality = x + y <= z || x + z <= y || y + z <= x
+let equilateral triangle = isValid triangle && distinctSides triangle = 1
 
-    let isInvalid = hasZeroSides || hasNegativeSide || violatesTriangleEquality
-    let isEquilateral = x = y && y = z
-    let isIsosceles = x = y || y = z || x = z
+let isosceles triangle = isValid triangle && distinctSides triangle <= 2
 
-    if   isInvalid     then invalidOp "Invalid triangle."
-    elif isEquilateral then TriangleKind.Equilateral
-    elif isIsosceles   then TriangleKind.Isosceles
-    else TriangleKind.Scalene
+let scalene triangle = isValid triangle && distinctSides triangle = 3

data/tracks/fsharp/exercises/triangle/Triangle.fs

@@ -1,8 +1,7 @@
 module Triangle
 
-type TriangleKind =
-    | Equilateral
-    | Isosceles
-    | Scalene
+let equilateral triangle = failwith "You need to implement this function."
 
-let kind x y z = failwith "You need to implement this function."
+let isosceles triangle = failwith "You need to implement this function."
+
+let scalene triangle = failwith "You need to implement this function."

data/tracks/fsharp/exercises/triangle/TriangleTest.fs

@@ -1,64 +1,77 @@
-// 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 TriangleTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
+
 open Triangle
-open System
 
 [<Fact>]
-let ``Equilateral triangles have equal sides`` () =
-    kind 2m 2m 2m |> should equal TriangleKind.Equilateral
+let ``Equilateral returns true if all sides are equal`` () =
+    equilateral [2.0; 2.0; 2.0] |> should equal true
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Equilateral returns false if any side is unequal`` () =
+    equilateral [2.0; 3.0; 2.0] |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Larger equilateral triangles also have equal sides`` () =
-    kind 10m 10m 10m |> should equal TriangleKind.Equilateral
+let ``Equilateral returns false if no sides are equal`` () =
+    equilateral [5.0; 4.0; 6.0] |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Isosceles triangles have last two sides equal`` () =
-    kind 3m 4m 4m |> should equal TriangleKind.Isosceles
+let ``All zero sides are illegal, so the triangle is not equilateral`` () =
+    equilateral [0.0; 0.0; 0.0] |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Isosceles triangles have first and last sides equal`` () =
-    kind 4m 3m 4m |> should equal TriangleKind.Isosceles
+let ``Equilateral returns sides may be floats`` () =
+    equilateral [0.5; 0.5; 0.5] |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Isosceles triangles have two first sides equal`` () =
-    kind 4m 4m 3m |> should equal TriangleKind.Isosceles
+let ``Isosceles returns true if last two sides are equal`` () =
+    isosceles [3.0; 4.0; 4.0] |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Isosceles triangles have in fact exactly two sides equal`` () =
-    kind 10m 10m 3m |> should equal TriangleKind.Isosceles
+let ``Isosceles returns true if first two sides are equal`` () =
+    isosceles [4.0; 4.0; 3.0] |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Scalene triangles have no equal sides`` () =
-    kind 3m 4m 5m |> should equal TriangleKind.Scalene
+let ``Isosceles returns true if first and last sides are equal`` () =
+    isosceles [4.0; 3.0; 4.0] |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Scalene triangles have no equal sides at a larger scale too`` () =
-    kind 10m 11m 12m |> should equal TriangleKind.Scalene
+let ``Equilateral triangles are also isosceles`` () =
+    isosceles [4.0; 4.0; 4.0] |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Scalene triangles have no equal sides in descending order either`` () =
-    kind 5m 4m 2m |> should equal TriangleKind.Scalene
+let ``Isosceles returns false if no sides are equal`` () =
+    isosceles [2.0; 3.0; 4.0] |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Very small triangles are legal`` () =
-    kind 0.4m 0.6m 0.3m |> should equal TriangleKind.Scalene
+let ``Sides that violate triangle inequality are not isosceles, even if two are equal`` () =
+    isosceles [1.0; 1.0; 3.0] |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Triangles with no size are illegal`` () =
-    (fun () -> kind 0m 0m 0m |> ignore) |> should throw typeof<InvalidOperationException>
+let ``Isosceles returns sides may be floats`` () =
+    isosceles [0.5; 0.4; 0.5] |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Triangles with negative sides are illegal`` () =
-    (fun () -> kind 3m 4m -5m |> ignore) |> should throw typeof<InvalidOperationException>
+let ``Scalene returns true if no sides are equal`` () =
+    scalene [5.0; 4.0; 6.0] |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Triangles violating triangle inequality are illegal`` () =
-    (fun () -> kind 1m 1m 3m |> ignore) |> should throw typeof<InvalidOperationException>
+let ``Scalene returns false if all sides are equal`` () =
+    scalene [4.0; 4.0; 4.0] |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Triangles violating triangle inequality are illegal 3`` () =
-    (fun () -> kind 7m 3m 2m |> ignore) |> should throw typeof<InvalidOperationException>
+let ``Scalene returns false if two sides are equal`` () =
+    scalene [4.0; 4.0; 3.0] |> should equal false
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Sides that violate triangle inequality are not scalene, even if they are all different`` () =
+    scalene [7.0; 3.0; 2.0] |> should equal false
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Scalene returns sides may be floats`` () =
+    scalene [0.5; 0.4; 0.6] |> should equal true
+

data/tracks/fsharp/generators/Generators.fs

@@ -789,6 +789,92 @@ type Poker() =
 
     override __.PropertiesWithIdentifier _ = ["input"; "expected"]
 
+type Pov() = 
+    inherit GeneratorExercise()
+
+    let isNull x = match x with null -> true | _ -> false
+
+    override __.RenderSetup _ = 
+        ["let rec graphToList graph = "
+         "    let right ="
+         "        graph.children"
+         "        |> List.sortBy (fun x -> x.value)"
+         "        |> List.collect graphToList"
+         "    [graph.value] @ right"
+         "let mapToList graph = match graph with | Some x -> graphToList x | None -> []"
+        ] |> String.concat "\n"
+
+    member this.RenderNode (tree: obj) : string = 
+        match isNull tree with
+        | true -> ""
+        | false ->
+            let node = (tree :?> JObject).ToObject<Collections.Generic.Dictionary<string, JToken>>();
+            let children = 
+                if node.ContainsKey "children" then 
+                    node.["children"]
+                    |> Seq.map this.RenderNode
+                    |> formatList
+                else
+                    "[]"
+            let label =
+                node.["label"]
+                |> formatValue
+            sprintf "mkGraph %s %s" label children
+
+    override this.RenderArrange canonicalDataCase =
+        seq {
+            yield 
+                canonicalDataCase.Properties.["tree"]
+                |> this.RenderNode 
+                |> sprintf "let tree = %s" 
+
+            match canonicalDataCase.Property, isNull canonicalDataCase.Expected with
+            | "fromPov", false ->
+                yield 
+                    canonicalDataCase.Expected
+                    |> this.RenderNode 
+                    |> sprintf "let expected = %s" 
+            | _, _ -> ()
+        }
+        |> Seq.toList
+
+
+    override __.RenderSut canonicalDataCase = 
+        match canonicalDataCase.Property with
+        | "fromPov" -> 
+            let from = 
+                canonicalDataCase.Properties.["from"]
+                |> formatValue
+            match isNull canonicalDataCase.Expected with
+            | false -> sprintf "fromPOV %s tree |> mapToList " from
+            | true -> sprintf "fromPOV %s tree " from
+        | "pathTo" -> 
+            let fromValue = 
+                canonicalDataCase.Properties.["from"] 
+                |> formatValue
+            let toValue = 
+                canonicalDataCase.Properties.["to"] 
+                |> formatValue
+            sprintf "tracePathBetween %s %s tree" fromValue toValue
+        | _ -> ""
+ 
+    override __.RenderExpected (canonicalDataCase, key, value) =
+        match canonicalDataCase.Property with
+        | "fromPov" -> 
+            match isNull value with 
+            | true -> "None"
+            | false -> sprintf "<| graphToList %s" key
+        | "pathTo" -> 
+            match isNull value with
+            | true -> "None" 
+            | false ->
+                printf "%s" canonicalDataCase.Description
+                canonicalDataCase.Expected :?> JArray
+                |> Seq.map formatValue
+                |> formatList
+                |> sprintf "<| Some %s" 
+        | _ -> ""
+
 type PrimeFactors() =
     inherit GeneratorExercise()
     
@@ -1065,6 +1151,15 @@ type Sieve() =
 type SecretHandshake() =
     inherit GeneratorExercise()
 
+type SpaceAge() =
+    inherit GeneratorExercise()
+
+    override __.RenderInput (canonicalDataCase, key, value) =
+        match value with
+        | :? string as s -> s
+        | :? int64 as i -> sprintf "%dL" i
+        | _ -> base.RenderInput (canonicalDataCase, key, value)
+
 type SpiralMatrix() =
     inherit GeneratorExercise()
 
@@ -1088,6 +1183,32 @@ type TwelveDays() =
         |> Seq.map formatValue
         |> formatMultiLineList
 
+type Triangle() =
+    inherit GeneratorExercise()
+
+    let formatFloat (value:obj) = 
+        match value with
+        | :? int64 as i -> sprintf "%.1f" (float i)
+        | :? int32 as i -> sprintf "%.1f" (float i)
+        | :? float as f -> sprintf "%.1f" f
+        | _ -> failwith "Invalid value"
+
+    let hasUniqueTestMethodName canonicalDataCase = 
+        canonicalDataCase.Description.Contains "equilateral" ||
+        canonicalDataCase.Description.Contains "isosceles" ||
+        canonicalDataCase.Description.Contains "scalene"
+
+    override __.RenderTestMethodName canonicalDataCase =
+        match hasUniqueTestMethodName canonicalDataCase with
+        | true  -> base.RenderTestMethodName canonicalDataCase
+        | false -> sprintf "%s returns %s" (String.upperCaseFirst canonicalDataCase.Property) canonicalDataCase.Description
+
+    override __.RenderInput (_, _, value) =
+        value :?> JArray
+        |> normalizeJArray
+        |> Seq.map formatFloat
+        |> formatList  
+
 type TwoFer() =
     inherit GeneratorExercise()