trackler 2.2.1.22 → 2.2.1.23

data/tracks/fsharp/exercises/ocr-numbers/OcrNumbersTest.fs

@@ -1,136 +1,123 @@
-module OcrNumbersTest
+module OcrNumbersTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open OcrNumbers
 
-[<Test>]
+[<Fact>]
 let ``Recognizes zero`` () = 
     let converted = convert (" _ " + "\n" +
                               "| |" + "\n" +
                               "|_|" + "\n" +
                               "   ")
-    Assert.That(converted, Is.EqualTo("0"))
+    converted |> should equal "0"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Recognizes one`` () = 
     let converted = convert ("   " + "\n" +
                              "  |" + "\n" +
                              "  |" + "\n" +
                              "   ")
-    Assert.That(converted, Is.EqualTo("1"))
+    converted |> should equal "1"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Recognizes two`` () = 
     let converted = convert (" _ " + "\n" +
                              " _|" + "\n" +
                              "|_ " + "\n" +
                              "   ")
-    Assert.That(converted, Is.EqualTo("2"))
+    converted |> should equal "2"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Recognizes three`` () = 
     let converted = convert (" _ " + "\n" +
                              " _|" + "\n" +
                              " _|" + "\n" +
                              "   ")
-    Assert.That(converted, Is.EqualTo("3"))
+    converted |> should equal "3"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Recognizes four`` () = 
     let converted = convert ("   " + "\n" +
                              "|_|" + "\n" +
                              "  |" + "\n" +
                              "   ")
-    Assert.That(converted, Is.EqualTo("4"))
+    converted |> should equal "4"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Recognizes five`` () = 
     let converted = convert (" _ " + "\n" +
                              "|_ " + "\n" +
                              " _|" + "\n" +
                              "   ")
-    Assert.That(converted, Is.EqualTo("5"))
+    converted |> should equal "5"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Recognizes six`` () = 
     let converted = convert (" _ " + "\n" +
                              "|_ " + "\n" +
                              "|_|" + "\n" +
                              "   ")
-    Assert.That(converted, Is.EqualTo("6"))
+    converted |> should equal "6"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Recognizes seven`` () = 
     let converted = convert (" _ " + "\n" +
                              "  |" + "\n" +
                              "  |" + "\n" +
                              "   ")
-    Assert.That(converted, Is.EqualTo("7"))
+    converted |> should equal "7"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Recognizes eight`` () = 
     let converted = convert (" _ " + "\n" +
                              "|_|" + "\n" +
                              "|_|" + "\n" +
                              "   ")
-    Assert.That(converted, Is.EqualTo("8"))
+    converted |> should equal "8"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Recognizes nine`` () = 
     let converted = convert (" _ " + "\n" +
                              "|_|" + "\n" +
                              " _|" + "\n" +
                              "   ")
-    Assert.That(converted, Is.EqualTo("9"))
+    converted |> should equal "9"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Recognizes garble`` () = 
     let converted = convert ("   " + "\n" +
                              "| |" + "\n" +
                              "| |" + "\n" +
                              "   ")
-    Assert.That(converted, Is.EqualTo("?"))
+    converted |> should equal "?"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Recognizes ten`` () = 
     let converted = convert ("    _ " + "\n" +
                              "  || |" + "\n" +
                              "  ||_|" + "\n" +
                              "       ")
-    Assert.That(converted, Is.EqualTo("10"))
+    converted |> should equal "10"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Recognizes 110101100`` () = 
     let converted = convert ("       _     _        _  _ " + "\n" +
                              "  |  || |  || |  |  || || |" + "\n" +
                              "  |  ||_|  ||_|  |  ||_||_|" + "\n" +
                              "                            ")
-    Assert.That(converted, Is.EqualTo("110101100"))
+    converted |> should equal "110101100"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Recognizes numbers and garble`` () = 
     let converted = convert ("       _     _           _ " + "\n" +
                              "  |  || |  || |     || || |" + "\n" +
                              "  |  | _|  ||_|  |  ||_||_|" + "\n" +
                              "                            ")
-    Assert.That(converted, Is.EqualTo("11?10?1?0"))
+    converted |> should equal "11?10?1?0"
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Recognizes multiple rows`` () = 
     let converted = convert ("    _  _ " + "\n" +
                              "  | _| _|" + "\n" +
@@ -144,4 +131,4 @@ let ``Recognizes multiple rows`` () =
                              "  ||_||_|" + "\n" +
                              "  ||_| _|" + "\n" +
                              "          ")
-    Assert.That(converted, Is.EqualTo("123,456,789"))
+    converted |> should equal "123,456,789"

data/tracks/fsharp/exercises/ocr-numbers/Program.fs

@@ -0,0 +1 @@
+module Program = let [<EntryPoint>] main _ = 0

data/tracks/fsharp/exercises/palindrome-products/PalindromeProducts.fs

@@ -0,0 +1,5 @@
+module Palindrome
+
+let largestPalindrome minFactor maxFactor = failwith "You need to implement this function."
+
+let smallestPalindrome minFactor maxFactor = failwith "You need to implement this function."

data/tracks/fsharp/exercises/palindrome-products/PalindromeProducts.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="PalindromeProducts.fs" />
+    <Compile Include="PalindromeProductsTest.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <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="FsUnit.xUnit" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

data/tracks/fsharp/exercises/palindrome-products/PalindromeProductsTest.fs

@@ -0,0 +1,54 @@
+module PalindromeTest
+
+open Xunit
+open FsUnit.Xunit
+
+open Palindrome
+
+[<Fact>]
+let ``Largest palindrome from single digit factors`` () =
+    let (largest, factors) = largestPalindrome 1 9
+    largest |> should equal 9
+    factors |> should equal [(1, 9); (3, 3)]
+    
+[<Fact(Skip = "Remove to run test")>]
+let ``Smallest palindrome from single digit factors`` () =
+    let (smallest, factors) = smallestPalindrome 1 9
+    smallest |> should equal 1
+    factors |> should equal [(1, 1)]
+    
+[<Fact(Skip = "Remove to run test")>]
+let ``Largest palindrome from double digit actors`` () =
+    let (largest, factors) = largestPalindrome 10 99
+    largest |> should equal 9009
+    factors |> should equal [(91, 99)]
+    
+[<Fact(Skip = "Remove to run test")>]
+let ``Smallest palindrome from double digit factors`` () =
+    let (smallest, factors) = smallestPalindrome 10 99
+    smallest |> should equal 121
+    factors |> should equal [(11, 11)]
+    
+[<Fact(Skip = "Remove to run test")>]
+let ``Largest palindrome from triple digit factors`` () =
+    let (largest, factors) = largestPalindrome 100 999
+    largest |> should equal 906609
+    factors |> should equal [(913, 993)]
+    
+[<Fact(Skip = "Remove to run test")>]
+let ``Smallest palindrome from triple digit factors`` () =
+    let (smallest, factors) = smallestPalindrome 100 999
+    smallest |> should equal 10201
+    factors |> should equal [(101, 101)]
+    
+[<Fact(Skip = "Remove to run test")>]
+let ``Largest palindrome from four digit factors`` () =
+    let (largest, factors) = largestPalindrome 1000 9999
+    largest |> should equal 99000099
+    factors |> should equal [(9901, 9999)]
+    
+[<Fact(Skip = "Remove to run test")>]
+let ``Smallest palindrome from four digit factors`` () =
+    let (smallest, factors) = smallestPalindrome 1000 9999
+    smallest |> should equal 1002001
+    factors |> should equal [(1001, 1001)]

data/tracks/fsharp/exercises/palindrome-products/Program.fs

@@ -0,0 +1 @@
+module Program = let [<EntryPoint>] main _ = 0

data/tracks/fsharp/exercises/pangram/Pangram.fs

@@ -0,0 +1,3 @@
+module Pangram
+
+let isPangram (input: string): bool = failwith "You need to implement this function."

data/tracks/fsharp/exercises/pangram/Pangram.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Pangram.fs" />
+    <Compile Include="PangramTest.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <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="FsUnit.xUnit" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

data/tracks/fsharp/exercises/pangram/PangramTest.fs

@@ -1,65 +1,57 @@
-module PangramTest
+module PangramTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open Pangram
 
-[<Test>]
+[<Fact>]
 let ``Empty sentence`` () =
     let input = ""
-    Assert.That(isPangram input, Is.False)
+    isPangram input |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Pangram with only lower case`` () =
     let input = "the quick brown fox jumps over the lazy dog"
-    Assert.That(isPangram input, Is.True)
+    isPangram input |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Missing character 'x'`` () =
     let input = "a quick movement of the enemy will jeopardize five gunboats"
-    Assert.That(isPangram input, Is.False)
+    isPangram input |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Another missing character 'x'`` () =
     let input = "the quick brown fish jumps over the lazy dog"
-    Assert.That(isPangram input, Is.False)
+    isPangram input |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Pangram with underscores`` () =
     let input = "the_quick_brown_fox_jumps_over_the_lazy_dog"
-    Assert.That(isPangram input, Is.True)
+    isPangram input |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Pangram with numbers`` () =
     let input = "the 1 quick brown fox jumps over the 2 lazy dogs"
-    Assert.That(isPangram input, Is.True)
+    isPangram input |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Missing letters replaced by numbers`` () =
     let input = "7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog"
-    Assert.That(isPangram input, Is.False)
+    isPangram input |> should equal false
     
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Pangram with mixed case and punctuation`` () =
     let input = "\"Five quacking Zephyrs jolt my wax bed.\""
-    Assert.That(isPangram input, Is.True)
+    isPangram input |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Pangram with non ascii characters`` () =
     let input = "Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich."
-    Assert.That(isPangram input, Is.True)
+    isPangram input |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Panagram in alphabet other than ASCII`` () =
     let input = "Широкая электрификация южных губерний даст мощный толчок подъёму сельского хозяйства."
-    Assert.That(isPangram input, Is.False)
+    isPangram input |> should equal false
     

data/tracks/fsharp/exercises/pangram/Program.fs

@@ -0,0 +1 @@
+module Program = let [<EntryPoint>] main _ = 0

data/tracks/fsharp/exercises/parallel-letter-frequency/ParallelLetterFrequency.fs

@@ -0,0 +1,3 @@
+module ParallelLetterFrequency
+
+let frequency texts = failwith "You need to implement this function."

data/tracks/fsharp/exercises/parallel-letter-frequency/ParallelLetterFrequency.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="ParallelLetterFrequency.fs" />
+    <Compile Include="ParallelLetterFrequencyTest.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <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="FsUnit.xUnit" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

data/tracks/fsharp/exercises/parallel-letter-frequency/ParallelLetterFrequencyTest.fs

@@ -1,6 +1,7 @@
-module ParallelLetterFrequencyTest
+module ParallelLetterFrequencyTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open ParallelLetterFrequency
 
@@ -37,60 +38,51 @@ let starSpangledBanner =
     "O say does that star-spangled banner yet wave,\n" +
     "O'er the land of the free and the home of the brave?\n"
  
-[<Test>]
+[<Fact>]
 let ``No texts mean no letters`` () =
-    Assert.That(frequency [], Is.EqualTo(Map.empty))
+    frequency [] |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``One letter`` () =
-    Assert.That(frequency ["a"], Is.EqualTo(Map.ofList [('a', 1)]))
+    frequency ["a"] |> should equal (Map.ofList [('a', 1)])
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Case insensitivity`` () =
-    Assert.That(frequency ["aA"], Is.EqualTo(Map.ofList [('a', 2)]))
+    frequency ["aA"] |> should equal (Map.ofList [('a', 2)])
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Many empty texts still mean no letters`` () =
-    Assert.That(frequency (List.replicate 10000 "  "), Is.EqualTo(Map.empty))
+    frequency (List.replicate 10000 "  ") |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Many times the same text gives a predictable result`` () =
-    Assert.That(frequency (List.replicate 1000 "abc"), Is.EqualTo(Map.ofList [('a', 1000); ('b', 1000); ('c', 1000)]))
+    frequency (List.replicate 1000 "abc") |> should equal (Map.ofList [('a', 1000); ('b', 1000); ('c', 1000)])
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Punctuation doesn't count`` () =
     let freqs = frequency [odeAnDieFreude]
-    Assert.That(Map.tryFind ',' freqs, Is.EqualTo(None))
+    Map.tryFind ',' freqs |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Numbers don't count`` () =
     let freqs = frequency ["Testing, 1, 2, 3"]
-    Assert.That(Map.tryFind '1' freqs, Is.EqualTo(None))
+    Map.tryFind '1' freqs |> should equal None
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Letters with and without diacritics are not the same letter`` () =
     let freqs = frequency ["aä"]
-    Assert.That(freqs, Is.EqualTo(Map.ofList [('a', 1); ('ä', 1)]))
+    freqs |> should equal (Map.ofList [('a', 1); ('ä', 1)])
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``All three anthems, together`` () =
     let freqs = frequency [odeAnDieFreude; wilhelmus; starSpangledBanner]
-    Assert.That(Map.tryFind 'a' freqs, Is.EqualTo(Some 49))
-    Assert.That(Map.tryFind 't' freqs, Is.EqualTo(Some 56))
-    Assert.That(Map.tryFind 'o' freqs, Is.EqualTo(Some 34))
+    Map.tryFind 'a' freqs |> should equal <| Some 49
+    Map.tryFind 't' freqs |> should equal <| Some 56
+    Map.tryFind 'o' freqs |> should equal <| Some 34
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Can handle large texts`` () =
     let freqs = frequency (List.replicate 1000 [odeAnDieFreude; wilhelmus; starSpangledBanner] |> List.concat)
-    Assert.That(Map.tryFind 'a' freqs, Is.EqualTo(Some 49000))
-    Assert.That(Map.tryFind 't' freqs, Is.EqualTo(Some 56000))
-    Assert.That(Map.tryFind 'o' freqs, Is.EqualTo(Some 34000))
+    Map.tryFind 'a' freqs |> should equal <| Some 49000
+    Map.tryFind 't' freqs |> should equal <| Some 56000
+    Map.tryFind 'o' freqs |> should equal <| Some 34000

data/tracks/fsharp/exercises/parallel-letter-frequency/Program.fs

@@ -0,0 +1 @@
+module Program = let [<EntryPoint>] main _ = 0

data/tracks/fsharp/exercises/pascals-triangle/PascalsTriangle.fs

@@ -0,0 +1,3 @@
+module PascalsTriangle
+    
+let triangle rows = failwith "You need to implement this function."

data/tracks/fsharp/exercises/pascals-triangle/PascalsTriangle.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="PascalsTriangle.fs" />
+    <Compile Include="PascalsTriangleTest.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <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="FsUnit.xUnit" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

data/tracks/fsharp/exercises/pascals-triangle/PascalsTriangleTest.fs

@@ -1,34 +1,30 @@
-module PascalsTriangleTest
+module PascalsTriangleTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open PascalsTriangle
 
-[<Test>]
+[<Fact>]
 let ``One row`` () =
-    Assert.That(triangle 1, Is.EqualTo([[1]]))
+    triangle 1 |> should equal [[1]]
         
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Two rows`` () =
-    Assert.That(triangle 2, Is.EqualTo([[1]; [1; 1]]))
+    triangle 2 |> should equal [[1]; [1; 1]]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Three rows`` () =
-    Assert.That(triangle 3, Is.EqualTo([[1]; [1; 1]; [1; 2; 1]]))
+    triangle 3 |> should equal [[1]; [1; 1]; [1; 2; 1]]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Four rows`` () =
-    Assert.That(triangle 4, Is.EqualTo([[1]; [1; 1]; [1; 2; 1]; [1; 3; 3; 1]]))
+    triangle 4 |> should equal [[1]; [1; 1]; [1; 2; 1]; [1; 3; 3; 1]]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Five rows`` () =
-    Assert.That(triangle 5, Is.EqualTo([[1]; [1; 1]; [1; 2; 1]; [1; 3; 3; 1]; [1; 4; 6; 4; 1]]))
+    triangle 5 |> should equal [[1]; [1; 1]; [1; 2; 1]; [1; 3; 3; 1]; [1; 4; 6; 4; 1]]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Twenty rows`` () =
-    Assert.That(triangle 20 |> List.last, Is.EqualTo([1; 19; 171; 969; 3876; 11628; 27132; 50388; 75582; 92378; 92378; 75582; 50388; 27132; 11628; 3876; 969; 171; 19; 1]))
+    triangle 20 |> List.last |> should equal [1; 19; 171; 969; 3876; 11628; 27132; 50388; 75582; 92378; 92378; 75582; 50388; 27132; 11628; 3876; 969; 171; 19; 1]

data/tracks/fsharp/exercises/pascals-triangle/Program.fs

@@ -0,0 +1 @@
+module Program = let [<EntryPoint>] main _ = 0

data/tracks/fsharp/exercises/perfect-numbers/PerfectNumbers.fs

@@ -0,0 +1,5 @@
+module PerfectNumbers
+
+type Classification = Perfect | Abundant | Deficient 
+
+let classify n = failwith "You need to implement this function."

data/tracks/fsharp/exercises/perfect-numbers/PerfectNumbers.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="PerfectNumbers.fs" />
+    <Compile Include="PerfectNumbersTest.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <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="FsUnit.xUnit" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>