trackler 2.2.1.51 → 2.2.1.52

data/tracks/fsharp/exercises/kindergarten-garden/Example.fs

@@ -5,16 +5,17 @@ type Plant = Violets | Radishes | Clover | Grass
 let plantsPerChildPerRow = 2
 let rowSeparator = '\n'
 
-let private defaultChildren = ["Alice"; "Bob"; "Charlie"; "David";
-                               "Eve"; "Fred"; "Ginny"; "Harriet";
-                               "Ileana"; "Joseph"; "Kincaid"; "Larry"]
+let private children = 
+    [ "Alice"; "Bob"; "Charlie"; "David";
+      "Eve"; "Fred"; "Ginny"; "Harriet";
+      "Ileana"; "Joseph"; "Kincaid"; "Larry"]
 
 let private plantFromCode code =
     match code with
-    | 'V' -> Plant.Violets
-    | 'R' -> Plant.Radishes
-    | 'C' -> Plant.Clover
-    | 'G' -> Plant.Grass
+    | 'V' -> Violets
+    | 'R' -> Radishes
+    | 'C' -> Clover
+    | 'G' -> Grass
     | x -> failwithf "%c is an invalid plant code" x
 
 let private plantsInRow (row: string) = 
@@ -22,16 +23,14 @@ let private plantsInRow (row: string) =
     |> Seq.chunkBySize plantsPerChildPerRow
     |> Seq.map List.ofArray
 
-let toGarden children (windowSills: string) =     
+let toGarden (windowSills: string) =     
     let rows = windowSills.Split rowSeparator
     let row1 = plantsInRow rows.[0]
     let row2 = plantsInRow rows.[1]
-    Seq.zip3 (children |> List.sort) row1 row2 
+    Seq.zip3 children row1 row2 
     |> Seq.map (fun (child, plants1, plants2) -> (child, plants1 @ plants2))
     |> Map.ofSeq
 
-let plantsForCustomStudents diagram student students = 
-    let garden = toGarden students diagram
-    defaultArg (Map.tryFind student garden) []
-
-let plantsForDefaultStudents diagram student = plantsForCustomStudents diagram student defaultChildren
+let plants diagram student = 
+    let garden = toGarden diagram
+    defaultArg (Map.tryFind student garden) []

data/tracks/fsharp/exercises/kindergarten-garden/KindergartenGarden.fs

@@ -2,6 +2,4 @@
 
 // TODO: define the Plant type
 
-let plantsForDefaultStudents diagram student = failwith "You need to implement this function."
-
-let plantsForCustomStudents diagram student students = failwith "You need to implement this function."
+let plants diagram student = failwith "You need to implement this function."

data/tracks/fsharp/exercises/kindergarten-garden/KindergartenGardenTest.fs

@@ -12,93 +12,61 @@ let ``Partial garden - garden with single student`` () =
     let student = "Alice"
     let diagram = "RC\nGG"
     let expected = [Plant.Radishes; Plant.Clover; Plant.Grass; Plant.Grass]
-    plantsForDefaultStudents diagram student |> should equal expected
+    plants diagram student |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Partial garden - different garden with single student`` () =
     let student = "Alice"
     let diagram = "VC\nRC"
     let expected = [Plant.Violets; Plant.Clover; Plant.Radishes; Plant.Clover]
-    plantsForDefaultStudents diagram student |> should equal expected
+    plants diagram student |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Partial garden - garden with two students`` () =
     let student = "Bob"
     let diagram = "VVCG\nVVRC"
     let expected = [Plant.Clover; Plant.Grass; Plant.Radishes; Plant.Clover]
-    plantsForDefaultStudents diagram student |> should equal expected
+    plants diagram student |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Partial garden - multiple students for the same garden with three students - second student's garden`` () =
     let student = "Bob"
     let diagram = "VVCCGG\nVVCCGG"
     let expected = [Plant.Clover; Plant.Clover; Plant.Clover; Plant.Clover]
-    plantsForDefaultStudents diagram student |> should equal expected
+    plants diagram student |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Partial garden - multiple students for the same garden with three students - third student's garden`` () =
     let student = "Charlie"
     let diagram = "VVCCGG\nVVCCGG"
     let expected = [Plant.Grass; Plant.Grass; Plant.Grass; Plant.Grass]
-    plantsForDefaultStudents diagram student |> should equal expected
+    plants diagram student |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Full garden - first student's garden`` () =
     let student = "Alice"
     let diagram = "VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV"
     let expected = [Plant.Violets; Plant.Radishes; Plant.Violets; Plant.Radishes]
-    plantsForDefaultStudents diagram student |> should equal expected
+    plants diagram student |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Full garden - second student's garden`` () =
     let student = "Bob"
     let diagram = "VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV"
     let expected = [Plant.Clover; Plant.Grass; Plant.Clover; Plant.Clover]
-    plantsForDefaultStudents diagram student |> should equal expected
+    plants diagram student |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Full garden - second to last student's garden`` () =
     let student = "Kincaid"
     let diagram = "VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV"
     let expected = [Plant.Grass; Plant.Clover; Plant.Clover; Plant.Grass]
-    plantsForDefaultStudents diagram student |> should equal expected
+    plants diagram student |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Full garden - last student's garden`` () =
     let student = "Larry"
     let diagram = "VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV"
     let expected = [Plant.Grass; Plant.Violets; Plant.Clover; Plant.Violets]
-    plantsForDefaultStudents diagram student |> should equal expected
-
-[<Fact(Skip = "Remove to run test")>]
-let ``Non-alphabetical student list - first student's garden`` () =
-    let student = "Patricia"
-    let students = ["Samantha"; "Patricia"; "Xander"; "Roger"]
-    let diagram = "VCRRGVRG\nRVGCCGCV"
-    let expected = [Plant.Violets; Plant.Clover; Plant.Radishes; Plant.Violets]
-    plantsForCustomStudents diagram student students |> should equal expected
-
-[<Fact(Skip = "Remove to run test")>]
-let ``Non-alphabetical student list - second student's garden`` () =
-    let student = "Roger"
-    let students = ["Samantha"; "Patricia"; "Xander"; "Roger"]
-    let diagram = "VCRRGVRG\nRVGCCGCV"
-    let expected = [Plant.Radishes; Plant.Radishes; Plant.Grass; Plant.Clover]
-    plantsForCustomStudents diagram student students |> should equal expected
-
-[<Fact(Skip = "Remove to run test")>]
-let ``Non-alphabetical student list - third student's garden`` () =
-    let student = "Samantha"
-    let students = ["Samantha"; "Patricia"; "Xander"; "Roger"]
-    let diagram = "VCRRGVRG\nRVGCCGCV"
-    let expected = [Plant.Grass; Plant.Violets; Plant.Clover; Plant.Grass]
-    plantsForCustomStudents diagram student students |> should equal expected
-
-[<Fact(Skip = "Remove to run test")>]
-let ``Non-alphabetical student list - fourth (last) student's garden`` () =
-    let student = "Xander"
-    let students = ["Samantha"; "Patricia"; "Xander"; "Roger"]
-    let diagram = "VCRRGVRG\nRVGCCGCV"
-    let expected = [Plant.Radishes; Plant.Grass; Plant.Clover; Plant.Violets]
-    plantsForCustomStudents diagram student students |> should equal expected
+    plants diagram student |> should equal expected
 

data/tracks/fsharp/exercises/phone-number/PhoneNumberTest.fs

@@ -9,49 +9,49 @@ open PhoneNumber
 
 [<Fact>]
 let ``Cleans the number`` () =
-    clean "(223) 456-7890" |> should equal <| Some "2234567890"
+    clean "(223) 456-7890" |> should equal (Some "2234567890")
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Cleans numbers with dots`` () =
-    clean "223.456.7890" |> should equal <| Some "2234567890"
+    clean "223.456.7890" |> should equal (Some "2234567890")
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Cleans numbers with multiple spaces`` () =
-    clean "223 456   7890   " |> should equal <| Some "2234567890"
+    clean "223 456   7890   " |> should equal (Some "2234567890")
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Invalid when 9 digits`` () =
-    clean "123456789" |> should equal <| None
+    clean "123456789" |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Invalid when 11 digits does not start with a 1`` () =
-    clean "22234567890" |> should equal <| None
+    clean "22234567890" |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Valid when 11 digits and starting with 1`` () =
-    clean "12234567890" |> should equal <| Some "2234567890"
+    clean "12234567890" |> should equal (Some "2234567890")
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Valid when 11 digits and starting with 1 even with punctuation`` () =
-    clean "+1 (223) 456-7890" |> should equal <| Some "2234567890"
+    clean "+1 (223) 456-7890" |> should equal (Some "2234567890")
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Invalid when more than 11 digits`` () =
-    clean "321234567890" |> should equal <| None
+    clean "321234567890" |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Invalid with letters`` () =
-    clean "123-abc-7890" |> should equal <| None
+    clean "123-abc-7890" |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Invalid with punctuations`` () =
-    clean "123-@:!-7890" |> should equal <| None
+    clean "123-@:!-7890" |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Invalid if area code does not start with 2-9`` () =
-    clean "(123) 456-7890" |> should equal <| None
+    clean "(123) 456-7890" |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Invalid if exchange code does not start with 2-9`` () =
-    clean "(223) 056-7890" |> should equal <| None
+    clean "(223) 056-7890" |> should equal None
 

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

@@ -9,33 +9,33 @@ open RnaTranscription
 
 [<Fact>]
 let ``RNA complement of cytosine is guanine`` () =
-    toRna "C" |> should equal <| Some "G"
+    toRna "C" |> should equal (Some "G")
 
 [<Fact(Skip = "Remove to run test")>]
 let ``RNA complement of guanine is cytosine`` () =
-    toRna "G" |> should equal <| Some "C"
+    toRna "G" |> should equal (Some "C")
 
 [<Fact(Skip = "Remove to run test")>]
 let ``RNA complement of thymine is adenine`` () =
-    toRna "T" |> should equal <| Some "A"
+    toRna "T" |> should equal (Some "A")
 
 [<Fact(Skip = "Remove to run test")>]
 let ``RNA complement of adenine is uracil`` () =
-    toRna "A" |> should equal <| Some "U"
+    toRna "A" |> should equal (Some "U")
 
 [<Fact(Skip = "Remove to run test")>]
 let ``RNA complement`` () =
-    toRna "ACGTGGTCTTAA" |> should equal <| Some "UGCACCAGAAUU"
+    toRna "ACGTGGTCTTAA" |> should equal (Some "UGCACCAGAAUU")
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Correctly handles invalid input (RNA instead of DNA)`` () =
-    toRna "U" |> should equal <| None
+    toRna "U" |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Correctly handles completely invalid DNA input`` () =
-    toRna "XXX" |> should equal <| None
+    toRna "XXX" |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Correctly handles partially invalid DNA input`` () =
-    toRna "ACGTXXXCTTAA" |> should equal <| None
+    toRna "ACGTXXXCTTAA" |> should equal None
 

data/tracks/fsharp/exercises/robot-simulator/RobotSimulator.fs

@@ -1,6 +1,9 @@
 module RobotSimulator
 
 type Bearing = North | East | South | West
+type Coordinate = int * int
+
+type Robot = { bearing: Bearing; coordinate: Coordinate }
 
 let createRobot bearing coordinate = failwith "You need to implement this function."
 

data/tracks/fsharp/exercises/robot-simulator/RobotSimulatorTest.fs

@@ -1,44 +1,147 @@
+// This file was auto-generated based on version 2.0.0 of the canonical data.
+
 module RobotSimulatorTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open RobotSimulator
 
 [<Fact>]
-let ``Turn right edge case`` () =
-    let robot = createRobot Bearing.West (0, 0)
-    let movedRobot = turnRight robot
-    movedRobot |> should equal <| createRobot Bearing.North (0, 0)
+let ``create - Robots are created with a position and direction`` () =
+    let robot = createRobot North (0, 0)
+    let expected = createRobot North (0, 0)
+    robot |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``create - Negative positions are allowed`` () =
+    let robot = createRobot South (-1, -1)
+    let expected = createRobot South (-1, -1)
+    robot |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``turnRight - Does not change the position`` () =
+    let robot = createRobot North (0, 0)
+    let actual = turnRight robot
+    let expected = (0, 0)
+    actual.coordinate |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``turnRight - Changes the direction from north to east`` () =
+    let robot = createRobot North (0, 0)
+    let actual = turnRight robot
+    let expected = East
+    actual.bearing |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``turnRight - Changes the direction from east to south`` () =
+    let robot = createRobot East (0, 0)
+    let actual = turnRight robot
+    let expected = South
+    actual.bearing |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``turnRight - Changes the direction from south to west`` () =
+    let robot = createRobot South (0, 0)
+    let actual = turnRight robot
+    let expected = West
+    actual.bearing |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``turnRight - Changes the direction from west to north`` () =
+    let robot = createRobot West (0, 0)
+    let actual = turnRight robot
+    let expected = North
+    actual.bearing |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Turn left edge case`` () =
-    let robot = createRobot Bearing.North (0, 0)
-    let movedRobot = turnLeft robot
-    movedRobot |> should equal <| createRobot Bearing.West (0, 0)
+let ``turnLeft - Does not change the position`` () =
+    let robot = createRobot North (0, 0)
+    let actual = turnLeft robot
+    let expected = (0, 0)
+    actual.coordinate |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Robbie`` () =
-    let robbie = createRobot Bearing.East (-2, 1)
-    robbie |> should equal <| createRobot Bearing.East (-2, 1)
+let ``turnLeft - Changes the direction from north to west`` () =
+    let robot = createRobot North (0, 0)
+    let actual = turnLeft robot
+    let expected = West
+    actual.bearing |> should equal expected
 
-    let movedRobbie = simulate robbie "RLAALAL"
-    movedRobbie |> should equal <| createRobot Bearing.West (0, 2)
+[<Fact(Skip = "Remove to run test")>]
+let ``turnLeft - Changes the direction from west to south`` () =
+    let robot = createRobot West (0, 0)
+    let actual = turnLeft robot
+    let expected = South
+    actual.bearing |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Clutz`` () =
-    let clutz = createRobot Bearing.North (0, 0)
-    let movedClutz = simulate clutz "LAAARALA"
-    movedClutz |> should equal <| createRobot Bearing.West (-4, 1)
+let ``turnLeft - Changes the direction from south to east`` () =
+    let robot = createRobot South (0, 0)
+    let actual = turnLeft robot
+    let expected = East
+    actual.bearing |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Sphero`` () =
-    let sphero = createRobot Bearing.East (2, -7)
-    let movedSphero = simulate sphero "RRAAAAALA"
-    movedSphero |> should equal <| createRobot Bearing.South (-3, -8)
+let ``turnLeft - Changes the direction from east to north`` () =
+    let robot = createRobot East (0, 0)
+    let actual = turnLeft robot
+    let expected = North
+    actual.bearing |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Roomba`` () =
-    let roomba = createRobot Bearing.South (8, 4)
-    let movedRoomba = simulate roomba "LAAARRRALLLL"
-    movedRoomba |> should equal <| createRobot Bearing.North (11, 5)
+let ``advance - Does not change the direction`` () =
+    let robot = createRobot North (0, 0)
+    let actual = advance robot
+    let expected = North
+    actual.bearing |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``advance - Increases the y coordinate one when facing north`` () =
+    let robot = createRobot North (0, 0)
+    let actual = advance robot
+    let expected = (0, 1)
+    actual.coordinate |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``advance - Decreases the y coordinate by one when facing south`` () =
+    let robot = createRobot South (0, 0)
+    let actual = advance robot
+    let expected = (0, -1)
+    actual.coordinate |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``advance - Increases the x coordinate by one when facing east`` () =
+    let robot = createRobot East (0, 0)
+    let actual = advance robot
+    let expected = (1, 0)
+    actual.coordinate |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``advance - Decreases the x coordinate by one when facing west`` () =
+    let robot = createRobot West (0, 0)
+    let actual = advance robot
+    let expected = (-1, 0)
+    actual.coordinate |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``instructions - Instructions to move west and north`` () =
+    let robot = createRobot North (0, 0)
+    let actual = simulate robot "LAAARALA"
+    let expected = createRobot West (-4, 1)
+    actual |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``instructions - Instructions to move west and south`` () =
+    let robot = createRobot East (2, -7)
+    let actual = simulate robot "RRAAAAALA"
+    let expected = createRobot South (-3, -8)
+    actual |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``instructions - Instructions to move east and north`` () =
+    let robot = createRobot South (8, 4)
+    let actual = simulate robot "LAAARRRALLLL"
+    let expected = createRobot North (11, 5)
+    actual |> should equal expected
+