trackler 2.2.1.44 → 2.2.1.45

data/tracks/fsharp/exercises/acronym/AcronymTest.fs

@@ -1,58 +1,33 @@
+// This file was auto-generated based on version 1.1.0 of the canonical data.
+
 module AcronymTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
+
 open Acronym
 
 [<Fact>]
-let ``Empty string abbreviated to empty string`` () =
-    acronym "" |> should be EmptyString
-
-[<Fact(Skip = "Remove to run test")>]
 let ``Basic`` () =
-    let phrase = "Portable Network Graphics"
-    let expected = "PNG"
-    let actual = acronym phrase
-    expected |> should equal actual
+    abbreviate "Portable Network Graphics" |> should equal "PNG"
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Lowercase words`` () =
-    let phrase = "Ruby on Rails"
-    let expected = "ROR"
-    let actual = acronym phrase
-    expected |> should equal actual
-
-[<Fact(Skip = "Remove to run test")>]
-let ``Camel case`` () =
-    let phrase = "HyperText Markup Language"
-    let expected = "HTML"
-    let actual = acronym phrase
-    expected |> should equal actual
+    abbreviate "Ruby on Rails" |> should equal "ROR"
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Punctuation`` () =
-    let phrase = "First In, First Out"
-    let expected = "FIFO"
-    let actual = acronym phrase
-    expected |> should equal actual
+    abbreviate "First In, First Out" |> should equal "FIFO"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``All-Caps words`` () =
-    let phrase = "PHP: Hypertext Preprocessor"
-    let expected = "PHP"
-    let actual = acronym phrase
-    expected |> should equal actual
+let ``All caps words`` () =
+    abbreviate "PHP: Hypertext Preprocessor" |> should equal "PHP"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Non-acronym all-caps word`` () =
-    let phrase = "GNU Image Manipulation Program"
-    let expected = "GIMP"
-    let actual = acronym phrase
-    expected |> should equal actual
+let ``Non-acronym all caps word`` () =
+    abbreviate "GNU Image Manipulation Program" |> should equal "GIMP"
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Hyphenated`` () =
-    let phrase = "Complementary metal-oxide semiconductor"
-    let expected = "CMOS"
-    let actual = acronym phrase
-    expected |> should equal actual
+    abbreviate "Complementary metal-oxide semiconductor" |> should equal "CMOS"
+

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

@@ -3,7 +3,7 @@
 open System
 open System.Text.RegularExpressions
 
-let acronym (phrase:string) =  
+let abbreviate (phrase:string) =  
     let acronymChar = Char.ToUpperInvariant << Seq.head
     let words = Regex.Matches(phrase, "[A-Z]+[a-z]*|[a-z]+")
     let chars = [|for word in words do yield word.Value |> acronymChar|]        

data/tracks/fsharp/exercises/all-your-base/AllYourBase.fsproj

@@ -14,9 +14,10 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
-    <PackageReference Include="xunit" Version="2.3.0-beta5-build3769" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="xunit" Version="2.3.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0" />
     <PackageReference Include="FsUnit.xUnit" Version="3.0.0" />
+    <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.0" />
   </ItemGroup>
 
 </Project>

data/tracks/fsharp/exercises/all-your-base/AllYourBaseTest.fs

@@ -1,174 +1,177 @@
+// This file was auto-generated based on version 1.1.0 of the canonical data.
+
 module AllYourBaseTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open AllYourBase
 
 [<Fact>]
 let ``Single bit one to decimal`` () =
+    let expected = Some [1]
     let inputBase = 2
     let inputDigits = [1]
     let outputBase = 10
-    let outputDigits = Some [1]
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Binary to single decimal`` () =
+    let expected = Some [5]
     let inputBase = 2
     let inputDigits = [1; 0; 1]
     let outputBase = 10
-    let outputDigits = Some [5]
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Single decimal to binary`` () =
+    let expected = Some [1; 0; 1]
     let inputBase = 10
     let inputDigits = [5]
     let outputBase = 2
-    let outputDigits = Some [1; 0; 1]
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Binary to multiple decimal`` () =
+    let expected = Some [4; 2]
     let inputBase = 2
     let inputDigits = [1; 0; 1; 0; 1; 0]
     let outputBase = 10
-    let outputDigits = Some [4; 2]
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Decimal to binary`` () =
+    let expected = Some [1; 0; 1; 0; 1; 0]
     let inputBase = 10
     let inputDigits = [4; 2]
     let outputBase = 2
-    let outputDigits = Some [1; 0; 1; 0; 1; 0]
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Trinary to hexadecimal`` () =
+    let expected = Some [2; 10]
     let inputBase = 3
     let inputDigits = [1; 1; 2; 0]
     let outputBase = 16
-    let outputDigits = Some [2; 10]
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Hexadecimal to trinary`` () =
+    let expected = Some [1; 1; 2; 0]
     let inputBase = 16
     let inputDigits = [2; 10]
     let outputBase = 3
-    let outputDigits = Some [1; 1; 2; 0]
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``15-bit integer`` () =
+    let expected = Some [6; 10; 45]
     let inputBase = 97
     let inputDigits = [3; 46; 60]
     let outputBase = 73
-    let outputDigits = Some [6; 10; 45]
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Empty list`` () =
+    let expected = None
     let inputBase = 2
     let inputDigits = []
     let outputBase = 10
-    let outputDigits = None
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Single zero`` () =
+    let expected = None
     let inputBase = 10
     let inputDigits = [0]
     let outputBase = 2
-    let outputDigits = Some [0]
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Multiple zeros`` () =
+    let expected = None
     let inputBase = 10
     let inputDigits = [0; 0; 0]
     let outputBase = 2
-    let outputDigits = Some [0]
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Leading zeros`` () =
+    let expected = None
     let inputBase = 7
     let inputDigits = [0; 6; 0]
     let outputBase = 10
-    let outputDigits = Some [4; 2]
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``First base is one`` () =
+    let expected = None
+    let inputBase = 1
+    let inputDigits = []
+    let outputBase = 10
+    rebase inputBase inputDigits outputBase |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``First base is zero`` () =
+    let expected = None
+    let inputBase = 0
+    let inputDigits = []
+    let outputBase = 10
+    rebase inputBase inputDigits outputBase |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``First base is negative`` () =
+    let expected = None
+    let inputBase = -2
+    let inputDigits = [1]
+    let outputBase = 10
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Negative digit`` () =
+    let expected = None
     let inputBase = 2
     let inputDigits = [1; -1; 1; 0; 1; 0]
     let outputBase = 10
-    let outputDigits = None
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Invalid positive digit`` () =
+    let expected = None
     let inputBase = 2
     let inputDigits = [1; 2; 1; 0; 1; 0]
     let outputBase = 10
-    let outputDigits = None
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
-
-[<Fact(Skip = "Remove to run test")>]
-let ``First base is one`` () =
-    let inputBase = 1
-    let inputDigits = []
-    let outputBase = 10
-    let outputDigits = None
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second base is one`` () =
+    let expected = None
     let inputBase = 2
     let inputDigits = [1; 0; 1; 0; 1; 0]
     let outputBase = 1
-    let outputDigits = None
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
-
-[<Fact(Skip = "Remove to run test")>]
-let ``First base is zero`` () =
-    let inputBase = 0
-    let inputDigits = []
-    let outputBase = 10
-    let outputDigits = None
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second base is zero`` () =
+    let expected = None
     let inputBase = 10
     let inputDigits = [7]
     let outputBase = 0
-    let outputDigits = None
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
-
-[<Fact(Skip = "Remove to run test")>]
-let ``First base is negative`` () =
-    let inputBase = -2
-    let inputDigits = [1]
-    let outputBase = 10
-    let outputDigits = None
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second base is negative`` () =
+    let expected = None
     let inputBase = 2
     let inputDigits = [1]
     let outputBase = -7
-    let outputDigits = None
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Both bases are negative`` () =
+    let expected = None
     let inputBase = -2
     let inputDigits = [1]
     let outputBase = -7
-    let outputDigits = None
-    rebase inputBase inputDigits outputBase |> should equal outputDigits
+    rebase inputBase inputDigits outputBase |> should equal expected
+

data/tracks/fsharp/exercises/all-your-base/Example.fs

@@ -16,7 +16,10 @@ let fromBase b nums =
         if digit <  0 then None else
         if digit >= b then None else
         loop (acc * b + digit) rest
-    if nums = [] then None else loop 0 nums
+
+    match nums with
+    | [] | 0::_ -> None
+    | _ -> loop 0 nums
 
 let rebase inB inDigits outB =
     if inB < 2 || outB < 2 then None else

data/tracks/fsharp/exercises/allergies/Allergies.fs

@@ -4,6 +4,6 @@ open System
 
 // TODO: define the Allergen type
 
-let allergicTo allergen codedAllergies = failwith "You need to implement this function."
+let allergicTo codedAllergies allergen = failwith "You need to implement this function."
 
-let allergies codedAllergies = failwith "You need to implement this function."
+let list codedAllergies = failwith "You need to implement this function."

data/tracks/fsharp/exercises/allergies/Allergies.fsproj

@@ -14,9 +14,10 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
-    <PackageReference Include="xunit" Version="2.3.0-beta5-build3769" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="xunit" Version="2.3.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0" />
     <PackageReference Include="FsUnit.xUnit" Version="3.0.0" />
+    <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.0" />
   </ItemGroup>
 
 </Project>

data/tracks/fsharp/exercises/allergies/AllergiesTest.fs

@@ -1,70 +1,61 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 module AllergiesTest
 
-open System
-open Xunit
 open FsUnit.Xunit
+open Xunit
+
 open Allergies
 
 [<Fact>]
 let ``No allergies means not allergic`` () =
-    allergicTo Allergen.Peanuts 0 |> should equal false
-    allergicTo Allergen.Cats 0 |> should equal false
-    allergicTo Allergen.Strawberries 0 |> should equal false
+    allergicTo 0 Allergen.Peanuts |> should equal false
+    allergicTo 0 Allergen.Cats |> should equal false
+    allergicTo 0 Allergen.Strawberries |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Allergic to eggs`` () =
-    allergicTo Allergen.Eggs 1 |> should equal true
+let ``Is allergic to eggs`` () =
+    allergicTo 1 Allergen.Eggs |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Allergic to eggs in addition to other stuff`` () =
-    allergicTo Allergen.Eggs 5 |> should equal true
-    allergicTo Allergen.Shellfish 5 |> should equal true
-    allergicTo Allergen.Strawberries 5 |> should equal false
+    allergicTo 5 Allergen.Eggs |> should equal true
+    allergicTo 5 Allergen.Shellfish |> should equal true
+    allergicTo 5 Allergen.Strawberries |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
 let ``No allergies at all`` () =
-    allergies 0 |> should be Empty
+    list 0 |> should be Empty
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Allergic to just eggs`` () =
-    allergies 1 |> should equal [Allergen.Eggs]
+    list 1 |> should equal [Allergen.Eggs]
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Allergic to just peanuts`` () =
-    allergies 2 |> should equal [Allergen.Peanuts]
+    list 2 |> should equal [Allergen.Peanuts]
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Allergic to just strawberries`` () =
+    list 8 |> should equal [Allergen.Strawberries]
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Allergic to eggs and peanuts`` () =
-    allergies 3 |> should equal [Allergen.Eggs; Allergen.Peanuts]
+    list 3 |> should equal [Allergen.Eggs; Allergen.Peanuts]
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Allergic to more than eggs but not peanuts`` () =
+    list 5 |> should equal [Allergen.Eggs; Allergen.Shellfish]
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Allergic to lots of stuff`` () =
-    allergies 248 |> should equal 
-        [ Allergen.Strawberries; 
-          Allergen.Tomatoes;
-          Allergen.Chocolate;
-          Allergen.Pollen;
-          Allergen.Cats ]
+    list 248 |> should equal [Allergen.Strawberries; Allergen.Tomatoes; Allergen.Chocolate; Allergen.Pollen; Allergen.Cats]
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Allergic to everything`` () =
-    allergies 255 |> should equal 
-        [ Allergen.Eggs;
-          Allergen.Peanuts;
-          Allergen.Shellfish;
-          Allergen.Strawberries;
-          Allergen.Tomatoes;
-          Allergen.Chocolate;
-          Allergen.Pollen;
-          Allergen.Cats ]
+    list 255 |> should equal [Allergen.Eggs; Allergen.Peanuts; Allergen.Shellfish; Allergen.Strawberries; Allergen.Tomatoes; Allergen.Chocolate; Allergen.Pollen; Allergen.Cats]
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Ignore non allergen score parts`` () =
-    allergies 509  |> should equal 
-        [ Allergen.Eggs;
-          Allergen.Shellfish;
-          Allergen.Strawberries;
-          Allergen.Tomatoes;
-          Allergen.Chocolate;
-          Allergen.Pollen;
-          Allergen.Cats ]
+    list 509 |> should equal [Allergen.Eggs; Allergen.Shellfish; Allergen.Strawberries; Allergen.Tomatoes; Allergen.Chocolate; Allergen.Pollen; Allergen.Cats]
+

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

@@ -12,10 +12,10 @@ type Allergen =
    | Pollen = 64
    | Cats = 128
 
-let allergicTo (allergen: Allergen) (codedAllergies: int) = codedAllergies &&& int allergen <> 0
+let allergicTo (codedAllergies: int) (allergen: Allergen) = codedAllergies &&& int allergen <> 0
 
-let allergies (codedAllergies: int) = 
+let list (codedAllergies: int) = 
     Enum.GetValues(typeof<Allergen>) 
     |> Seq.cast<Allergen> 
     |> List.ofSeq 
-    |> List.filter (fun allergen -> allergicTo allergen codedAllergies)
+    |> List.filter (allergicTo codedAllergies)

data/tracks/fsharp/exercises/alphametics/Alphametics.fsproj

@@ -14,9 +14,10 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
-    <PackageReference Include="xunit" Version="2.3.0-beta5-build3769" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="xunit" Version="2.3.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0" />
     <PackageReference Include="FsUnit.xUnit" Version="3.0.0" />
+    <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.0" />
   </ItemGroup>
 
 </Project>

data/tracks/fsharp/exercises/anagram/Anagram.fsproj

@@ -14,9 +14,10 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
-    <PackageReference Include="xunit" Version="2.3.0-beta5-build3769" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="xunit" Version="2.3.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0" />
     <PackageReference Include="FsUnit.xUnit" Version="3.0.0" />
+    <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.0" />
   </ItemGroup>
 
 </Project>

data/tracks/fsharp/exercises/atbash-cipher/AtbashCipher.fs

@@ -1,3 +1,5 @@
-module Atbash
+module AtbashCipher
 
-let encode str = failwith "You need to implement this function."
+let encode str = failwith "You need to implement this function."
+
+let decode str = failwith "You need to implement this function."

data/tracks/fsharp/exercises/atbash-cipher/AtbashCipher.fsproj

@@ -14,9 +14,10 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
-    <PackageReference Include="xunit" Version="2.3.0-beta5-build3769" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="xunit" Version="2.3.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0" />
     <PackageReference Include="FsUnit.xUnit" Version="3.0.0" />
+    <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.0" />
   </ItemGroup>
 
 </Project>

data/tracks/fsharp/exercises/atbash-cipher/AtbashCipherTest.fs

@@ -1,61 +1,57 @@
-module AtbashTest
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
+module AtbashCipherTest
 
-open Xunit
 open FsUnit.Xunit
-open Atbash
+open Xunit
+
+open AtbashCipher
 
 [<Fact>]
 let ``Encode yes`` () =
-    let phrase = "yes"
-    let expected = "bvh"
-    let actual = encode phrase
-    actual |> should equal expected
+    encode "yes" |> should equal "bvh"
 
-[<Fact(Skip = "Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode no`` () =
-    let phrase = "no"
-    let expected = "ml"
-    let actual = encode phrase
-    actual |> should equal expected
+    encode "no" |> should equal "ml"
 
-[<Fact(Skip = "Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode OMG`` () =
-    let phrase = "OMG"
-    let expected = "lnt"
-    let actual = encode phrase
-    actual |> should equal expected
+    encode "OMG" |> should equal "lnt"
 
-[<Fact(Skip = "Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode spaces`` () =
-    let phrase = "O M G"
-    let expected = "lnt"
-    let actual = encode phrase
-    actual |> should equal expected
+    encode "O M G" |> should equal "lnt"
 
-[<Fact(Skip = "Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode mindblowingly`` () =
-    let phrase = "mindblowingly"
-    let expected = "nrmwy oldrm tob"
-    let actual = encode phrase
-    actual |> should equal expected
+    encode "mindblowingly" |> should equal "nrmwy oldrm tob"
 
-[<Fact(Skip = "Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode numbers`` () =
-    let phrase = "Testing, 1 2 3, testing."
-    let expected = "gvhgr mt123 gvhgr mt"
-    let actual = encode phrase
-    actual |> should equal expected
+    encode "Testing,1 2 3, testing." |> should equal "gvhgr mt123 gvhgr mt"
 
-[<Fact(Skip = "Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode deep thought`` () =
-    let phrase = "Truth is fiction."
-    let expected = "gifgs rhurx grlm"
-    let actual = encode phrase
-    actual |> should equal expected
+    encode "Truth is fiction." |> should equal "gifgs rhurx grlm"
 
-[<Fact(Skip = "Remove to run test")>]     
+[<Fact(Skip = "Remove to run test")>]
 let ``Encode all the letters`` () =
-    let phrase = "The quick brown fox jumps over the lazy dog."
-    let expected = "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
-    let actual = encode phrase
-    actual |> should equal expected
+    encode "The quick brown fox jumps over the lazy dog." |> should equal "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Decode exercism`` () =
+    decode "vcvix rhn" |> should equal "exercism"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Decode a sentence`` () =
+    decode "zmlyh gzxov rhlug vmzhg vkkrm thglm v" |> should equal "anobstacleisoftenasteppingstone"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Decode numbers`` () =
+    decode "gvhgr mt123 gvhgr mt" |> should equal "testing123testing"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Decode all the letters`` () =
+    decode "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt" |> should equal "thequickbrownfoxjumpsoverthelazydog"
+

data/tracks/fsharp/exercises/atbash-cipher/Example.fs

@@ -1,4 +1,4 @@
-module Atbash
+module AtbashCipher
 
 open System
 
@@ -10,7 +10,7 @@ let rec mapMaybe f list =
         | Some(a) -> a :: mapMaybe f xs
         | None -> mapMaybe f xs
 
-let stringFromChars (chars:char seq) = new String(chars |> Array.ofSeq)
+let stringFromChars (chars:char seq) = String(Array.ofSeq chars)
 let chunksOfSize n xs = 
     xs 
     |> Seq.mapi(fun i x -> i / n, x)
@@ -24,4 +24,6 @@ let encodeLetter letter = Map.tryFind (Char.ToLower letter) lettersMap
 let encodeInChunks = String.concat " " << Seq.map stringFromChars << chunksOfSize 5
 let encodeStr = encodeInChunks << mapMaybe encodeLetter
     
-let encode (str:string) = str |> List.ofSeq |> encodeStr
+let encode (str:string) = str |> List.ofSeq |> encodeStr
+
+let decode (str:string) = (encode str).Replace(" ", "")